LineSlip Solutions is a cloud-hosted software company purpose-built for the commercial insurance industry

LineSlip Solutions

Or: How to make the perfect neck strap case for using a mobile phone with a smart stopwatch app as a full replacement for a handheld sports stopwatch. In the following, I will show you a quick way to attach a low-cost, yet comfortable strap to an affordable, , yet sturdy enough smartphone case. Together these provide the perfect complement for utility apps that require you to frequently switch between using the phone and getting your hands free for some other activity. products are hard to come by otherwise and everything but affordable. minimal Comparable FOR UTILITY APPS WITH FREQUENT PICK-UP If you are a regular smartphone user, most of your most frequented apps such as mobile games or chat applications make it quick and easy for you to handle them. Furthermore, you typically spend longer, continuous stretches of time using these apps. Once you pick up the phone, you find your preferred hand and finger position on the device and its screen, use the app for a while and, once done for good, re-stash the phone in a pocket or put it down on a surface such as the table right in front of you. Some utility apps, however, and stopwatch apps for sports are just one prominent example, require a different pattern of use: You pick up the phone in your preferred (often single-)hand position, make a few taps on the screen, then let go of the phone to use your hands otherwise, just to return to the smartphone moments later. When using a utility app on the go at the track, pool or somewhere else outdoors, there often is no proper surface to rest the phone on in between uses. So, you either constantly take out and re-stash your phone in some pocket. Or, you use a neckband (also referred to as smartphone necklace at times). A smartphone neckband comes with added drop protection and ideally works in such a way that you can blindly pick up the device in the required or preferred hand position. THE IDEAL NECKBAND FOR A SMARTPHONE The not so ideal solution for quick pickup and release of a smartphone For quick and easy use, the ideal neckband is attached close to BOTH bottom corners of the phone. Having these two separate points to attach a band to, protects the phone from turning and the neckband from twisting potentially multiple times like straps love to do. A single point of attachment such as the fifth-generation iPod touch devices had even built in (as shown in the picture), when used with a neckband instead of the accompanying lanyard loop, is prone to twisting in itself. Furthermore, when carrying multiple devices around the neck, these are likely to getting tangled up in nasty knots. The double-corner attachment makes sure that the screen of your android device, iPhone or iPod touch always stays in front. Attaching the neckband to the bottom of the device makes sure that, when you quickly slip your hand behind the phone and lift it closer to eye-level, the screen that hangs upside down on your chest stares right at you in the correct top-to-bottom orientation (as pictured). App ready to use on single-handed pick-up with just the right double-bottom strap attachement Unfortunately, smartphones do not come with a means to attach a neckband in the way outlined. In fact, most phones do not come with any hook to attach a strap to at all. There are products to screw a small, metal loop on top of, for example, an iPhone’s Lightning port. But those are highly experimental at best. If you happen to rely on frequent-pick-up utility apps and in particular, if you are a sports coach that wants to use a video, analytics or stopwatch app on site, this leaves you with few options: Buy a dedicated case with attachment points and strap already included, or go with a do-it-yourself options. HARDLY ANY READY-TO-BUY OPTIONS As the creator of a next-generation stopwatch app to replace one or even several traditional handheld stopwatches for sports coaches, parents and other frequent or occasional timekeepers, I had a keen interest in finding a ready-made solution. Regrettably, my extensive research came up rather short. Waterproof cases that I was originally most interested in where expensive and came without a proper neck strap. They also are bulky and no good for every-day use. Even worse, they are tough to get a device into and back out again. Simpler cases with a strap attached didn’t have the required double-corner attachment; and some more affordable water-proof covers, on top, left the smartphone screen rather hard to tap. That’s why I started to look into my own solution, dropping the preference for a waterproof solution. The latest iPhone 7, for example, is waterproof on its own anyways, and I expect this trend for water-resistant smartphones to continue. In my particular case, I acquired a 6th-generation iPod touch on ebay to let professionals try my high-end stopwatch app for a while, even when they didn’t own the required iPhone or iPod touch themselves. (The as-good-as-new, latest-generation iPod touch plus case and strap comes down to about 160$ (150€), which, together with the free smart stopwatch app gives a much more capable stopwatch then even the most high-end, handheld stopwatches on the market, which often go for as high as 200–300$/€. A similarly-priced, dedicated printer as the frequent, only export option — which my does not require — not yet included.) stopwatch app with its Excel export INGREDIENTS OF A HANDCRAFTED NECKBAND CASE These are the just three simple parts I combined to a neckband and case that is not only affordable, but also quite easy to apply to a naked smartphone as well as take off again. I bought a 0.5mm tinker/fishing line (polyamid/nylon thread) on Amazon. (Being in Germany, I actually bought .) I only needed about 20cm (15in), though. So, if you have a piece of a similar fishing line at home (we almost all do, don’t we!) use it. I just made sure that I use a sturdy enough line to not risk tearing it and dropping an expensive smartphone (or iPod) in the process. The 0.5mm (or 0.45mm to be exact; about 0.02in) seems plenty. like this one that one I acquired a thin, transparent casing like ( , , ) also on Amazon, also making sure it appeared to be reasonably sturdy, in particular when pierced. Notice that these are all cases! (I actually bought in Germany, which is for the 6th-generation iPod touch, on which I tried the procedure.) this one for iPhone 6S 6S Plus iPhone 7 7 Plus soft this case Finally, I took the strap from a handheld stopwatch that wouldn’t work anymore. (In the process, I cleaned it in hot water with dish detergent to make it shine as new.) As an alternative, I also tried the neckband of an expired event badge, which did the job just fine, too. I even removed the single hook it came with, as this is no good in my case. MINIMAL COSTS This is what I paid for the parts on Amazon: Cost   Shipping  Total  Item€3.95  €1.95     €5.90  Semi-transparent iPod touch silicon case€1.41  €2.05     €3.46  Nylon thread/fishing line./.                     Neckband Prices in US-$ are almost the same these days. If you absolutely can’t find a suitable piece of nylon thread/fishing line at home or amongst a friend’s assets, even if you buy a new roll like the one I have listed, this is something you need at home all the time anyways. Furthermore, for some sort of (pseudo-)neckband/necklace, you can use any strap you already have, for example, from an event tag or an old photo camera, or simply make one yourself from an existing thread, thin rope, etc. Therefore, for all practical purposes, I consider neckband and thread as FREE. This leaves me with . costs for materials at €5.90 (US $6.30) ASSEMBLING NECKBAND AND CASE 1. Drilling holes I drilled two holes right in the middle of each of the case’s BOTTOM corners using a rather thin, sub-millimeter drill. I used holes as small as possible to affect the stability of the plastic case as little as possible. If you don’t have such a thin drilling means available, asking your dentist for help at the next appointment is a good option ;-) Dentists have plenty of those drills and a diamond dentist drill makes it through plastic just fine. (The plastic didn’t leave any permanent residue on the drill.) Drilling holes into the BOTTOM corners of you new stopwatch-replacement smartphone cover A simple needle will make it through the case just fine, too, I believe. I didn’t go with that option, however, because the resulting hole may be prone to tearing uncontrollably when pulling on the case in use, I imagine. This may result in dropping the smartphone, which I don’t like to risk. One thing I would do different next time: I would put the holes a bit further to the center. This will be slightly less sturdy. However, as you can see in the pictures, my final product has the neckband stand out beyond the long edges of the case. This is slightly in the way when holding iPod/smartphone at the lower end. There is a limit to how far in you can put the holes, though, as it is undesirable to get too close to the gaps for the likes of headphone plugs. A softer neckband would mitigate the, really just minor, problem, too. As would giving the fishing line by which I fastened the neck strap to the case a bit more length. (If you look closer at some of my photos, you’ll also notice that I drilled an extra set of holes on the wrong, top side of the case. I did this on purpose, of course, to show how NOT to do it. Or, actually: The first time I did this, I was really in a hurry catching a train and didn’t think properly. Attaching the neckband at the top would make the phone be upside-down when quickly picked up with one hand, not what we want.) 2. Attaching the thread I cut off about 20–30cm (8–12in) of the fishing line and checked that the resulting piece didn’t have any prior damage, which would reduce the resilience of the thread against unwanted pulling on the device. I then put each end of the line through one of the holes in the case from the inside and looped it back through the same hole. Through the two resulting loops I then put the neckband from dysfunctional stopwatch or, alternatively, event badge. Then I locked both ends of the thread in a quadruple (or more) knot, pulling the whole finishing line somewhat, but not tight. With the fishing line more tightly knit, the neckband becomes more rigidly attached to the case and tends to stick out to the sides even more, which is not what I want. too 3. Final assembly I now just made sure that the knot was about in the middle of the case so that when I put the smart device into the case it would push out the knot at the center gap (usually for a power adapter) so that the knot wouldn’t leave a bump, which I thought may contribute to having the device slip out of the case slightly more easily. The final structure seems to be rather sturdy and the smartphone tightly embedded in the case, even with a bit of fishing line between case and device. 4. One more step (optional): Cut out button There is an optional step, if you want to use the resulting product with a stopwatch app such as the that I invented. One significant aspect of this stopwatch app is its support for pressing a physical volume button instead of the (in my patent-pending, new multi-timing procedure) single, virtual time button. Many photo apps also take advantage of at least one of a smartphone’s physical buttons. Naturally, the position of the button will differ on different devices. However, you will easily adapt the following instructions to make a physical button accessible more easily despite the neckband case: smart stopwatch for sports coaches The case hides the physical button behind a layer of plastic/silicon, which, although somewhat flexible, delays the button press. For a precision stopwatch and possibly a photo app, too, this is undesirable. Therefore, I liberally cut out the lower of the two volume buttons of the iPod touch device I tested this on. That’s the ‘-‘ button in the case of iPhone and iPod touch. I used nail scissors in favor of a carpet knife that I also tried, yet which turned out to be too coarse and not quite sharp enough. After finishing the initial hole, I tried to reduce sharp edges on the case further by cutting the hole in the form of a crater, which is wider around the outer perimeter. Still, I made sure NOT to cut the inner frame (on the phone’s screen side) of the case or leave too little material there. This is, because cutting this off will make the smartphone fall out of the case much more easily. Your index finger will tell you when the cut-out is about right. Spending some effort on getting this hole to a comfortable level is worth the time for sports timing at least, as a stopwatch will require you to press this button quite frequently. That’s it. I was somewhat surprised that I didn’t find a satisfying commercial solution at a reasonable price. But in the end, I am quite happy with the do-it-yourself solution I found myself. Questions, suggestions or comments? Get in touch at marco@smartstopwatch.com Oh, and if you ever need a professional sports stopwatch that replaces one or even several traditional stopwatches, or you just don’t want to waste any money on even a cheap, old-school handheld stopwatch, check out my . stopwatch app for iPhone on the Apple app store DISCLAIMER: Please use the instructions at your own risk. I cannot be held responsible for any damages to your smartphone or any other damages related to following these instructions or using the resulting product. Originally published at smartstopwatch.com . https://upscri.be/hackernoon/

DIY: How I Made a Mobile Phone Neck Strap Lanyard Case for $6

Document or text classification is one of the predominant tasks in Natural language processing. It has many applications including news type classification, spam filtering, toxic comment identification, etc. In big organizations the datasets are large and training deep learning text classification models from scratch is a feasible solution but for the majority of real-life problems your dataset is small and if you want to build your machine learning model you need to be smart. In this article (originally posted by on the ), I will talk about pragmatic approaches towards text representation which make document classification on small datasets doable. Shahul ES neptune.ai/blog Text Classification 101 The text classification workflow begins by cleaning and preparing the corpus out of the dataset. Then this corpus is represented by any of the different text representation methods which are then followed by modeling. In this article, step of this pipeline. we will focus on the “Text Representation” Example text classification dataset We will use the data from kaggle competition. Here, the Real or Not? NLP with disaster tweets task is to predict which tweets are about real disasters and which ones are not. If you want to follow the article step-by-step you may want to install all the libraries that I used for the analysis. Let’s take a look at our data, pandas pd

tweet= pd.read_csv( )
test=pd.read_csv( )

tweet.head( ) import as '../input/nlp-getting-started/train.csv' '../input/nlp-getting-started/test.csv' 3 The data contains of id, keyword, location, text, and target which is binary. We will only consider the tweets to predict the target. print( .format(tweet.shape[ ],tweet.shape[ ]))
print( .format(test.shape[ ],test.shape[ ])) 'There are {} rows and {} columns in train' 0 1 'There are {} rows and {} columns in test' 0 1 The training dataset has less than 8000 tweets. That, combined with the fact that tweets are 280 characters tops make it a tricky, small(ish) dataset. Text data preparation Before we get into any NLP task, we need to do some data preprocessing and basic cleaning. It is not a focus of this article but if you want to read more about this step check out this . article In short, we will: : the process by which sentences are converted to a list of tokens or words. Tokenize : drop words like ‘a’ or ‘the’ Remove stopwords : reduce the inflectional forms of each word into a common base or root ( . Lemmatize “studies”, “studying” -> “study”) new_corpus=[]
	
	lem=WordNetLemmatizer() text df[ ]:
    	words=[w w word_tokenize(text) (w stop)]
  	 
    	words=[lem.lemmatize(w) w words]
  	 
    	new_corpus.append(words) new_corpus

corpus=preprocess_news(df) : def preprocess_news (df) '''Function to preprocess and create corpus''' for in "question_text" for in if not in for in return Now, let’s see how to represent this corpus so that we can feed this into any machine learning algorithm. Text Representation Text cannot be used directly as input to a machine learning model but needs to be represented in the numeric format first. This is known as text representation. Countvectorizer Countvectorizer provides an easy method to vectorize and represent a collection of text documents. It tokenizes the input text and builds a vocabulary of known words and then represents the documents using this vocabulary. Let’s understand it by using an example, text = [ ] vectorizer = CountVectorizer() vectorizer.fit(text) print(vectorizer.vocabulary_) vector = vectorizer.transform(text) print(vector.shape)
print(type(vector))
print(vector.toarray()) "She sells seashells in the seashore" # create the transform # tokenize and build vocab # summarize # encode document # summarize encoded vector You can see that the Coutvectorizer has built a vocabulary out of the given text and then represented the words using a . We can try and transfer another text using this vocabulary and observe the output to get a better understanding. numpy sparse matrix vector=vectorizer.transform([ ])
vector.toarray() "I sell seashells in the seashore" You can see that: The index positions 3 and 4 have zeroes meaning that these two words are not present in our vocabulary and all other positions have 1 meaning that these words are present in our vocabulary. The corresponding words missing from the vocabulary are “sells” and “she”. Now that you understand how Coutvectorizer works, we can fit and transform our corpus using it. vec=CountVectorizer(max_df= ,max_features= )
vec.fit(df.question_text.values)
vector=vec.transform(df.question_text.values) 10 10000 You should know that Countvectorizer has a few important parameters that you should adjust to your problem: : build a vocabulary that only considers the top n tokens ordered by term frequency across the corpus. max_features : When building the vocabulary ignore terms that have a token frequency strictly lower than the given threshold min_df : When building the vocabulary ignore terms that have a token frequency strictly higher than the given threshold. max_df What usually helps with selecting reasonable values (or ranges for hyperparameter optimization methods) is good exploratory data analysis. Check out my other article to read about it. TfidfVectorizer One issue with Countvectorizer is that common words like “the” will appear many times (unless you remove them at the preprocessing stage) and these words are not actually important. One popular alternative is Tfidfvectorizer. It is an acronym for Term frequency-inverse document frequency. : This summarizes how often a given word appears within a document. Term Frequency : This downscales words that appear a lot across documents. Inverse Document Frequency Let’s look at an example: sklearn.feature_extraction.text TfidfVectorizer text = [ , , ] vectorizer = TfidfVectorizer() vectorizer.fit(text) print(vectorizer.vocabulary_)
print(vectorizer.idf_) vector = vectorizer.transform([text[ ]]) print(vector.shape)
print(vector.toarray()) from import # list of text documents "She sells seashells by the seashore" "The sea." "The seashore" # create the transform # tokenize and build vocab # summarize # encode document 0 # summarize encoded vector The vocabulary again consists of 6 words and the inverse document frequency is calculated for each word, assigning the lowest score to “the” which occurred 4 times. Then the scores are normalized between 0 and 1 and this text representation can be used as input into any machine learning model. Word2vec The big issue with the above approaches is that the context of the word is lost when representing it. Word embeddings provide a much better representation of the words in NLP by encoding some context information. It provides a mapping from a word to a corresponding n-dimensional vector. Word2Vec was developed at Google by Tomas Mikolov, et al. and uses a to learn word embeddings. The vectors are learned by understanding the context in which the word occurs. shallow neural network Specifically, it looks at co-occurring words. Given below is the co-occurrence matrix for the sentence “The cat sat on the mat”. Word2vec is composed of two different models: (CBOW) model can be thought of as learning word embeddings by training a model to Continuous Bag of Words predict a word given its context. model is the opposite, learning word embeddings by training a model to Skip-Gram predict context given a word. The basic idea of word embedding is words that occur in similar context tend to be closer to each other in vector space. Let’s check how to implement word2vec in python. gensim gensim.models Word2Vec

model = gensim.models.Word2Vec(corpus, 
                               min_count = , size = , window = ) import from import 1 100 5 Now you have created your word2vec model, some of the important parameters that you can actually change and observe the differences are, : this indicates the embedding size of the resulting vector for each word. size : When building the vocabulary ignore terms that have a document frequency strictly lower than the given threshold min_count : The number of words surrounding the word is considered when building the representation. Also known as the window size. window In this article, we focus on pragmatic approaches for small datasets and we will use pre-trained word vectors instead of training vectors from our corpus. This method is guaranteed to yield better performance. First, you will have to download the trained vectors from . Then you can load the vectors using gensim. here gensim.models.KeyedVectors load_word2vec_format word2vecDict = load_word2vec_format( ,
        binary= , unicode_errors= )
    embeddings_index = dict() word word2vecDict.wv.vocab:
        embeddings_index[word] = word2vecDict.word_vec(word) embeddings_index from import : def load_word2vec () '../input/word2vec-google/GoogleNews-vectors-negative300.bin' True 'ignore' for in return Let’s check the embedding, w2v_model=load_word2vec()
w2v_model[ ].shape 'London' You can see that the word is represented using a 300-dimensional vector. So every word in your corpus can be represented like this and this embedding matrix is used to train your model. FastText Now, let’s learn about fastText which is an extremely useful module available in . FastText has been developed by Facebook and yields great performance and speed in text classification tasks. gensim It supports both Continuous Bag of Words and Skip-Gram models. The main difference between previous models and FastText is that it breaks the word in several n-grams. Let’s take the word orange for example. The trigrams of word orange are,org,ran,ang,nge(ignoring the starting and ending boundaries of the word). The word Rare words or typos can now be properly represented since it is highly likely that some of their n-grams also appears in other words. embedding vector (text representation)for orange will be the sum of these n-grams. For example, for a word like , which might never have been in any corpus, gensim might return any two of the following solutions: a zero vector or a random vector with low magnitude. stupedofantabulouslyfantastic , however, . In this particular case, the final vector might be closer to the vectors of fantastic and fantabulous. FastText can produce better vectors by breaking the word into chunks and using the vectors for those chunks to create a final vector for the word Again, we will use a pre-trained model rather than training our own word embeddings. For this, you can download pre-trained vectors from . here Each line of this file contains a word and it’s a corresponding n-dimensional vector. We will create a dictionary using this file for mapping each word to its vector representation. gensim.models FastText print( )
	embeddings_index = {}
	f = open( ,encoding= ) line tqdm(f):
    	values = line.strip().rsplit( )
    	word = values[ ]
    	coefs = np.asarray(values[ :], dtype= )
    	embeddings_index[word] = coefs
	f.close()
	print( % len(embeddings_index)) embeddings_index

embeddings_index=load_fastext() from import : def load_fasttext () 'loading word embeddings...' '../input/fasttext/wiki.simple.vec' 'utf-8' for in ' ' 0 1 'float32' 'found %s word vectors' return Let’s check the embedding for a word, embeddings_index[ ].shape 'london' GloVe (Global vectors for word representation) GloVe stands for global vectors for word representation. It is an unsupervised learning algorithm developed by Stanford. The basic idea of GloVe is to derive a semantic relationship between words using a co-occurrence matrix. The idea is very similar to word2vec but there are slight differences. Go here to read more. For this, we will use which are trained on large corpora. This is guaranteed to perform better in almost any situation.You can download it from . pre-trained glove vectors here After downloading we can load our pre-trained word model. Before that, you should understand the format in which it is made available. Each line contains a word and its corresponding n-dimensional vector representation. Like this, So, to use this you should first prepare a dictionary that contains the mapping between word and corresponding vector. This can be called an embedding dictionary. Let’s create one for our purpose. embedding_dict = {}
    path = open(path, ) f: line f:
            values = line.split()
            word = values[ ]
            vectors = np.asarray(values[ :], )
            embedding_dict[word] = vectors
    f.close() embedding_dict


embeddings_index = load_glove() : def load_glove () '../input/glove-global-vectors-for-word-representation/glove.6B.100d.txt' with 'r' as for in 0 1 'float32' return Now, we have a dictionary containing every word in the glove pre-trained vectors and their corresponding vector in a dictionary. Let’s check the embedding for a word. embeddings_index[ ].shape 'london' Till now we were dealing with representing words and these techniques are most useful for word-level operations. Sometimes we need to explore operations. These encoders are called sentence encoders. sentence level A good sentence encoder is expected to encode sentences in such a way that the vectors of similar sentences have a minimal distance between them in the vector space. For example, It is sunny today It is rainy today It is cloudy today. These sentences will be encoded and represented so that they are close to each other in the vector space. Let’s move on and check how to implement universal sentence encoder and find similar sentences using it. You can download the pertained vectors from . here We will load the module using the TensorFlow hub. module_url = embed = hub.load(module_url) "../input/universalsentenceencoderlarge4" # Import the Universal Sentence Encoder's TF Hub module Next, we will create the embedding for each sentence in our list. sentence_list=df.question_text.values.tolist()
sentence_emb=embed(sentence_list)[ ].numpy() 'outputs' Here is an article to read more about universal sentence encoder. Elmo, BERT, and others. When using any of the above embedding methods one thing we forget about is the context in which the word was used. This is one of the main drawbacks of such word representation models. For example, the word word “stick” will be represented using the same vector independent of the context in which it was used which doesn’t make much sense. With the recent developments in the field of NLP and models like BERT (bidirectional encoder representation from transformers), this has been made possible. Here is an article to read more. Text Classification In this section, we will prepare the embedding matrix which is passed to the Keras Embedding layer to learn text representations. You can use the same steps to prepare the corpus for any word-level embedding methods. Let’s create a word index and fix a maximum sentence length, pad each sentence in our corpus using and . Keras Tokenizer pad_sequences MAX_LEN= tokenizer_obj=Tokenizer()
tokenizer_obj.fit_on_texts(corpus)
sequences=tokenizer_obj.texts_to_sequences(corpus)

tweet_pad=pad_sequences(sequences,
                        maxlen=MAX_LEN,
                        truncating= ,
                        padding= ) 50 'post' 'post' Let’s check the number of unique words in our corpus, word_index=tokenizer_obj.word_index
print( ,len(word_index)) 'Number of unique words:' Using this word index dictionary and embedding dictionary you can create an for our corpus. This embedding matrix is passed on to the of the neural network to learn word representations. embedding matrix embedding layer num_words = len(word_index)
    embedding_matrix = np.zeros((num_words, emb_size)) word, i tqdm(word_index.items()): i > num_words: emb_vec = embedding_dict.get(word) emb_vec :
        embedding_matrix[i] = emb_vec embedding_matrix : def prepare_matrix (embedding_dict, emb_size= ) 300 for in if continue if is not None return We can define our neural network and pass this embedding index to the Embedding layer of the network. We pass the vectors onto the Embedding layer and set to prevent the weights from being updated. trainable=False inp = Input(shape=(MAX_LEN,))

    x = Embedding(num_words, embedding_matrix.shape[ ], weights=[embedding_matrix],
                  trainable= )(inp)

    x = Bidirectional(
        LSTM( , return_sequences= , name= , 
             dropout= , recurrent_dropout= ))(x)

    x = GlobalAveragePool1D()(x)
    x = Dense( , activation= )(x)
    model = Model(inputs=inp, outputs=x)

    model.compile(loss= ,
                  optimizer= ,
                  metrics=[ ]) model : def new_model (embedding_matrix) 1 False 60 True 'lstm_layer' 0.1 0.1 1 "sigmoid" 'binary_crossentropy' 'adam' 'accuracy' return For example, to run the model using word2vec embeddings, embeddings_index=load_word2vec()
embedding_matrix=prepare_matrix(embeddings_index)
model=new_model(embedding_matrix)

history=model.fit(X_train,y_train,
                  batch_size= ,
                  epochs= ,
                  validation_data=(X_test,y_test),
                  verbose= ) 8 5 2 You can call your desired type of embeddings and follow the same steps to implement any of them. Comparison So which text classification method worked best in our example problem? You can use Neptune to compare the performance of our model using different embeddings by simply setting up an experiment. Glove embeddings performed a little better in test sets when compared to the other two embeddings. You may be able to get better results by doing extensive cleaning on the data and tuning the model. You can here if you want to. explore experiments Final Thoughts In this article, we discussed and implemented different feature representation methods for text classification that you can use for smaller datasets. Hopefully, you will find them useful in your projects. This article was originally posted on the Neptune blog. If you liked it, you may like it there :) You can also find me tweeting @Neptune_a i or posting on LinkedIn about ML and Data Science stuff.

Document Classification Process: 7 Pragmatic Approaches For Small Datasets

A parable about missed deadlines and over-engineering Some time ago I attended to a coding interview for the position of Data Scientist at one start-up. I felt myself well-prepared and confident, practicing lots of programming puzzles, coding various Machine Learning techniques from scratch, and having several years of programming experience under the belt. What can go wrong? Unfortunately, I failed at the thing that doesn’t have any relation to the Gradient Descent methods or Time Complexity analysis. No, the failure was related to something very different and much more complicated. It was a Tic-Tac-Toe game! I bet at this moment, some of you just close this story with thoughts: What, a Tic-Tac-Toe game? How can one fail to implement such a simple thing? You should be a total newbie, man, not being able to solve such a trivial exercise! The rest of you, who decided to give me a chance, I invite you to read my story and probably this experience help you to escape similar mistakes in your software development practice and be more careful. Photo by Quino Al on Unsplash How Can Anything Go Wrong Here? Now let me explain the interview task more thoroughly to give you enough context and understanding of the project’s scope. The following list enumerates the minimal requirements. Terminal-based interface. Turn-based gameplay; the one player makes a move after another one. At the very beginning and after each turn, the game shows whose turn it is, and allows to make a choice. When the turn is submitted, the game automatically shows a new board’s state and analyzes if there is a winner. If there is one, the UI shows information about the winner, and the game ends. The game is written in Python ≥ 3.x. Sounds very straightforward, right? The greatest twist here is a . You’re only given a to build the MVP, i.e., working terminal-based game for two players. Also, there is an additional list of priorities that clarify and extend the design requirements. Note that they list in . time limit 1 hour the order of decreasing importance The game meets the minimum requirements stated above. The UI is intuitive and doesn’t require additional instructions. The code is well-structured, compact, and easy to read. Tests are proving the correctness of the developed program and its components. The game can handle incorrect input. The UI is convenient. The code uses modern language features and libraries. Ok, great, the requirements are clear. Everything looks pretty simple and its time to start building the code! It shouldn’t be too tricky… Photo by Ant Rozetsky on Unsplash How I Know How To Prioritize Things As soon as I’d read the document with requirements, my thoughts were: . I wanted to build something fancy and interactive. Up to this moment, I’ve developed many CLI tools, and simple terminal experience wasn’t enough. So I chose the library to make things interactive and convenient. (I know, it could sound strange to talk about “convenience” of a terminal-based interface, but still…) Hey, the basic gameplay of a Tic-Tac-Toe game is very trivial so let’s focus on the UX and handling the input at the beginning, and then build the rest of the game logic curses There is one small question here: Here is a small snippet to explain what I am talking about. The code below shows the simplest program to interactively with a breakpoint. How would you debug a program that controls the terminal? curses curses

def main(term):
    term.clear() i range( ):
        # to debug after curses mangled the terminal
        breakpoint()
        term.addstr(i, , f )
    term.refresh()
    term.getkey() __name__ == :
    curses.wrapper(main) import for in 10 try 0 'String: {i + 1:d}' if '__main__' View codes on Github here Looks nice, right? Until you try to run it. Having an interactive UI wasn’t a strict requirement, as you see from the list shown above. Still, this thing drained my attention and a considerable part of the allocated time. When you run this snippet, it not shows you what you could expect. As you have probably already guessed, the take control over the terminal session, and when a debugger tries to render its interface, things are . curses totally broken Not a something you would like to see when running a debugger I’d spent a whole lot of time trying to set things up and deal with a broken debugger. Sure enough, the precious minutes wasted without bringing any value to the developed program. The most interesting thing here is that having an interactive UI wasn’t a strict requirement, as you see from the list shown above. Still, this thing drained my attention and a considerable part of the allocated time. It Is Easy To Refactor This God-Class Later After I’d gave up my attempts to tame the terminal, I started building the game logic. The main class called (yes, a pretty unusual name for a class that manages the game) was responsible for storing the board state, switching the active player, and managing the whole game process. Game As you already know, I was running out of time, so I’d tried to focus on the building working solution and put off the refactoring for the very end of the process. After some time, the was responsible not only for the gameplay but also rendered the board, including a few hard-coded constants and so on. Without notice, my class became responsible for . Game Game everything Ad-hoc solutions and quick patches had led to the avalanche of bad code without time to fix it Expectation vs Reality from the world of Computer Programming So as you can guess, I didn’t have enough time to factor out this AllmightyGame class into something more manageable and light-weighted. It becomes a great illustration of instead. Ad-hoc solutions and quick patches had led to the avalanche of bad code without time to fix it. It seems that distinguishing the clean code from the ugly one is a more simple thing than spotting how it from one category into another. God-class anti-pattern slowly slides Writing Tests Takes Too Much Time An ugly game logic class, a fragile UI, and the time given to complete the task is almost over. Not bad for such a “simple” thing! How can we safe a bit of time to fix all this mess? Which part of the software development process seems to be the one we can easily drop without much consequences? The answer is unit tests! The code is so compact that you can see every class and function; we can safely jump straight into application logic coding instead of writing these extra functions, right? Wrong. Even with the simplistic and trivial programs, you need You still need to write some to run your program, and you are going to execute it very often during the development process. These entry points are precisely the thing tests give you. somehow verify that your input generates a valid output. entry point The tests not only don’t add too much overhead to your code, but they also bring many benefits to the development process, even for pretty simple, toy programs Moreover, writing tests has a significant effect on your API building process: it forces you to decouple modules and untangle pieces of your system. See the snippet below. You need to verify that game logic works, and the most straightforward way to do so is to pass the game state from outside. Then you only need to call your winner checking function and see if it works as expected. Otherwise, you would need to run the game UI, and type turns manually. Even for small game states, it would steal a few seconds of your time on each run, not talking about testing bigger boards. pytest

@pytest.mark.parametrize( , [ , , ])
def test_game_has_winner(state):
    game = Game(state)
    assert game.has_winner() = state_from_string(state)

    def has_winner(self):
        pass  # check rows, columns, and diagonals

def state_from_string(line): [list(row) row line.split( )] import 'state' 'ooo|x.x|..x' 'xo.|xo.|x..' 'x..|.xo|o.x' : ( , ): . class Game def __init__ self state self state return for in '|' View codes on Github here Therefore, the tests not only don’t add too much overhead to your code, but they also bring many benefits to the development process, even for pretty simple, toy programs. I believe there is an opposite tendency actually: the tests could even and help to make it better. One should think twice before shrinking testing to save time. speed up the development process Lessons Learned Sure enough, this little story was written not to tell you how to deal with terminal rendering troubles or write puzzle games. It is musing about Software Development in general. One could find this “parable” quite shallow with lots of obvious mistakes I’d made. Well, good for you! You are a much better developer than I am. Nevertheless, I decided to share this failure with the rest of us who feel confident and experienced but sometimes forget about such “mundane things” like deadlines, KISS, and MVP. Tight time limits and perceived task’s simplicity could play a bad joke of you, and I am talking not only about test tasks but the daily development process as well. So let’s go through the lessons we can learn from this story. If you don’t have a working product, everything else doesn’t make much sense. I’ve seen similar things in my carrier when a company starts with building fancy customized dashboards, a bunch of cross-platform applications, tries to account all possible edge cases when it would be more beneficial to focus on the minimal logic and not to spread the efforts. Don’t put the horse before the cart. It becomes evident when you’re given just an hour to complete the task. Such a short period highlights things that are true for a broader scope as well. Moreover, long development timespan can easily hide the issue. Being busy doesn’t imply making progress. Tests can’t guarantee the absence of bugs, but they force you to separate the code into smaller fragments, decouple submodules, inverse dependencies, and in general, write a cleaner API. It is a pretty good method to structure the thinking process and better understand the requirements. Try to use test-driven development approach whenever it’s possible. At least, at the very beginning of the development process. Even when the task seems to be super easy, resits the urge to combine its implementation with the learning of a new framework. Go with the technologies you know best. You should keep the convenience of the users in mind but make of it an ultimate goal probably not a good idea. This point has lots in common all the previous ones. Following accidental requests from your customers, you tend to ignore testing, making ad-hoc changes, hacking the codebase, and essentially “overfitting” the quality of your product. Don’t put the user’s convenience before the clean code. Many of these things could seem obvious and many times repeated. (Not talking about plenty of great books). Nevertheless, I believe that every of us has a chance to fall into the same trap, and it is a good idea to remind yourself about these simple observations every once in a while to be in a good fit and make better decisions. Have you ever had similar experience during your developer’s carrier? Or if you’re an employer, which kind of tasks you prefer to give to your candidates? What do you think about such type of “stress-testing”? Would be glad to hear your thoughts!

How To Fail A Coding Interview

In the modern world, content design holds immense significance. Design can make or break a business. It influences potential customers and whether they like a business or not. A well-designed piece of content can grab attention and communicate the intended message effectively. Modern-day design tools provide a treasure trove of useful features. However, there are still a few challenges that designers face. This article focuses on one such challenge. Finding the ideal image(s) or text that works best for a design involves some amount of experimentation. This involves swapping out the images or text captions manually to see what fits. It is time-consuming to do so and there is a clear need for a faster way. Data Driven automation involves finding suitable images and text, not through manual experimentation, but instead by cycling through different combinations of assets without manual intervention. Problem Quick and easy swapping of assets in a design template to preview multiple design outcomes in order to speed up decision-making. Solution The asset boxes on the design template can be tagged with unique IDs. We can then use these IDs to map out the relevant assets. A database is used to store all the relevant assets, alongside their corresponding IDs. The designer can then dynamically populate the template with the stored assets, allowing him to preview multiple design outcomes efficiently. Implementation We shall use , an repository, by Klaus Schaefer to build the solution. It’s a prototyping tool that provides a way to build multiple templates in parallel. The terminology used by Quant UX for asset boxes is ‘widgets’ whereas text captions are called ‘labels’. Quant UX open-source Vue JS For this implementation, the focus will lie solely on image and text assets. A CSV file will be used to store these assets. Text will be stored directly, while images will be uploaded and their URLs stored in the file. The initial row of the file will contain the unique IDs used for asset mapping, while the following rows will contain the variations of data we are interested in previewing. The RenderFactory module in the src/core folder is responsible for rendering both image and text assets. As part of our implementation, we will write two new functions — updateLabelCustom and updateImageCustom into this module. These will be used to render our uploaded assets. Both functions are passed to the widget (asset box) and the corresponding asset as input parameters. updateLabelCustom (widget, value) {
  let node = this.getLabelNodeById(widget);
  if (node) {
   this.setInnerHTML(node, value)
  }
 }

 updateImageCustom (widget, value) {
  let imgCntr = this._imageNodes[widget];
  this._set_customBackgroundImage(imgCntr, value)
 }

// setInnerHTML and _set_customBackgroundImage are factory methods 
// provided by Quant The next step involves the upload of our CSV file. We will add Upload, Add, and iteration buttons to the toolbar. The iteration buttons are not important at this stage, but will will be required later to cycle through our uploaded assets. These buttons are added to the Toolbar.vue file located in the src/canvas/toolbar folder. <a class="MatcToolbarItem MatcToolbarIconNoSmooth" data-dojo-attach-point="uploadButton">
    <span class="MatcToolbarLabel">Upload</span>
</a>

<a class="MatcToolbarItem MatcToolbarIconNoSmooth" data-dojo-attach-point="addButton">
    <span class="MatcToolbarLabel">Add</span>
</a>

<a class="MatcToolbarItem MatcToolbarIconNoSmooth" data-dojo-attach-point="iteratePreviousButton">
    <span class="MatcToolbarLabel">⪻</span>
</a>

<a class="MatcToolbarItem MatcToolbarIconNoSmooth" data-dojo-attach-point="iterateNextButton">
    <span class="MatcToolbarLabel">⪼</span>
</a> Clicking on the Upload button triggers a popup. Once the CSV file is uploaded through this popup, it triggers the onCustomFileUpload function, which converts the CSV into a JavaScript object. onCustomFileUpload: function (e) {
   const file = e.target.files[0];
   const reader = new FileReader();
   reader.readAsText(file);
   reader.onload = (e) => {
    let csv = e.target.result;
    const lines = csv.split('\n')
    let result = []
    const headers = lines[0].split(',');
    headers[headers.length - 1] = headers[headers.length - 1].slice(0, -1);

    lines.map(l => {
     const obj = {}
     const line = l.split(',')
     line[line.length - 1] = line[line.length - 1].slice(0, -1);
     headers.map((h, i) => {
      obj[h] = line[i]
     })
     result.push(obj)
    })
    result = result.slice(1);
    addNewData(result);
   };
  }, We shall use the Quant UX functionality that allows for widget naming, and use these names as unique IDs. Next, the add button is clicked. This runs the addCustom() method. This method iterates over all the widgets on the screen. If the widget has the same name as the name given on the CSV file, then the image or text asset gets associated with it. let widgets = this.model.widgets;
let widgetNames = Object.keys(widgets);

for (let i = 0; i < widgetNames.length; i++) {    // Iterating through the image, and assigning asset based on
    if (widgets[widgetNames[i]].type == "Image") {    // whether the widget is an image or text
        let imgObj = {
            url: newCustomData[this.iterateCount][widgets[widgetNames[i]].name],
            name: widgetNames[i] + "image",
        };
        this.model.widgets[widgetNames[i]].style.backgroundImage = imgObj;
        this.canvas.customSetting(
            widgetNames[i],
            newCustomData[this.iterateCount][widgets[widgetNames[i]].name],
            true
        );
    } else {
        this.model.widgets[widgetNames[i]].props.label =
            newCustomData[this.iterateCount][widgets[widgetNames[i]].name];
        this.canvas.customSetting(
            widgetNames[i],
            newCustomData[this.iterateCount][widgets[widgetNames[i]].name],
            false
        );
    }
} Once the assets have been associated with the widgets on the template, all that’s left to do is preview. The iteration buttons are used to cycle through the assets. With each iteration, the subsequent row from the CSV file is dynamically populated onto the assigned widget, allowing a different preview for each iteration. And that’s how it’s implemented! This solution can benefit designers in three ways. : This approach significantly reduces the time spent on swapping and experimenting with assets. Time Efficiency : The ability to easily iterate through various assets, encourages the exploration of more creative options. It allows the designer to consider a broader range of design possibilities. Enhanced Creativity : Previewing different asset combinations, helps the designer select the most effective design elements. Informed Decision-making The forked Quant UX repository the implementation is built upon can be found . Exact details on the implementation can be found in the Readme. here

Data-Driven Automation for Content Design

The Hunting Wasps by Jean-Henri Fabre, is part of the HackerNoon Books Series. You can jump to any chapter in this book here . THE FLY-HUNT Chapter XV. THE FLY-HUNT After our list, in the last chapter, of the fare on which the Bembex feed in the larval form, it behoves us to seek the motive that induces these Wasps to adopt a method of victualling so exceptional among the digger-insects. Why, instead of previously storing a sufficient quantity of provisions on which the egg could be laid—which would enable the mother to close the cell immediately afterwards and never to return to it—why, I ask, does she tie herself down for a fortnight to this incessant, toilsome coming and going from the burrow to the fields and from the fields to the burrow, forcing her way each time through the unstable sand, either to go hunting or to bring the larva her latest capture? It is, first and foremost, a question of having fresh victuals for her larva: an all-important question, for the grub absolutely refuses any high or tainted game. Like the grubs of the other Diggers, it wants fresh meat and nothing but fresh meat. We have seen in the case of the Cerceres, the Sphex and the Ammophilæ how the mother solves the problem of preserved food-stuffs, the problem of stocking a cell with the requisite quantity of game for its future occupant and keeping the meat fresh for whole weeks at a time; indeed, it is something more than fresh, for the victims are kept in an almost living state, except that they are incapable of movement, an essential condition if the grub is to feed on them in safety. The miracle is performed by the most cunning methods known to physiology. The poisoned lancet is driven into the nerve-centres once or oftener, according to the structure of the nervous system. Thus operated upon, the victim retains all the attributes of life, short of the power of moving. Let us see if the Bembex make use of this profound science of slaughter. The Flies taken from between the legs of the kidnapper as she enters her burrow present, in most cases, every appearance of death. They are motionless; occasionally we can detect in a few of them some faint convulsions of the tarsi, the last vestiges of a life that is passing away. The same appearance of complete death is usually found in the insects which are not actually killed but paralysed by the adroit dagger-thrust of a Cerceris or a Sphex. The question whether they are alive or dead can therefore be decided only according to the manner in which the victims keep fresh. Placed in little screws of paper or in glass tubes, the Crickets and Grasshoppers of the Sphex, the caterpillars of the Ammophilæ, and the Beetles and Weevils of the Cerceres preserve their flexibility of limb, their freshness of colouring and the normal condition of their intestines for weeks and months. They are not corpses but bodies sunk in a lethargy from which there is no awaking. The Flies of the Bembex behave quite differently. The Eristales, the Syrphi—in short, all those whose livery is at all brightly coloured—soon lose the brilliancy of their attire. The eyes of certain Gad-flies, magnificently gilded, with three purple bands, very quickly grow pale and dim, like the eyes of a dying man. All these Flies, large and small, when placed in little paper bags through which the air circulates freely, dry up in two or three days and become brittle; all, when preserved against evaporation in glass tubes in which the air is stationary, go mouldy and decay. They are dead, therefore, really and truly dead, when the Wasp brings them to her larva. Should some of them still retain a remnant of life, a few days or even hours put an end to their agony. Consequently, for lack of talent in the use of her dagger or for some other reason, the murderess kills her victims outright. In view of this fact, that the prey is quite dead at the moment when it is carried off, who would not admire the logic of the Bembex’ procedure? How methodical and consistent everything is in the actions of the cunning Wasp! As the provisions cannot keep beyond two or three days without going bad, they must not be stored entire in the first stages of an infancy which will last at least a fortnight; and the hunting and distribution must necessarily be done day by day, bit by bit, as the larva grows up. The first ration, the one that receives the egg, will last longer than the others; the budding grub will take several days to eat its flesh. It must therefore be small, otherwise the joint would begin to putrefy before it was all finished. This joint therefore will not be a bulky Gad-fly or a corpulent Bombylius, but rather a tiny Sphærophoria, or something similar, making a dainty meal for the larva which is still so delicate. Later, getting bigger and bigger in time, will come the larger joints of venison. The burrow must be kept shut during the mother’s absence, to save the larva from regrettable intrusions; nevertheless the entrance must be one that can be opened very frequently and hurriedly, without much difficulty, when the Wasp returns laden with her prey and watched by the sharp eyes of daring parasites. These conditions could not be obtained with a compact soil such as that in which the Digger-wasps usually make their abodes: the door, left to itself, would stay open; and so, each time, there would be the long and toilsome job of either blocking up the entrance with earth and gravel or unblocking it, as the case might be. The house therefore must be dug in ground with a very loose surface, in fine dry sand, which will at once yield to the slightest effort on the mother’s part and, as it slides down, will close the door of its own accord, like a curtain which, when you thrust it aside with your hand, lets you pass through and then falls back again. There you have the series of actions as deduced by man’s reason and as practised by the Wasp’s sagacity. Why does the spoiler kill the captured prey instead of simply paralysing it? Is it for want of skill in the use of her sting? Is it because of some difficulty due to the structure of the Flies or to the methods employed in the chase? I must begin by confessing that I have failed in my attempts to place Flies, without killing them, in that state of complete immobility to which it is so easy to reduce a Buprestis, a Weevil or a Scarab by injecting a tiny drop of ammonia with a needle into the thoracic ganglia. In making the experiment, it is difficult to render the insect motionless; and, by the time that it has ceased to move, death has actually occurred, as is proved by its speedy corruption or desiccation. But I have too much confidence in the resources of instinct and have witnessed the ingenious solution of too many problems to believe that a difficulty which baffles the experimenter can bring the insect to a standstill. Therefore, without throwing doubt upon the Bembex’ talents as a slaughterer, I should be inclined to look for other reasons. Perhaps the Fly, so thinly covered, so devoid of any plumpness, in a word, so lean, could not, if paralysed by the sting, resist evaporation long enough and would shrivel up during the two or three weeks of waiting. Consider the puny Sphærophoria, the larva’s first mouthful. How much liquid has that body to satisfy the needs of evaporation? An infinitesimal drop, a mere nothing. The abdomen is a thin strip; its two sides touch. Can such game as this form the basis of preserved food, seeing that evaporation would dry up its juices in a few hours when these are not renewed by nutrition? It is doubtful, to say the least. Let us examine the method of hunting, so as to throw some final light on the subject. In the quarry removed from between the legs of the Bembex, it is not rare to observe signs of a hurried capture, made anyhow, according to the chances of a rough-and-tumble fight. The Fly sometimes has her head turned the wrong way round, as though the spoiler had wrung her neck; her wings are crushed; her fur, when she possesses any, is ruffled. I have seen some that had their bellies ripped open by their assailant’s mandibles and had lost their legs in the battle. As a rule, however, the victim is intact. No matter: considering the nature of the game, endowed with good wings for flying, the capture must take place with a suddenness that makes it hardly possible, I should say, to obtain paralysis unaccompanied by death. A Cerceris face to face with her clumsy Weevil, a Sphex grappling with the fat Cricket or the portly Ephippiger, an Ammophila holding her caterpillar by the skin of its neck, all three have an advantage over a prey which is too slow in its movements to avoid attack. They can take their time, select at their ease the mathematical spot where the sting is to penetrate, and lastly go to work with the precision of an anatomist probing with his scalpel the patient who lies before him on the operating-table. But with the Bembex it is a very different matter: at the least alarm, the game nimbly makes off; and, once on the wing, it can defy its pursuer. The Wasp has to pounce upon her prey unawares, without considering how she shall attack or calculating her blows, just as the Goshawk does when hunting in the fallows. Mandibles, claws, sting, every weapon must be employed simultaneously in the fierce fray so as to put an end as early as possible to a contest in which the least hesitation would give the victim time to escape. If these conjectures are borne out by the facts, the Bembex’ prize can be nothing but a corpse or at most a mortally wounded prey. Well, my conjectures are correct: the Bembex delivers her attack with a dash which would do credit to a bird of prey. To surprise the Wasp hunting is not an easy thing; were we never so well armed with patience, we should watch in vain in the neighbourhood of the burrow: the favourable opportunity would not present itself, for the insect flies far away and there is no possibility of following it in its rapid evolutions. Its tactics would doubtless be unknown to me but for the assistance of a utensil from which I would certainly never have expected such a service. I am speaking of my umbrella, which I used as a protection against the sun in the sand of the Bois des Issarts. I was not the only one to profit by its shade; I was generally surrounded by numerous companions. Gad-flies of various species would take refuge under the silken dome and sit peacefully on every part of the tightly-stretched cover. I was rarely without their society when the heat became overpowering. To while away the hours when I had nothing to do, it amused me to watch their great gold eyes, which shone like carbuncles under my canopy; I loved to follow their solemn progress when some part of the ceiling became too hot and obliged them to move a little way on. One day, bang! The tight cover resounded like the skin of a drum. Perhaps an oak had dropped an acorn on the umbrella. Presently, one after the other, bang, bang, bang! Can some practical joker have come to disturb my solitude and fling acorns or little pebbles at my umbrella? I leave my tent and inspect the neighbourhood: nothing! The same sharp sound is repeated. I look up at the ceiling, and the mystery is explained. The Bembex of the vicinity, who all consume Gad-flies, had discovered the rich provender that was keeping me company and were impudently penetrating my shelter to seize the Flies on the ceiling. Things were going to perfection: I had only to sit still and look. Every moment a Bembex would enter, swift as lightning, and dart up to the silken ceiling, which resounded with a sharp thud. Some rumpus was going on aloft, where the eye could no longer distinguish between attacker and attacked, so lively was the fray. The struggle did not last for an appreciable time: the Wasp would retire forthwith with a victim between her legs. The dull herd of Gad-flies, at this sudden irruption which slaughtered them one after the other, drew back a little all round, without quitting the treacherous shelter. It was so hot outside! Why get excited? Obviously, this suddenness of attack, followed by the swift removal of the prey, does not allow the Bembex to regulate her dagger-play. The sting no doubt performs its office, but it is directed without precision at those spots which the hazards of the fight place within its reach. I have seen Bembex, to finish off their half-killed Gad-flies still struggling in the assassin’s grasp, munch the head and thorax of the victims. This habit in itself proves that the Wasp wants a genuine corpse and not a paralysed prey, since she ends the Fly’s agony with so little ceremony. All things considered, therefore, I think that, on the one hand, the nature of the prey, which dries up so quickly, and, on the other hand, the difficulty of making such rapid attacks, explain why the Bembex serve up dead prey to their larvæ and consequently cater for them from day to day. Let us watch the Wasp as she returns to the burrow with her capture held under her abdomen between her legs. Here comes one, the Tarsal Bembex (B. tarsata), who arrives laden with a Bee-fly. The nest is situated at the sandy foot of a steep bank. The huntress announces her approach by a shrill humming, which has something plaintive about it and which continues until the insect sets foot to earth. We see the Bembex hover above the bank and then dip straight down, very slowly and cautiously, all the time emitting her shrill hum. Should her keen eye descry anything unusual, she slackens her descent, hovers for a second or two, goes up again, comes down again and flies away, swift as an arrow. After a few moments, here she is once more. Hovering at a certain height, she appears to be inspecting the locality, as if from the top of an observatory. The vertical descent is resumed with the most cautious slowness; finally, the Wasp alights with no hesitation whatever at a spot which to my eye has naught to distinguish it from the rest of the sandy surface. At that instant the plaintive whimper ceases. The insect, no doubt, has landed more or less on chance, since the most practised eye cannot distinguish one spot from the other on that expanse of sand; it has alighted somewhere near its home, of which it will now seek the entrance, concealed after its last exit not only by the natural falling-in of the materials but also by the Wasp’s own careful sweeping. But no: the Bembex does not hesitate at all, does not grope about, does not seek. By common consent the antennæ are looked upon as organs for guiding insects in their searches. At this moment of the return to the nest, I see nothing particular in the play of the antennæ. Without once letting go her prey, the Bembex scratches a little in front of her, at the very spot where she has alighted, gives a push with her head and straightway enters, with the Fly under her abdomen. The sand falls in, the door closes and the Wasp is at home. It makes no difference that I have seen the Bembex return to her nest hundreds of times; it is always with fresh astonishment that I behold the keen-sighted insect find without hesitation a door whose presence there is nothing to indicate. This door, in fact, is hidden with jealous care, not now, after the Bembex has gone in—for the obliterating sand does not become quite level of its own weight, but leaves perhaps a slight depression, or an incompletely blocked porch—but certainly after she comes out, for, when starting on an expedition, she never fails to put a finishing touch to the result of the natural landslip. Wait for her departure and you shall see her, before flying off, sweep the front of the door and level it with scrupulous care. When she is gone, I defy the most penetrating eye to find the entrance. To discover it again, when the sandy expanse was of any size, I had to resort to a kind of triangulation; and how often, after a few hours’ absence, did not my combinations of triangles and my efforts of memory prove to be at fault! All that remained was the stake, a grass-stalk planted on the threshold; and even this method was not always effective, for the insect, with its passion for continually improving the outside of the nest, often made the bit of straw disappear from sight. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Jean-Henri Fabre (2022). The Hunting Wasps. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/67110/pg67110-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at www.gutenberg.org , located at https://www.gutenberg.org/policy/license.html .

THE FLY-HUNT

When working with text in JavaScript, you may come across situations where you need to add a prefix or suffix to each new line in a given text. In this tutorial, we'll walk you through a simple and effective way to achieve this using HTML, CSS, and JavaScript. We'll create an easy-to-use online tool that adds a specified prefix and suffix to each new line of text entered by the user. Step 1: Create the HTML Structure First, let's create the basic for our tool. This includes a text area for inputting the text, two input fields for the prefix and suffix, a button to trigger the , and an output text area to display the processed text. HTML structure JavaScript function <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Add Prefix and Suffix</title>
</head>
<body>
    <h1>Add Prefix and Suffix to Each New Line</h1>
    <textarea id="inputText" rows="10" cols="50" placeholder="Enter your text here..."></textarea>
    <br>
    <label for="prefix">Prefix:</label>
    <input type="text" id="prefix" />
    <br>
    <label for="suffix">Suffix:</label>
    <input type="text" id="suffix" />
    <br>
    <button onclick="addPrefixAndSuffix()">Add Prefix and Suffix</button>
    <br>
    <h2>Output:</h2>
    <textarea id="outputText" rows="10" cols="50" readonly></textarea>
</body>
</html> Step 2: Add CSS for Styling Although not required, you may want to add some basic the tool. Here's a simple example: CSS to style <style>
    body {
        font-family: Arial, sans-serif;
        max-width: 800px;
        margin: 0 auto;
        padding: 20px;
    }

    textarea, input {
        display: block;
        width: 100%;
        margin-bottom: 10px;
    }

    button {
        background-color: #4CAF50;
        color: white;
        padding: 8px 16px;
        border: none;
        cursor: pointer;
        text-decoration: none;
    }

    button:hover {
        background-color: #45a049;
    }
</style> Add the above CSS code inside the tag of the HTML code to apply the styles. <head> Step 3: Write the JavaScript Function Now, let's write the JavaScript function that will add the specified prefix and suffix to each new line of the input text. Be sure to include this code within tags at the end of your HTML file, just before the closing tag. <script> </body> function addPrefixAndSuffix() {
    const inputText = document.getElementById('inputText').value;
    const prefix = document.getElementById('prefix').value;
    const suffix = document.getElementById('suffix').value;
    const lines = inputText.split('\n');

    const outputLines = lines.map(line => {
        if (line.trim() === '') {
            return line;
        }
        return prefix + line + suffix;
    });

    const outputText = outputLines.join('\n');
    document.getElementById('outputText').value = outputText;
} This function retrieves the input text, prefix, and suffix from the HTML elements. It then splits the input of lines, processes each line by adding the prefix and suffix (skipping empty or whitespace-only lines), and finally combines the processed lines back into a single string. text into an array Step 4: Test the Tool To test the , save the HTML, CSS, and JavaScript code in a new file and open it in your web browser. You should see a simple interface with input fields for the text, prefix, and suffix, as well as a button to trigger the function. tool .html Enter your text in the text area, input your desired prefix and suffix, and click the "Add Prefix and Suffix" button. The processed text with the added prefix and suffix should appear in the output text area. Conclusion In this tutorial, we have demonstrated how to create a user-friendly online tool that adds a prefix and suffix to each new line of text using HTML, CSS, and JavaScript. This tool can be helpful for tasks such as formatting lists, adding , or enhancing the appearance of your text. code snippets With this simple yet effective solution, you can save time and effort when working with text in JavaScript.

How to Add Prefix or Suffix to Each New Line in JavaScript

This tutorial is part of my book " ". OpenAI GPT For Python Developers The goal of this book is to provide a step-by-step guide to using GPT-3 in your projects through this API but not only that - many other tools and models built by OpenAI such as Whisper (an automatic speech recognition (ASR) system trained on 680,000 hours of multilingual and multitask supervised data), CLIP (Contrastive Language-Image Pre-Training), a neural network trained on a variety of (image, text) pairs and DALL·E 2, a new AI system that can create realistic images and art from a description in natural language. The Problem GPT is a generative text model which means that it produces new text by predicting what comes next based on the input it gets from the user. The model was trained on a large corpus of text (books, articles, and websites), and it used this data and learned patterns and relationships between words and phrases. By default, the model has no memory when you initiate a discussion with it. This means each input is treated independently without any context or information carried over from the previous user prompts. This is certainly not ideal for human-friendly interactions. While this seems like a limitation, it actually allows the model to generate more diverse and less repetitive text. In some cases, carrying over context is useful and necessary. Some techniques like fine-tuning on a specific topic help in improving the quality of outputs; the other technique that we are going to implement next is much easier to implement. No Context = Chaos of Randomness Let’s start by building a simple chatbot; initially, we are going to initiate a discussion as our goal is to compare the outputs of the model now and later when we add more context to the conversation. import openai
import os

def init_api():
    with open(".env") as env:
        for line in env:
            key, value = line.strip().split("=")
            os.environ[key] = value

    openai.api_key = os.environ.get("API_KEY")
    openai.organization = os.environ.get("ORG_ID")

init_api()

initial_prompt = """You: Hi there!
You: Hello!
AI: How are you?
You: {}
AI: """

while True:
    prompt = input("You: ")

    response = openai.Completion.create(
        engine="text-davinci-003",
        prompt=initial_prompt.format(prompt),
        temperature=1,
        max_tokens=100,
        stop=[" You:", " AI:"]
    )
    
    print("AI:", response.choices[0].text) The following test shows that by default, the chat agent we built doesn’t have any memory: You: Hey AI: Hey! How can I help you today? You: Remember this string 'blah' and store it. I'll ask you about it later. AI: Sure, I remember the string 'blah'. You: What was the string? AI: I'm not sure what you mean - can you elaborate? You: What was the string I told you to remember? AI: I'm sorry, I don't remember any strings you told me. You: I already told you! AI: I'm sorry, I didn't catch that. Could you please explain the context of the last message? History = Context The idea is pretty simple, and it works by creating a history variable where we store the request of the user and the text generated by the model. When the user asks a new question, the history is inserted before the new question. import openai
import os

def init_api():
    with open(".env") as env:
        for line in env:
            key, value = line.strip().split("=")
            os.environ[key] = value

    openai.api_key = os.environ.get("API_KEY")
    openai.organization = os.environ.get("ORG_ID")

init_api()

initial_prompt = """You: Hi there!
You: Hello!
AI: How are you?
You: {}
AI: """

history = ""

while True:
    prompt = input("You: ")
    response = openai.Completion.create(
        engine="text-davinci-003",
        prompt=initial_prompt.format(history + prompt),
        temperature=1,
        max_tokens=100,
        stop=[" You:", " AI:"],
    )

    response_text = response.choices[0].text
    history += "You: "+ prompt + "\n" + "AI: " + response_text + "\n"

    print("AI: " + response_text) This is how the same discussion went: You: Hey AI: Hi there! How are you? You: Remember this string 'blah' and store it. I'll ask you about it later. AI: Got it! What would you like to know about 'blah'? You: What was the string? AI: The string was 'blah'. You: Why? AI: You asked me to remember the string 'blah' and store it, so I did. The Problem With Carrying Over History With long discussions, the user prompt will be longer since it will always be added to the history until the point when it reaches the maximum number of tokens allowed by OpenAI. In this case, the result is a total failure, as the API will respond with errors. The second problem here is the cost. You are charged by tokens, so the more tokens you have in your input, the more expensive it will be. Last in First Out (LIFO) Memory I am not sure if this approach has a technical name, but I called it “last in first out” since the idea behind it is simple: Users will always initiate discussions with a context. Context evolves, and the discussion too. Users will most likely include the context in the latest 2 to 5 prompts. Based on this, we could assume that a better approach is to only store the most recent prompts. This is how it works in a few words: We create a text file where we will store the history, then we store the historical prompts and answers separated by a separator that is not found in the discussion. For example: ##### Then we retrieve the last 2 and add them to the user prompt as a context. Instead of a text file, you can use a PostgreSQL database, a Redis database, or whatever you want. Let’s take a look at the code: import openai
import os

def init_api():
    with open(".env") as env:
        for line in env:
            key, value = line.strip().split("=")
            os.environ[key] = value

    openai.api_key = os.environ.get("API_KEY")
    openai.organization = os.environ.get("ORG_ID")

def save_history_to_file(history):
    with open("history.txt", "w+") as f:
        f.write(history)

def load_history_from_file():
    with open("history.txt", "r") as f:
        return f.read()

def get_relevant_history(history):
    history_list = history.split(separator)
    if len(history_list) > 2:
        return separator.join(history_list[-2:])
    else:
        return history        

init_api()

initial_prompt = """You: Hi there!
You: Hello!
AI: How are you?
You: {}
AI: """

history = ""
relevant_history = ""
separator = "#####"

while True:
    prompt = input("You: ")
    relevant_history = get_relevant_history(load_history_from_file())

    response = openai.Completion.create(
        engine="text-davinci-003",
        prompt=initial_prompt.format(relevant_history + prompt),
        temperature=1,
        max_tokens=100,
        stop=[" You:", " AI:"],
    )

    response_text = response.choices[0].text
    history += "\nYou: "+ prompt + "\n" + "AI: " + response_text + "\n" + separator
    save_history_to_file(history)

    print("AI: " + response_text) The Problem With Last in First Out Memory This approach I called the Last in First out memory may struggle when a discussion becomes very complex, and the user needs to switch back and forth between different contexts. In such cases, the approach may not be able to provide the required context to the user as it only stores the most recent prompts. This can lead to confusion and frustration for the user, which is not ideal for human-friendly interactions. Selective Context The solution suggested in this part will work as follows: An initial prompt is saved to a text file. The user enters a prompt. The program creates embeddings for all interactions in the file. The program creates embeddings for the user's prompt. The program calculates the cosine similarity between the user's prompt and all interactions in the file. The program sorts the file by cosine similarity. The best n interactions are read from the file and sent with the prompt to the user. We are using a text file here to make things simple, but as said previously, you can use any data store. These are the different functions we are going to use to perform the above: def save_history_to_file(history):
    """
    Save the history of interactions to a file
    """
    with open("history.txt", "w+") as f:
        f.write(history)

def load_history_from_file():
    """
    Load all the history of interactions from a file
    """
    with open("history.txt", "r") as f:
        return f.read()

def cos_sim(a, b):
    """    
    Calculate cosine similarity between two strings
    Used to compare the similarity between the user input and a segments in the history
    """
    a = nlp(a)
    a_without_stopwords = nlp(' '.join([t.text for t in a if not t.is_stop]))
    b = nlp(b)
    b_without_stopwords = nlp(' '.join([t.text for t in b if not t.is_stop]))
    return a_without_stopwords.similarity(b_without_stopwords)

def sort_history(history, user_input):   
    """
    Sort the history of interactions based on cosine similarity between the user input and the segments in the history
    History is a string of segments separated by separator
    """
    segments = history.split(separator)     
    similarities = []    
    
    for segment in segments:
        # get cosine similarity between user input and segment
        similarity = cos_sim(user_input, segment)
        similarities.append(similarity)        
    sorted_similarities = np.argsort(similarities)
    sorted_history = ""
    for i in range(1, len(segments)):
        sorted_history += segments[sorted_similarities[i]] + separator
    save_history_to_file(sorted_history)

def get_latest_n_from_history(history, n):
    """
    Get the latest n segments from the history.
    History is a string of segments separated by separator
    """
    segments = history.split(separator)
    return separator.join(segments[-n:]) Here is what the function does, explained step by step: sort_history : The function first splits the input history string into segments based on the specified separator (in our example, we will use which we will declare later). This creates a list of segments representing each interaction in history. Split the history into segments ##### : For each segment, the function computes the cosine similarity between the user's input and the segment using the function. The cosine similarity measures the similarity between two vectors as we have seen in the previous chapters. Compute the cosine similarity cos_sim Although we could have used OpenAI embedding, our goal is to reduce computing costs by performing certain tasks locally instead of relying on the API. : The function sorts the similarities in ascending order using , which returns the indices of the sorted similarities in the order of their values. This creates a list of indices representing the segments sorted by their similarity to the user's input. Sort the similarities np.argsort : We iterate over the sorted indices in reverse order and concatenate the corresponding segments together into a new string. This creates a new, sorted history string in which the most similar interactions to the user's input appear first. Reconstruct the sorted history : Finally, we save the sorted history to a file using the function. Save the sorted history save_history_to_file This is how we used these functions after defining the initial prompts, the value of the separator, and saved the initial prompts to a file. initial_prompt_1 = """
You: Hi there!
AI: Hello!
#####
You: How are you?
AI: I am fine, thank you.
#####
You: Do you know cars?
AI: Yes I have some knowledge about cars.
#####
You: Do you eat Pizza?
AI: I don't eat pizza. I am an AI that is not able to eat.
#####
You: Have you ever been to the moon?
AI: I have never been to the moon. What about you?
#####
You: What is your name?
AI: My name is Pixel. What is your name?
#####
You: What is your favorite movie?
AI: My favorite movie is The Matrix. Follow the white rabbit :)
#####
"""

initial_prompt_2 ="""You: {}
AI: """
initial_prompt = initial_prompt_1 + initial_prompt_2
separator = "#####"

init_api()
save_history_to_file(initial_prompt_1)

while True:
    prompt = input("You: ")    
    sort_history(load_history_from_file(), prompt)
    history = load_history_from_file()
    best_history = get_latest_n_from_history(history, 5)
    full_user_prompt = initial_prompt_2.format(prompt)
    full_prompt = best_history + "\n" + full_user_prompt
    response = openai.Completion.create(
        engine="text-davinci-003",
        prompt=full_prompt,
        temperature=1,
        max_tokens=100,
        stop=[" You:", " AI:"],
    )
    response_text = response.choices[0].text.strip()
    history += "\n" + full_user_prompt + response_text + "\n" + separator + "\n"
    save_history_to_file(history)

    print("AI: " + response_text) If we put everything together, this is what we get: import openai
import os
import spacy
import numpy as np

# Load the pre-trained spaCy model
nlp = spacy.load('en_core_web_md')

def init_api():
    with open(".env") as env:
        for line in env:
            key, value = line.strip().split("=")
            os.environ[key] = value

    openai.api_key = os.environ.get("API_KEY")
    openai.organization = os.environ.get("ORG_ID")

def save_history_to_file(history):
    """
    Save the history of interactions to a file
    """
    with open("history.txt", "w+") as f:
        f.write(history)

def load_history_from_file():
    """
    Load all the history of interactions from a file
    """
    with open("history.txt", "r") as f:
        return f.read()

def cos_sim(a, b):
    """    
    Calculate cosine similarity between two strings
    Used to compare the similarity between the user input and a segments in the history
    """
    a = nlp(a)
    a_without_stopwords = nlp(' '.join([t.text for t in a if not t.is_stop]))
    b = nlp(b)
    b_without_stopwords = nlp(' '.join([t.text for t in b if not t.is_stop]))
    return a_without_stopwords.similarity(b_without_stopwords)

def sort_history(history, user_input):   
    """
    Sort the history of interactions based on cosine similarity between the user input and the segments in the history
    History is a string of segments separated by separator
    """
    segments = history.split(separator)     
    similarities = []    
    
    for segment in segments:
        # get cosine similarity between user input and segment
        similarity = cos_sim(user_input, segment)
        similarities.append(similarity)        
    sorted_similarities = np.argsort(similarities)
    sorted_history = ""
    for i in range(1, len(segments)):
        sorted_history += segments[sorted_similarities[i]] + separator
    save_history_to_file(sorted_history)

def get_latest_n_from_history(history, n):
    """
    Get the latest n segments from the history.
    History is a string of segments separated by separator
    """
    segments = history.split(separator)
    return separator.join(segments[-n:])
    
        

initial_prompt_1 = """
You: Hi there!
AI: Hello!
#####
You: How are you?
AI: I am fine, thank you.
#####
You: Do you know cars?
AI: Yes I have some knowledge about cars.
#####
You: Do you eat Pizza?
AI: I don't eat pizza. I am an AI that is not able to eat.
#####
You: Have you ever been to the moon?
AI: I have never been to the moon. What about you?
#####
You: What is your name?
AI: My name is Pixel. What is your name?
#####
You: What is your favorite movie?
AI: My favorite movie is The Matrix. Follow the white rabbit :)
#####
"""

initial_prompt_2 ="""You: {}
AI: """
initial_prompt = initial_prompt_1 + initial_prompt_2
separator = "#####"

init_api()
save_history_to_file(initial_prompt_1)

while True:
    prompt = input("You: ")    
    sort_history(load_history_from_file(), prompt)
    history = load_history_from_file()
    best_history = get_latest_n_from_history(history, 5)
    full_user_prompt = initial_prompt_2.format(prompt)
    full_prompt = best_history + "\n" + full_user_prompt
    response = openai.Completion.create(
        engine="text-davinci-003",
        prompt=full_prompt,
        temperature=1,
        max_tokens=100,
        stop=[" You:", " AI:"],
    )
    response_text = response.choices[0].text.strip()
    history += "\n" + full_user_prompt + response_text + "\n" + separator + "\n"
    save_history_to_file(history) This tutorial is part of my book " ". OpenAI GPT For Python Developers The goal of this book is to provide a step-by-step guide to using GPT-3 in your projects through this API but not only that - many other tools and models built by OpenAI such as Whisper (an automatic speech recognition (ASR) system trained on 680,000 hours of multilingual and multitask supervised data), CLIP (Contrastive Language-Image Pre-Training), a neural network trained on a variety of (image, text) pairs and DALL·E 2, a new AI system that can create realistic images and art from a description in natural language. Whether you’re building a chatbot, an AI (voice) assistant, a semantic search engine, a classification system, a recommendation engine, a web app providing AI-generated data, or any other sort of natural language/image/voice processing and generation platform, this guide will help you reach your goals. If you have the basics of Python programming language and are open to learning a few more techniques like using Pandas Dataframes and some NLP techniques, you have all the necessary tools to start building intelligent systems using OpenAI tools.

LINESLIP SOLUTIONS

lineslipsolutions.com

-- employees

Since n.d.

COMPANY RANKING

LINESLIP SOLUTIONS

EVERGREEN INDEX #7222

Representing this company? Click here to claim and customize this page!

LineSlip Solutions WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

LINESLIP SOLUTIONS

lineslipsolutions.com

-- employees

Since n.d.

COMPANY RANKING

LINESLIP SOLUTIONS

EVERGREEN INDEX #7222

RELATED COMPANIESRANK

STORIES ABOUT LINESLIP SOLUTIONS

Representing this company? Click here to claim and customize this page!

LineSlip Solutions WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!