Dan Nelson

Gradient Boosting Classifiers in Python with Scikit-Learn

This is the 15th article in my series of articles on Python for NLP. In my <a target="_blank" href="https://stackabuse.com/python-for-nlp-creating-tf-idf-model-from-scratch/">previous article</a>, I explained how to implement <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Tf%E2%80%93idf">TF-IDF</a> approach from scratch in Python. Before that, we studied how to implement <a target="_blank" href="/python-for-nlp-creating-bag-of-words-model-from-scratch/">bag-of-words approach from scratch in Python</a>.
Today, we will study the N-Grams approach and will see how the N-Grams approach can be used to create a simple automatic text filler or suggestion engine. Automatic text filler is a very useful application and is widely used by Google and different smartphones where a user enters some text and the remaining text is automatically populated or suggested by the application.
<h2 id="problemswithtfidfandbagofwordsapproach">Problems with TF-IDF and Bag of Words Approach</h2>
Before we go and actually implement the N-Grams model, let us first discuss the drawback of the bag of words and TF-IDF approaches.
In the bag of words and TF-IDF approach, words are treated individually and every single word is converted into its numeric counterpart. The context information of the word is not retained. Consider two sentences &quot;big red machine and carpet&quot; and &quot;big red carpet and machine&quot;. If you use a bag of words approach, you will get the same vectors for these two sentences. However, we can clearly see that in the first sentence we are talking about a &quot;big red machine&quot;, while the second sentence contains information about the &quot;big red carpet&quot;. Hence, context information is very important. The N-Grams model basically helps us capture the context information.
<h2 id="theoryofngramsmodel">Theory of N-Grams Model</h2>
Wikipedia defines an N-Gram as &quot;A contiguous sequence of N items from a given sample of text or speech&quot;. Here an item can be a character, a word or a sentence and N can be any integer. When N is 2, we call the sequence a bigram. Similarly, a sequence of 3 items is called a trigram, and so on.
In order to understand the N-Grams model, we first have to understand how the Markov chains work.
<h3 id="connectionofngramswithmarkovchains">Connection of N-Grams with Markov Chains</h3>
A <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Markov_chain">Markov chain</a> is a sequence of states. Consider a Markov system with 2 states, X and Y. In a Markov chain, you can either stay at one state or move to the other state. In our example, our states have the following behavior:
<ol>
<li>The probability of moving from X to Y is 50% and similarly, the probability of staying at X is 50%.</li>
<li>Likewise, the probability of staying at Y is 50% while the possibility of moving back to X is also 50%.</li>
</ol>
This way a Markov sequence can be generated, such as XXYX, etc.
In an N-Grams model, an item in a sequence can be treated as a Markov state. Let's see a simple example of character bigrams where each character is a Markov state.
<pre><code class="hljs">Football is a very famous game
</code></pre>
The character bigrams for the above sentence will be: <code>fo</code>, <code>oo</code>, <code>ot</code>, <code>tb</code>, <code>ba</code>, <code>al</code>, <code>ll</code>, <code>l </code>, <code> i</code>, <code>is</code> and so on. You can see that bigrams are basically a sequence of two consecutively occurring characters.
Similarly, the trigrams are a sequence of three contiguous characters, as shown below:
<code>foo</code>, <code>oot</code>, <code>otb</code>, <code>tba</code> and so on.
In the previous two examples, we saw character bigrams and trigrams. We can also have bigrams and trigrams of words.
Let's go back to our previous example, &quot;big red machine and carpet&quot;. The bigram of this sentence will be &quot;big red&quot;, &quot;red machine&quot;, &quot;machine and&quot;, &quot;and carpet&quot;. Similarly, the bigrams for the sentence &quot;big red carpet and machine&quot; will be &quot;big red&quot;, &quot;red carpet&quot;, &quot;carpet and&quot;, &quot;and machine&quot;.
Here in this case with bigrams, we get a different vector representation for both of the sentences.
In the following section, we will implement the N-Grams model from scratch in Python and will see how we can create an automatic text filler using N-Grams like these.
<h2 id="ngramsfromscratchinpython">N-Grams from Scratch in Python</h2>
We will create two types of N-Grams models in this section: a character N-Grams model and a word N-Gram model.
<h3 id="charactersngramsmodel">Characters N-Grams Model</h3>
In this section, I will explain how to create a simple character N-Gram model. In the next section, we will see how to implement the word N-Gram model.
To create our corpus, we will scrape the Wikipedia article on Tennis. Let's first import the libraries that we need to download and parse the Wikipedia article.
<pre><code class="hljs">import nltk
import numpy as np
import random
import string

import bs4 as bs
import urllib.request
import re
</code></pre>
We will be using the <a rel="nofollow" target="_blank" href="https://www.crummy.com/software/BeautifulSoup/bs4/doc/">BeautifulSoup4</a> library to parse the data from Wikipedia. Furthermore, Python's regex library, <code>re</code>, will be used for some preprocessing tasks on the text.
As we said earlier, we will use the Wikipedia article on Tennis to create our corpus. The following script retrieves the Wikipedia article and extracts all the paragraphs from the article text. Finally, the text is converted into lower case for easier processing.
<pre><code class="hljs">raw_html = urllib.request.urlopen(&#x27;https://en.wikipedia.org/wiki/Tennis&#x27;)
raw_html = raw_html.read()

article_html = bs.BeautifulSoup(raw_html, &#x27;lxml&#x27;)
article_paragraphs = article_html.find_all(&#x27;p&#x27;)
article_text = &#x27;&#x27;

for para in article_paragraphs:
 article_text += para.text

article_text = article_text.lower()
</code></pre>
Next, we remove everything from our dataset except letters, periods, and spaces:
<pre><code class="hljs">article_text = re.sub(r'[^A-Za-z. ]', '', article_text)
</code></pre>
We have preprocessed our dataset and now is the time to create an N-Grams model. We will be creating a character trigram model. Execute the following script:
<pre><code class="hljs">ngrams = {}
chars = 3

for i in range(len(article_text)-chars):
 seq = article_text[i:i+chars]
 print(seq)
 if seq not in ngrams.keys():
 ngrams[seq] = []
 ngrams[seq].append(article_text[i+chars])
</code></pre>
In the script above, we create a dictionary <code>ngrams</code>. The keys of this dictionary will be the character trigrams in our corpus and the values will be the characters that occur next to the trigrams. Next, since we are creating an N-Gram of three characters we declare a variable <code>chars</code>. After that we iterate through all the characters in our corpus, starting from the fourth character.
Next, inside the loop, we extract the trigram by filtering the next three characters. The trigram is stored in the <code>seq</code> variable. We then check if the trigram exists in the dictionary. If it doesn't exist in the <code>ngrams</code> dictionary we add the trigram to the dictionary. After that, we assign an empty list as the value to the trigram. Finally, the character that exists after the trigram is appended as a value to the list.
If you open the dictionary <code>ngrams</code> in the Spyder variable explorer. You should see something like this:
<img class="img-responsive" src="https://stackabuse.s3.amazonaws.com/media/python-nlp-developing-automatic-text-filler-n-grams-1.png">
You can see trigrams as keys, and the corresponding characters, which occur after the trigrams in the text, as values. You might see keys with two characters in the dictionary but they are actually not two characters. The third character is actually a space.
Let's now try to generate text using the first three characters of our corpus as input. The first three characters of our corpus are &quot;ten&quot;. Look at the following script:
<pre><code class="hljs">curr_sequence = article_text[0:chars]
output = curr_sequence
for i in range(200):
 if curr_sequence not in ngrams.keys():
 break
 possible_chars = ngrams[curr_sequence]
 next_char = possible_chars[random.randrange(len(possible_chars))]
 output += next_char
 curr_sequence = output[len(output)-chars:len(output)]

print(output)
</code></pre>
In the script above we first store the first trigram i.e. <code>ten</code> into the <code>curr_sequence</code> variable. We will generate a text of two hundred characters, therefore we initialize a loop that iterates for 200 times. During each iteration, we check if the <code>curr_sequence</code> or the trigram is in the <code>ngrams</code> dictionary. If the trigram is not found in the <code>ngrams</code> dictionary, we simply break out of the loop.
Next, the <code>curr_sequence</code> trigram is passed as key to the <code>ngrams</code> dictionary, which returns the list of possible next characters. From the list of possible next characters, an index is chosen randomly, which is passed to the <code>possible_chars</code> list to get the next character for the current trigram. The next character is then appended to the <code>output</code> variable that contains the final output.
Finally, the <code>curr_sequence</code> is updated with the next trigram from the text corpus. If you print the <code>output</code> variable that contains two hundred characters generated automatically, you should see something like this (It is important to mention that since the next character is randomly chosen, your output can be different):
Output:
<pre><code class="hljs">tent pointo somensiver tournamedal pare the greak in the next peak sweder most begal tennis sport. the be has siders with sidernaments as was that adming up is coach rackhanced ball of ment. a game and
</code></pre>
The output doesn't make much sense here in this case. If you increase the value of the <code>chars</code> variable to 4. You should see the results similar to the following outputs:
<pre><code class="hljs">tennis ahead with the club players under.most coaching motion us . the especific at the hit and events first predomination but of ends on the u.s. cyclops have achieved the end or net inches call over age
</code></pre>
You can see that the results are a bit better than the one we got using 3-grams. Our text suggestion/filling will continue to improve as we increase the N-Gram number.
In the next section, we will implement the Words N-Grams model. You will see that the text generated will make much more sense in the case of Words N-Grams model.
<h3 id="wordsngramsmodel">Words N-Grams Model</h3>
In Words N-Grams model, each word in the text is treated as an individual item. In this section, we will implement the Words N-Grams model and will use it to create automatic text filler.
The dataset that we are going to use is the same as the one we used in the last section.
Let's first create a dictionary that contains word trigrams as keys and the list of words that occur after the trigrams as values.
<pre><code class="hljs">ngrams = {}
words = 3

words_tokens = nltk.word_tokenize(article_text)
for i in range(len(words_tokens)-words):
 seq = &#x27; &#x27;.join(words_tokens[i:i+words])
 print(seq)
 if seq not in ngrams.keys():
 ngrams[seq] = []
 ngrams[seq].append(words_tokens[i+words])
</code></pre>
In the script above, we create a Words trigram model. The process is similar to the one followed to use character trigrams. However, in the above script, we first tokenize our corpus into words.
Next, we iterate through all the words and then join the current three words to form a trigram. After that, we check if the word trigram exists in the <code>ngrams</code> dictionary. If the trigram doesn't already exist, we simply insert it into the <code>ngrams</code> dictionary as a key.
Finally, we append the list of words that follow the trigram in the whole corpus, as the value in the dictionary.
Now if you look at the <code>ngrams</code> dictionary, in the variable explorer, it will look like this:
<img class="img-responsive" src="https://stackabuse.s3.amazonaws.com/media/python-nlp-developing-automatic-text-filler-n-grams-2.png">
You can see trigrams as dictionary keys and corresponding words as dictionary values.
Let's now create an automatic text filler, using the word trigrams that we just created.
<pre><code class="hljs">curr_sequence = &#x27; &#x27;.join(words_tokens[0:words])
output = curr_sequence
for i in range(50):
 if curr_sequence not in ngrams.keys():
 break
 possible_words = ngrams[curr_sequence]
 next_word = possible_words[random.randrange(len(possible_words))]
 output += &#x27; &#x27; + next_word
 seq_words = nltk.word_tokenize(output)
 curr_sequence = &#x27; &#x27;.join(seq_words[len(seq_words)-words:len(seq_words)])

print(output)
</code></pre>
In the script above, we initialize the <code>curr_sequence</code> variable with the first trigram in the corpus. The first trigram is &quot;tennis is a&quot;. We will generate 50 words using the first trigram as the input. To do so, we execute a for loop that executes for 50 times. During each iteration, it is first checked if the word trigram exists in the <code>ngrams</code> dictionary. If not, the loop breaks. Otherwise the list of the words that are likely to follow the trigram are retrieved from the <code>ngrams</code> dictionary by passing trigram as the value. From the list of possible words, one word is chosen randomly and is appended at the end of the out. Finally, the <code>curr_sequence</code> variable is updated with the value of the next trigram in the dictionary.
The generated text looks like this. You can see that in the case of word trigrams, the automatically generated text makes much more sense.
Output:
<pre><code class="hljs">tennis is a racket sport that can be played individually against a single opponent singles or between two teams of two players each doubles. each player uses a tennis racket include a handle known as the grip connected to a neck which joins a roughly elliptical frame that holds a matrix of
</code></pre>
If you set the value of words variable to 4 (use 4-grams) to generate text, your output will look even more robust as shown below:
<pre><code class="hljs">tennis is a racket sport that can be played individually against a single opponent singles or between two teams of two players each doubles . each player uses a tennis racket that is strung with cord to strike a hollow rubber ball covered with felt over or around a net and into the opponents
</code></pre>
You can see the output makes even more sense with 4-grams. This is largely because our generator is mostly regenerating the same text from the Wikipedia article, but with some slight improvements to the generator, and a larger corpus, our generator could easily generate new and unique sentences as well.
<h2 id="conclusion">Conclusion</h2>
The N-Grams model is one of the most widely used sentence-to-vector models since it captures the context between N-words in a sentence. In this article, you saw the theory behind the N-Grams model. You also saw how to implement characters N-Grams and Words N-Grams models. Finally, you studied how to create automatic text filler using both approaches.

Usman Malik

Python for NLP: Developing an Automatic Text Filler using N-Grams

<h2 id="introduction">Introduction</h2>
If you are a JavaScript developer, you may know that JavaScript conforms to the <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/ECMAScript">ECMAScript</a> (ES) standards. The ES6, or ECMAScript 2015 specifications, had introduced some of the revolutionary specifications for JavaScript, like Arrow Functions, Classes, Rest and Spread operators, Promises, <code>let</code> and <code>const</code>, etc.
In this tutorial, we'll focus on Arrow functions, which is very much confusing and intimidating for JavaScript beginners.
<h2 id="arrowfunctionsyntax">Arrow Function Syntax</h2>
As we know, an ES5 function has the following syntax:
<pre><code class="hljs">function square(a) {
 return a * a;
}
</code></pre>
In ES6, we can write the same function with only one line of code:
<pre><code class="hljs">let square = (a) =&gt; { return a * a; }
</code></pre>
Furthermore, if the function body has only one statement that it returns, we can skip curly braces <code>{}</code> and the <code>return</code> statement:
<pre><code class="hljs">let square = (a) =&gt; a * a
</code></pre>
Also, if the function takes only one parameter we can even skip the braces <code>()</code> around it:
<pre><code class="hljs">let square = a =&gt; a * a
</code></pre>
On the other hand, if the function does not takes any parameters we may write it like this:
<pre><code class="hljs">let results = () =&gt; { /* ...some statements */ };
</code></pre>
We have to write less code with this syntax while providing the same functionality, which can help to declutter and simplify your code.
The advantage of this syntax is most noticeable when used in callbacks. So a verbose and difficult-to-follow snippet of code like this:
<pre><code class="hljs">function getRepos() {
 return fetch(&#x27;https://api.github.com/users/stackabuse/repos&#x27;)
 .then((response) =&gt; {
 return response.json();
 }).then((response) =&gt; {
 return response.data;
 }).then((repos) =&gt; {
 return repos.filter((repo) =&gt; {
 return repo.created_at &gt; &#x27;2019-06-01&#x27;;
 });
 }).then((repos) =&gt; {
 return repos.filter((repo) =&gt; {
 return repo.stargazers_count &gt; 1;
 });
 });
}
</code></pre>
can be reduced to the following, by using arrow functions:
<pre><code class="hljs">function getRepos() {
 return fetch(&#x27;https://api.github.com/users/stackabuse/repos&#x27;)
 .then(response =&gt; response.json())
 .then(response =&gt; response.data)
 .then(repos =&gt; repos.filter(repo =&gt; repo.created_at &gt; &#x27;2019-06-01&#x27;))
 .then(repos =&gt; repos.filter(repo =&gt; repo.stargazers_count &gt; 1));
}
</code></pre>
<h2 id="benefitsofarrowfunctions">Benefits of Arrow Functions</h2>
There are two major benefits of using Arrow functions. One is that it's a shorter syntax and thus requires less code. The main benefit is that it removes the several pain points associated with the <code>this</code> operator.
<h3 id="nobindingofthisoperator">No Binding of 'this' Operator</h3>
Unlike other Object-oriented programming languages, in JavaScript (before arrow functions) every function defined its reference of <code>this</code> and it depends on how the function was called. If you have experience with modern programming languages like Java, Python, C#, etc., the operator <code>this</code> or <code>self</code> inside a method refers to the object that called the method and not how that method is called.
Programmers always complain that using <code>this</code> is too complicated in JavaScript. It causes great confusion in the JavaScript community and causes unintended behavior of the code in some cases.
To better understand the benefit of Arrow functions, let us first understand how <code>this</code> works in ES5.
<h4 id="thethisoperatorines5">The 'this' Operator in ES5</h4>
<blockquote>
The value of <code>this</code> is determined by a function's execution context, which in simple terms means how a function is called.
</blockquote>
What adds more to the confusion is that every time the same function is called, the execution context can be different.
Let us try to understand it with the help of an example:
<pre><code class="hljs">function test() {
 console.log(this);
}
test();
</code></pre>
The output of this program would be the following in a browser console:
<pre><code class="hljs">Window {...}
</code></pre>
As we called <code>test()</code> from the global context, the <code>this</code> keyword refers to the global object which is a <code>Window</code> object in browsers. Every global variable we create gets attached to this global object <code>Window</code>.
For example, if you run the following code in a browser console:
<pre><code class="hljs">let greetings = &#x27;Hello World!&#x27;;
console.log(greetings);
console.log(window.greetings)
</code></pre>
you will be greeted with 'Hello World!' twice:
<pre><code class="hljs">Hello World!
Hello World!
</code></pre>
As we can see the global variable <code>greetings</code> is attached to the global object <code>window</code>.
Let us take a different example with a constructor function:
<pre><code class="hljs">function Greetings(msg) {
 this.msg = msg;
};

let greetings = Greetings(&#x27;Hello World!&#x27;);
console.log(greetings);
</code></pre>
We will get the following message in the console:
<pre><code class="hljs">undefined
</code></pre>
which makes sense because we are calling <code>Greetings()</code> in the <code>window</code> context and like the previous example <code>this</code> refers to the global object <code>window</code> and <code>this.msg</code> has added <code>msg</code> property to the <code>window</code> object.
We can check it if we run:
<pre><code class="hljs">window.msg
</code></pre>
We will be greeted with:
<pre><code class="hljs">Hello World!
</code></pre>
But if we use the <code>new</code> operator while creating the <code>Greetings</code> object:
<pre><code class="hljs">let greetings = new Greetings(&#x27;Hello World!&#x27;);
console.log(greetings.msg);
</code></pre>
We will be greeted with:
<pre><code class="hljs">Hello World!
</code></pre>
We can see the <code>this</code> operator does not refer to the global <code>window</code> object this time. It is the <code>new</code> operator that does this magic. The <code>new</code> operator creates an empty object and makes the <code>this</code> refer to that empty object.
I hope now you are getting a feeling for our earlier statement
<blockquote>
<code>this</code> depends on how a function is called.
</blockquote>
Let us take another example:
<pre><code class="hljs">let greetings = {
 msg: &#x27;Hello World!&#x27;,
 greet: function(){
 console.log(this.msg);
 }
}

greetings.greet();
</code></pre>
If we run this code in a browser console, again we'll be greeted with:
<pre><code class="hljs">Hello World!
</code></pre>
Why do you think <code>this</code> did not refer to the <code>window</code> object this time?
<blockquote>
Implicit binding: <code>this</code> keyword is bound to the object before the dot.
</blockquote>
In our example, it refers to <code>greetings</code> object.
But if we assign the function reference <code>greetings.greet</code> to a variable:
<pre><code class="hljs">let greetRef = greetings.greet;
greetRef();
</code></pre>
We'll be greeted with:
<pre><code class="hljs">undefined
</code></pre>
Does that explain anything? Remember calling a function in a window context from the previous example?
As we are calling <code>greetRef()</code> in a <code>window</code> context, in this case <code>this</code> refers to the <code>window</code> object and we know it does not have any <code>msg</code> property.
Let us take a more complicated scenario of using an anonymous function:
<pre><code class="hljs">let factory = {
 items: [5, 1, 12],
 double: function(){
 return this.items.map(function(item, index){
 let value = item*2;
 console.log(`${value} is the double of ${this.items[index]}`);
 return value;
 });
 }
};
</code></pre>
If we call <code>factory.double()</code> we'll get the following error:
<pre><code class="hljs">Uncaught TypeError: Cannot read property '0' of undefined
 at &lt;anonymous&gt;
 at Array.map (&lt;anonymous&gt;)
</code></pre>
The error indicates that <code>this.items</code> is undefined which means <code>this</code> inside the anonymous function <code>map()</code> is not referring to the <code>factory</code> object.
These are the reasons why we call that the value of <code>this</code> is determined by a function's execution context. There are more complicated examples on this pain point which are beyond the scope of this tutorial.
There are several ways to get around this issue like passing the <code>this</code> context or using <code>bind()</code>. But using these workarounds makes the code complicated and unnecessarily bloated.
Thankfully, in ES6 the arrow functions are more predictable in terms of reference to the <code>this</code> keyword.
<h4 id="thethisoperatorandarrowfunctionsines6">The 'this' Operator and Arrow Functions in ES6</h4>
First, let us convert the anonymous function inside <code>map()</code> to an arrow function:
<pre><code class="hljs">let factory = {
 items: [5, 1, 12],
 double: function(){
 return this.items.map((item, index) =&gt; {
 let value = item*2;
 console.log(`${value} is the double of ${this.items[index]}`);
 return value;
 });
 }
};
</code></pre>
If we call <code>factory.double()</code> we'll be greeted with:
<pre><code class="hljs">10 is the double of 5
2 is the double of 1
24 is the double of 12
[10, 2, 24]
</code></pre>
As we can see the behavior of <code>this</code> inside an arrow function is quite predictable. In arrow functions <code>this</code> will always take its value from the outside. In fact, the arrow function does not even have <code>this</code>.
If we refer to <code>this</code> somewhere in the arrow function the lookup is made exactly the same way as if it were a regular variable - in the outer scope. We also call it <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Scope_(computer_science)#Lexical_scope_vs._dynamic_scope">Lexical scope</a>.
In our example, <code>this</code> inside the arrow function has the same value as the <code>this</code> outside i.e in the method <code>double()</code>. So, <code>this.items</code> in the arrow function is the same as <code>this.items</code> in the method <code>double()</code> and it is <code>factory.items</code>.
<blockquote>
Arrow functions can not be called with the <code>new</code> operator
</blockquote>
As the arrow function does not have <code>this</code> keyword, it is obvious that they cannot support the <code>new</code> operator.
<h2 id="conclusion">Conclusion</h2>
Arrow functions could be confusing to start with but it is super useful to make the code behave more predictable with the lexical scoping of the <code>this</code> keyword. It is also easy on fingers as it lets you type less code.
As a JavaScript developer, you should be comfortable using it as it is being used extensively with different frontend frameworks/libraries like React, Angular, etc. I hope this tutorial will be able to help you decide when and how to implement arrow functions in your future projects.

Shadab Ansari

Arrow Functions in JavaScript

<h2 id="introduction">Introduction</h2>
As the use of software becomes more common and more and more systems are built to handle various tasks, data plays a more important role in the current and future technology scene. Information is increasingly becoming more valuable as technology advances and opens up more opportunities for its use.
It is for this reason, and many more, that safe storage and manipulation of data have become an important aspect of any system or application that is built.
<h2 id="whatisobjectrelationalmapping">What is Object-Relational Mapping?</h2>
In many systems, real-life objects are modeled as objects in systems to ease the representation and manipulation of their attributes. For instance, a phone can be modeled as an object with attributes such as its name, operating system, manufacturer, and much more as its attributes and this can be easily manipulated and stored in a database.
Object-Relational Mapping (ORM) is a technique of mapping such objects and their attributes in the database through Object-Relational Mappers. This technique also helps us convert data between incompatible systems using object-oriented programming applications.
An ORM is a library that helps us interact with multiple databases or systems easily using our language of choice. Our code is now mapped to the databases' specific query language.
Normally, we need to use a database-specific language to interact with a database. For example, to interact with a <a rel="nofollow" target="_blank" href="https://www.mysql.com/">MySQL</a> database, we need to use the Structured Query Language (SQL), but these languages may differ from platform to platform.
For example, while they are still similar, the syntax on a <a rel="nofollow" target="_blank" href="https://www.postgresql.org/">PostgreSQL</a> database is different from the query language used on a <a rel="nofollow" target="_blank" href="https://www.microsoft.com/en-us/sql-server/sql-server-2019">Microsoft SQL</a> database. An ORM helps bridge that difference and plug in our software into different database systems with ease.
Other benefits of using an ORM includes speeding up of the development process since the developers do not have to write the database access code and repeat it every time they want to access a database. Once a model is designed and manipulation code is written, it does not need to be done again, hence making the code easy to update, maintain, and reuse.
However, there are some drawbacks associated with ORMs and they include:
<ul>
<li>ORMs have a tendency to be slow in some situations performance-wise</li>
<li>For complex queries like joins, ORMs sometimes cannot substitute raw SQL queries</li>
<li>Due to the abstractions introduced by an ORM, the developer may lose understanding of SQL and how database management is achieved behind the scenes</li>
</ul>
<h2 id="hibernate">Hibernate</h2>
<a rel="nofollow" target="_blank" href="https://hibernate.org/">Hibernate</a> is a framework that enables developers to easily persist application data in relational databases using JDBC. It is an implementation of the Java Persistence API (JPA), which means that it can be utilized in any system that supports JPA, such as the standard edition (Java SE) and the enterprise edition (Java EE).
Hibernate is a lightweight and open-source tool that simplifies the creation, manipulation, and access of data from a database in Java-based applications. It works by mapping an object created from a Java class and its attributes, to data stored in the database.
Some advantages of using Hibernate include:
<ul>
<li>It is open-source and lightweight, which means that it's free to use and has a community of contributors constantly improving it</li>
<li>Hibernate utilizes a cache internally that enhances its performance</li>
<li>It is database-independent, which means it can be used to access and manipulate data in various different databases</li>
<li>It provides the functionality to simplify joins when fetching data from multiple tables</li>
<li>By creating tables automatically, the developer can focus on doing other logic</li>
<li>It's a stable framework that has been around for 18 years</li>
</ul>
<h2 id="alternatives">Alternatives</h2>
Hibernate is not the only ORM framework that we can use in our Java applications, others include:
<ul>
<li><a rel="nofollow" target="_blank" href="https://www.jooq.org/">JOOQ</a> (Java Object Oriented Querying) is a light database-mapping software library</li>
<li><a rel="nofollow" target="_blank" href="http://jdbi.org/">JDBI</a> provides access to relational data in Java in a convenient way</li>
<li><a rel="nofollow" target="_blank" href="https://blog.mybatis.org/">MyBatis</a> is an SQL mapper framework to integrate relational databases</li>
<li><a rel="nofollow" target="_blank" href="http://avaje.com/">Ebean</a> which can be used for both Java and Kotlin-based applications</li>
<li><a rel="nofollow" target="_blank" href="http://ormlite.com/">ORMLite</a> which is a lightweight framework to persist Java objects to SQL databases</li>
</ul>
These are but a few of the alternatives for Hibernate, there are definitely even more libraries and frameworks out there that suit many different scenarios and databases.
<h2 id="implementinghibernatewithspringboot">Implementing Hibernate with Spring Boot</h2>
<h3 id="projectsetup">Project Setup</h3>
For this demo project, we are going to use a PostgreSQL database and installation instructions can be found <a rel="nofollow" target="_blank" href="https://www.educba.com/install-postgresql/">here</a> for Mac OS, Linux, and Windows platforms.
Once set up, we can create our demo database, <code>phonesdemo</code>. <a rel="nofollow" target="_blank" href="https://www.pgadmin.org/download/">PgAdmin</a> provides a user interface to interact with a PostgreSQL database, but a terminal can also be used.
Let us now see Hibernate in action by using it in a sample Spring Boot API, which we will bootstrap using the <a rel="nofollow" target="_blank" href="https://start.spring.io/">Spring Initializr</a> tool:
<img src="https://stackabuse.s3.amazonaws.com/media/implementing-hibernate-with-spring-boot-and-postgresql-1.png" alt="spring_intializr">
We will be using Java 8 and Maven for our dependency management with a few dependencies:
<ul>
<li><code>Spring Web Starter</code> to help us build a web-based application</li>
<li><code>Spring Data JPA</code> to provide the data access API that Hibernate will utilize</li>
<li><code>H2 Database</code> to bring in Hibernate functionality into our project</li>
<li><code>PostgreSQL</code> to enable us to connect to a PostgreSQL database</li>
</ul>
Once we click on &quot;Generate&quot;, we will receive a zip file containing the project and we can start implementing the web application that requires a database. Once we unpack this zip file into our working folder, we can test that it is ready to be worked on by running the command:
<pre><code class="hljs">$ mvn spring-boot:run
</code></pre>
<h3 id="implementation">Implementation</h3>
Let us modify our <code>application.properties</code> to include our database details:
<pre><code class="hljs"># Database Properties
spring.datasource.url=jdbc:postgresql://localhost:5432/phonesdemo
spring.datasource.username=postgres
spring.datasource.password=

# Hibernate Properties
# The SQL dialect makes Hibernate generate better SQL for the chosen database
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.PostgreSQL92Dialect

# Hibernate ddl auto (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto=update
</code></pre>
Hibernate provides an H2 Console that we can use to check the status of the database and even perform data entry via a user interface. We enable it by adding the following line to our <code>application.properties</code>:
<pre><code class="hljs">spring.h2.console.enabled=true
</code></pre>
Then we fire up our application and navigate to <code>http://localhost:8080/h2-console</code> to test if everything is working. We get a page where we can test if the connection to our database works:
<img src="https://stackabuse.s3.amazonaws.com/media/implementing-hibernate-with-spring-boot-and-postgresql-2.png" alt="h2_database">
For the saved settings dropdown, we are going to choose Generic PostgreSQL and we are also going to update the JDBC URL to match the name of our test database. Then we fill in our database username and password and click on &quot;Test Connection&quot; just to make sure that our Spring Application can connect to our database. If everything is well set up, we get a success message.
If we click on &quot;Connect&quot;, we get this page:
<img src="https://stackabuse.s3.amazonaws.com/media/implementing-hibernate-with-spring-boot-and-postgresql-3.png" alt="h2_console_full">
Here we can navigate our database and even perform SQL queries.
The API we will be building will be used to store and manipulate phones and their attributes such as name and operating system. With our database in place and connected, let us create an entity class (<code>Phone.java</code>) that will map our object's attributes to the database and enable us to perform CRUD operations in the database:
<pre><code class="hljs">// Imports truncated for brevity, refer to GitHub link below for the full code

@Entity
@Table(name = &quot;phones&quot;)
@EntityListeners(AuditingEntityListener.class)
public class Phone {
 @Id
 @GeneratedValue(strategy = GenerationType.AUTO)
 private long id; // Each phone will be given an auto-generated unique identifier when stored

 @Column(name = &quot;phone_name&quot;, nullable = false)
 private String phoneName; // Save the name of the phone

 @Column(name = &quot;os&quot;, nullable = false)
 private String os; // Save the operating system running in the phone
 
 // Standard getters and setters
}
</code></pre>
The <code>@Entity</code> annotation tells Hibernate that this class represents an entity that should be persisted.
The <code>@Table</code> annotation is used for naming the table. If this annotation is omitted, the table will simply use the name of the class/entity.
Similarly the <code>@Column</code> annotations can also be omitted, but the database columns will use the field names as they are, and sometimes this isn't the preferred behavior since your column names might be snake case and field names are camel case, for example.
When we save this file and restart our server and check our database, there will be a new table called <code>phones</code> and the columns of <code>id</code>, <code>phone_name</code>, and <code>os</code> will be present.
There will be no data but this is Hibernate at work, if the table specified in the entity class does not exist, Hibernate will create it for us.
Let us now implement the controller to help us perform operations on our database through an API:
<pre><code class="hljs">@RestController
@RequestMapping(&quot;/api/v1&quot;)
public class PhoneController {
 @Autowired
 private PhoneRepository phoneRepository;

 // GET method to fetch all phones
 @GetMapping(&quot;/phones&quot;)
 public List&lt;Phone&gt; getAllPhones() {
 return phoneRepository.findAll();
 }

 // GET method to fetch phone by Id
 @GetMapping(&quot;/phones/{id}&quot;)
 public ResponseEntity&lt;Phone&gt; getPhoneById(@PathVariable(value = &quot;id&quot;) Long phoneId)
 throws Exception {
 Phone phone = phoneRepository.findById(phoneId)
 .orElseThrow(() -&gt; new Exception(&quot;Phone &quot; + phoneId + &quot; not found&quot;));
 return ResponseEntity.ok().body(phone);
 }
 
 // POST method to create a phone
 @PostMapping(&quot;/phones&quot;)
 public Phone createPhone(@Valid @RequestBody Phone phone) {
 return phoneRepository.save(phone);
 }
 
 // PUT method to update a phone&#x27;s details
 @PutMapping(&quot;/phones/{id}&quot;)
 public ResponseEntity&lt;Phone&gt; updatePhone(
 @PathVariable(value=&quot;id&quot;) Long phoneId, @Valid @RequestBody Phone phoneDetails
 ) throws Exception {
 Phone phone = phoneRepository.findById(phoneId)
 .orElseThrow(() -&gt; new Exception(&quot;Phone &quot; + phoneId + &quot; not found&quot;));

 phone.setPhoneName(phoneDetails.getPhoneName());
 phone.setOs(phoneDetails.getOs());

 final Phone updatedPhone = phoneRepository.save(phone);
 return ResponseEntity.ok(updatedPhone);
 }
 
 // DELETE method to delete a phone
 @DeleteMapping(&quot;/phone/{id}&quot;)
 public Map&lt;String, Boolean&gt; deletePhone(@PathVariable(value=&quot;id&quot;) Long phoneId) throws Exception {
 Phone phone = phoneRepository.findById(phoneId)
 .orElseThrow(() -&gt; new Exception(&quot;Phone &quot; + phoneId + &quot; not found&quot;));

 phoneRepository.delete(phone);
 Map&lt;String, Boolean&gt; response = new HashMap&lt;&gt;();
 response.put(&quot;deleted&quot;, Boolean.TRUE);
 return response;
 }
}
</code></pre>
In our controller class, we annotate our class by <code>@RestController</code> to indicate that this is the request handler class that will be handling the REST functionality for our API. We then define methods to handle each of the four RESTful operations: <code>GET</code>, <code>POST</code>, <code>PUT</code>, and <code>DELETE</code>. These methods will provide an interface for us to interact with our API and manage data.
Our API, in turn, will utilize Hibernate to reflect our operations on the said data to our database.
Let us start by creating a single phone through our API:
<img src="https://stackabuse.s3.amazonaws.com/media/implementing-hibernate-with-spring-boot-and-postgresql-4.png" alt="phone_create">
We get the response from our API, but let us check the database using the H2 Console to confirm:
<img src="https://stackabuse.s3.amazonaws.com/media/implementing-hibernate-with-spring-boot-and-postgresql-5.png" alt="database_confirm">
As you can see, from the screen-shot above, to fetch the data in our database, we use the SQL command <code>SELECT * FROM phones</code>. In order to achieve the same in our code through the ORM, it is as simple as using the line:
<pre><code class="hljs">phoneRepository.findAll();
</code></pre>
This is more friendly and familiar to us since it is achieved in the same language that we are using while implementing the rest of our project.
<h2 id="conclusion">Conclusion</h2>
We have successfully created a phone object and saved its attributes to our PostgreSQL database by using Hibernate in our Spring Boot API. We can add more phones, delete phones, and update phone data by interacting with the API and Hibernate will reflect the changes in our database.
Hibernate has made it easier for us to interact with a database from our Spring Boot application and manage our data. The development time has also been significantly reduced since we do not have to write the SQL commands to manage the data ourselves.
The source code for this project is available <a rel="nofollow" target="_blank" href="https://github.com/ro6ley/java-hibernate-example">here on GitHub</a>.

Robley Gori

Implementing Hibernate with Spring Boot and PostgreSQL

Olivera Popović

Common String Operations in Java

Muhammad Junaid Khalid

Python's Bokeh Library for Interactive Data Visualization

Python for NLP: Creating TF-IDF Model from Scratch

In this article, we'll examine how to print a string without a newline character using Python.
In Python, the built-in <code>print</code> function is used to print content to the standard output, which is usually the console. By default, the print function adds a newline character at the end of the printed content, so the next output by the program occurs on the next line.
Try running this code to see an example:
<pre><code class="hljs">print(&#x27;Banana&#x27;)
print(&#x27;pudding.&#x27;)
</code></pre>
Output:
<pre><code class="hljs">Banana
pudding.
</code></pre>
As expected, the output of each <code>print</code> statement is shown on its own line.
However, in some cases we may want to output multiple strings on the same line using separate <code>print</code> statements. There are a few ways to prevent Python from adding the newline character when using the <code>print</code> function, depending on whether we are using Python 2.x or Python 3.x.
For example, this kind of functionality is useful for when you're developing a REPL or any command line application that takes input from the user, and you don't want the prompt and input text to be on different lines.
For Python 2.x, we can simply add a comma after the print function call, which will terminate the printed string with a space instead of a newline character:
<pre><code class="hljs">print(&#x27;Banana&#x27;),
print(&#x27;pudding.&#x27;)
</code></pre>
Output:
<pre><code class="hljs">Banana pudding.
</code></pre>
In Python 3.x, we can use the <code>end</code> keyword argument in the <code>print</code> method to specify the termination character for the printed string:
<pre><code class="hljs">print(&#x27;Banana&#x27;, end=&#x27; &#x27;)
print(&#x27;pudding.&#x27;)
</code></pre>
Output:
<pre><code class="hljs">Banana pudding.
</code></pre>
So in this case, a space is used as the &quot;termination&quot; character, which results in the printed strings to be on the same line and only separated by a single space.
<h2 id="abouttheauthor">About the Author</h2>
This article was written by Jacob Stopak, a software consultant and developer with a passion for helping others improve their lives through code. Jacob is the creator of <a rel="nofollow" target="_blank" href="https://initialcommit.com/codecard">Code Card</a> - a convenient tool for developers to look up, copy, and paste common code snippets.

Jacob Stopak

Python: Print without Newline

In this article, we'll examine how to use the <code>assert</code> statement in Python.
In Python, the <code>assert</code> statement is used to validate whether or not a condition is true, using the syntax:
<pre><code class="hljs">assert &lt;condition&gt;
</code></pre>
If the condition evaluates to <code>True</code>, the program continues executing as if nothing out of the ordinary happened. However, if the condition evaluates to <code>False</code>, the program terminates with an <code>AssertionError</code>.
<pre><code class="hljs">&gt;&gt;&gt; assert True
</code></pre>
Nothing happens when the code above is executed, since the condition evaluates to <code>True</code>. Alternatively, the condition in the example below evaluates to <code>False</code>:
<pre><code class="hljs">&gt;&gt;&gt; assert False
Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
AssertionError
</code></pre>
For added clarity, we can add a custom error message to the assertion output as follows:
<pre><code class="hljs">&gt;&gt;&gt; assert False, &quot;This is a custom assertion message!&quot;
Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
AssertionError: This is a custom assertion message!
</code></pre>
The assert statement is useful when we want to check that a variable in our code assumes the correct value and terminate the program if it doesn't. This helps prevent silent failure modes, which can occur if the program continues executing with erroneous values and can be difficult to debug.
Here is an example of an assert statement with a more meaningful condition. Let's assume that we want to ensure that a flag variable input by the user has been set to one of several correct values. If not, we will terminate execution of the program. We can do that as follows:
<pre><code class="hljs">&gt;&gt;&gt; flag = input(&quot;Enter a flag (y/n): &quot;)
Enter a flag (y/n): y
&gt;&gt;&gt; assert flag == &quot;y&quot; or flag == &quot;n&quot;, &quot;Invalid flag, must be &#x27;y&#x27; or &#x27;n&#x27;&quot;
</code></pre>
In the above example, the user inputted a valid value for the flag, so no errors are thrown. However, in the example below, an assertion is thrown due to invalid user input:
<pre><code class="hljs">&gt;&gt;&gt; flag = input(&quot;Enter a flag (y/n): &quot;)
Enter a flag (y/n): b
&gt;&gt;&gt; assert flag == &quot;y&quot; or flag == &quot;n&quot;, &quot;Invalid flag, must be &#x27;y&#x27; or &#x27;n&#x27;&quot;
Traceback (most recent call last):
 File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
AssertionError: Invalid flag, must be &#x27;y&#x27; or &#x27;n&#x27;
</code></pre>
When used in this way, your code should catch the thrown error and show the custom error message as output to the user so they can correct their response. This has a huge number of uses in Python programs, whether it be asserting inputs to an API route or checking that a downloaded resource contains the proper information.
Another important point to note is that when you're running the Python interpreter or Python script from the command line, the <code>–O</code> flag can be used to run the program without enforcing any assertions. This will ignore the assert statements by turning off the Python interpreter's debug mode. Be careful using this as it can lead to your code accepting invalid or dangerous inputs.
<h2 id="abouttheauthor">About the Author</h2>
This article was written by Jacob Stopak, a software consultant and developer with a passion for helping others improve their lives through code. Jacob is the creator of <a rel="nofollow" target="_blank" href="https://initialcommit.com/codecard">Code Card</a> - a convenient tool for developers to look up, copy, and paste common code snippets.