Robley Gori

Spring Security: Forgot Password Functionality

<h2 id="introduction">Introduction</h2>
Reinforcement Learning is definitely one of the most active and stimulating areas of research in AI.
The interest in this field grew exponentially over the last couple of years, following great (and greatly publicized) advances, such as <a rel="nofollow" target="_blank" href="https://www.deepmind.com/blog/alphago-zero-starting-from-scratch">DeepMind's AlphaGo</a> beating the word champion of GO, and OpenAI AI models <a rel="nofollow" target="_blank" href="https://venturebeat.com/2019/04/22/openais-dota-2-bot-defeated-99-4-of-players-in-public-matches/">beating professional DOTA players</a>.
Thanks to all of these advances, Reinforcement Learning is now being applied in a variety of different fields, from health-care to finance, from chemistry to resource management.
In this article, we will introduce the fundamental concepts and terminology of Reinforcement Learning, and we will apply them in a practical example.
<h2 id="whatisreinforcementlearning">What is Reinforcement Learning?</h2>
<a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Reinforcement_learning">Reinforcement Learning</a> (RL) is a branch of machine learning concerned with actors, or <a target="_blank" rel="noopener noreferrer" href="https://writesonic.com/blog/what-is-an-ai-agent">AI agents</a>, taking actions in some kind of environment in order to maximize some type of reward that they collect along the way.
This is deliberately a very loose definition, which is why reinforcement learning techniques can be applied to a very wide range of real-world problems.
Imagine someone playing a video game. The player is the agent, and the game is the environment. The rewards the player gets (i.e. beat an enemy, complete a level), or doesn't get (i.e. step into a trap, lose a fight) will teach him how to be a better player.
As you've probably noticed, reinforcement learning doesn't really fit into the categories of supervised/unsupervised/semi-supervised learning.
In supervised learning, for example, each decision taken by the model is independent, and doesn't affect what we see in the future.
In reinforcement learning, instead, we are interested in a long term strategy for our agent, which might include sub-optimal decisions at intermediate steps, and a trade-off between exploration (of unknown paths), and exploitation of what we already know about the environment.
<h2 id="briefhistoryofreinforcementlearning">Brief History of Reinforcement Learning</h2>
For several decades (since the 1950s!), reinforcement learning followed two separate threads of research, one focusing on trial and error approaches, and one based on optimal control.
Optimal control methods are aimed at designing a controller to minimize a measure of a dynamical system's behavior over time. To achieve this, they mainly used dynamic programming algorithms, which we will see are the foundations of modern reinforcement learning techniques.
Trial-and-error approaches, instead, have deep roots in the psychology of animal learning and neuroscience, and this is where the term reinforcement comes from: actions followed (reinforced) by good or bad outcomes have the tendency to be reselected accordingly.
Arising from the interdisciplinary study of these two fields came a field called <a rel="nofollow" target="_blank" href="http://www.scholarpedia.org/article/TD-learning">Temporal Difference (TD) Learning</a>.
The modern machine learning approaches to RL are mainly based on TD-Learning, which deals with rewards signals and a value function (we'll see more in detail what these are in the following paragraphs).
<h2 id="terminology">Terminology</h2>
We will now take a look at the main concepts and terminology of Reinforcement Learning.
<h3 id="agent">Agent</h3>
A system that is embedded in an environment, and takes actions to change the state of the environment. Examples include mobile robots, software agents, or industrial controllers.
<h3 id="environment">Environment</h3>
The external system that the agent can &quot;perceive&quot; and act on.
Environments in RL are defined as Markov Decision Processes (MDPs). A MDP is a tuple:
$$ 
(S, A, P, R, \gamma) 
$$
where:
<ul>
<li>S is a finite set of states</li>
<li>A is a finite set of actions</li>
<li>P is a state transition probability matrix</li>
</ul>
<div>
$$
P_{ss'}^{a} = \mathbb{P}[S_{t+1} = s'| S_t = s, A_t = a]
$$
</div>
<ul>
<li>R is a reward function</li>
</ul>
<div>
$$
R_s^a = \mathbb{E}[R_{t+1}|S_t=s, A_t = a]
$$
</div>
<ul>
<li>γ is a discount factor, γ ∈ [0,1]</li>
</ul>
<img class="img-responsive" alt="Markov decision process" src="https://s3.amazonaws.com/stackabuse/media/introduction-to-reinforcement-learning-with-python-1.png">
A lot of real-world scenarios can be represented as <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Markov_decision_process">Markov Decision Processes</a>, from a simple chess board to a much more complex video game.
In a chess environment, the states are all the possible configurations of the board (there are a lot). The actions refer to moving the pieces, surrendering, etc.
The rewards are based on whether we win or lose the game, so that winning actions have higher return than losing ones.
State transition probabilities enforce the game rules. For example, an illegal action (move a rook diagonally) will have zero probability.
<h3 id="rewardfunction">Reward Function</h3>
The reward function maps states to their rewards. This is the information that the agents use to learn how to navigate the environment.
A lot of research goes into designing a good reward function and overcoming the problem of sparse rewards, when the often sparse nature of rewards in the environment doesn't allow the agent to learn properly from it.
Return Gt is defined as the discounted sum of rewards from time step t.
<div>
$$
G_t=\sum_{k=0}^{\infty} \gamma^k R_{t+k+1}
$$
</div>
γ is called the discount factor, and it works by reducing the amount of the rewards as we move into the future.
Discounting rewards allows us to represent uncertainty about the future, but it also helps us model human behavior better, since it has been shown that humans/animals have a preference for immediate rewards.
<h3 id="valuefunction">Value Function</h3>
The value function is probably the most important piece of information we can hold about a RL problem.
Formally, the value function is the expected return starting from state s. In practice, the value function tells us how good it is for the agent to be in a certain state. The higher the value of a state, the higher the amount of reward we can expect:
<div>
$$
v_\pi (s) = \mathbb{E}_\pi [G_t|S_t = s]
$$
</div>
The actual name for this function is state-value function, to distinguish it from another important element in RL: the action-value function.
The action-value function gives us the value, i.e. the expected return, for using action a in a certain state s:
<div>
$$
q_\pi (s, a) = \mathbb{E}_\pi [G_t|S_t = s, A_t = a]
$$
</div>
<h3 id="policy">Policy</h3>
The policy defines the behavior of our agent in the MDP.
Formally, policies are distributions over actions given states. A policy maps states to the probability of taking each action from that state:
<div>
$$
\pi (a|s) = \mathbb{P}[A_t = a|S_t=s]
$$
</div>
The ultimate goal of RL is to find an optimal (or a good enough) policy for our agent. In the video game example, you can think of the policy as the strategy that the player follows, i.e, the actions the player takes when presented with certain scenarios.
<h2 id="mainapproaches">Main Approaches</h2>
A lot of different models and algorithms are being applied to RL problems.
Really, <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Reinforcement_learning#Comparison_of_reinforcement_learning_algorithms">a lot</a>.
However, all of them more or less fall into the same two categories: policy-based, and value-based.
<h3 id="policybasedapproach">Policy-Based Approach</h3>
In policy-based approaches to RL, our goal is to learn the best possible policy. Policy models will directly output the best possible move from the current state, or a distribution over the possible actions.
<h3 id="valuebasedapproach">Value-Based Approach</h3>
In value-based approaches, we want to find the optimal value function, which is the maximum value function over all policies.
We can then choose which actions to take (i.e. which policy to use) based on the values we get from the model.
<h2 id="explorationvsexploitation">Exploration vs Exploitation</h2>
The trade-off between exploration and exploitation has been widely studied in the RL literature.
Exploration refers to the act of visiting and collecting information about states in the environment that we have not yet visited, or about which we still don't have much information. The idea is that exploring our MDP might lead us to better decisions in the future.
On the other side, exploitation consists of making the best decision given current knowledge, comfortable in the bubble of the already known.
We will see in the following example how these concepts apply to a real problem.
<h2 id="amultiarmedbandit">A Multi-Armed Bandit</h2>
We will now look at a practical example of a Reinforcement Learning problem - the multi-armed bandit problem.
The multi-armed bandit is one of the most popular problems in RL:
<blockquote>
You are faced repeatedly with a choice among k different options, or actions. After each choice you receive a numerical reward chosen from a stationary probability distribution that depends on the action you selected. Your objective is to maximize the expected total reward over some time period, for example, over 1000 action selections, or time steps.
</blockquote>
You can think of it in analogy to a slot machine (a one-armed bandit). Each action selection is like a play of one of the slot machine’s levers, and the rewards are the payoffs for hitting the jackpot.
<img class="img-responsive" alt="Bandit machine" src="https://s3.amazonaws.com/stackabuse/media/introduction-to-reinforcement-learning-with-python-2.jpg">
Solving this problem means that we can come come up with an optimal policy: a strategy that allows us to select the best possible action (the one with the highest expected return) at each time step.
<h3 id="actionvaluemethods">Action-Value Methods</h3>
A very simple solution is based on the action value function. Remember that an action value is the mean reward when that action is selected:
<div>
$$
q(a) = E[R_t \mid A=a]
$$
</div>
We can easily estimate q using the sample average:
<div>
$$
Q_t(a) = \frac{\text{sum of rewards when "a" taken prior to "t"}}{\text{number of times "a" taken prior to "t"}}
$$
</div>
If we collect enough observations, our estimate gets close enough to the real function. We can then act greedily at each timestep, i.e. select the action with the highest value, to collect the highest possible rewards.
<h3 id="dontbetoogreedy">Don't be too Greedy</h3>
Remember when we talked about the trade-off between exploration and exploitation? This is one example of why we should care about it.
As a matter of fact, if we always act greedily as proposed in the previous paragraph, we never try out sub-optimal actions which might actually eventually lead to better results.
To introduce some degree of exploration in our solution, we can use an ε-greedy strategy: we select actions greedily most of the time, but every once in a while, with probability ε, we select a random action, regardless of the action values.
It turns out that this simple exploration method works very well, and it can significantly increase the rewards we get.
One final caveat - to avoid from making our solution too computationally expensive, we compute the average incrementally according to this formula:
<div>
$$
Q_{n+1} = Q_n + \frac{1}{n}[R_n - Q_n]
$$
</div>
<h3 id="pythonsolutionwalkthrough">Python Solution Walkthrough</h3>
<pre><code class="hljs">import numpy as np

# Number of bandits
k = 3

# Our action values
Q = [0 for _ in range(k)]

# This is to keep track of the number of times we take each action
N = [0 for _ in range(k)]

# Epsilon value for exploration
eps = 0.1

# True probability of winning for each bandit
p_bandits = [0.45, 0.40, 0.80]

def pull(a):
 &quot;&quot;&quot;Pull arm of bandit with index `i` and return 1 if win, 
 else return 0.&quot;&quot;&quot;
 if np.random.rand() &lt; p_bandits[a]:
 return 1
 else:
 return 0

while True:
 if np.random.rand() &gt; eps:
 # Take greedy action most of the time
 a = np.argmax(Q)
 else:
 # Take random action with probability eps
 a = np.random.randint(0, k)
 
 # Collect reward
 reward = pull(a)
 
 # Incremental average
 N[a] += 1
 Q[a] += 1/N[a] * (reward - Q[a])
</code></pre>
Et voilà! If we run this script for a couple of seconds, we already see that our action values are proportional to the probability of hitting the jackpots for our bandits:
<pre><code class="hljs">0.4406301434281669, 
0.39131455399060977, 
0.8008844354479673
</code></pre>
This means that our greedy policy will correctly favor actions from which we can expect higher rewards.
<h2 id="conclusion">Conclusion</h2>
Reinforcement Learning is a growing field, and there is a lot more to cover. In fact, we still haven't looked at general-purpose algorithms and models (e.g. dynamic programming, Monte Carlo, Temporal Difference).
The most important thing right now is to get familiar with concepts such as value functions, policies, and MDPs. In the Resources section of this article, you'll find some awesome resources to gain a deeper understanding of this kind of material.
<h2 id="resources">Resources</h2>
<ul>
<li><a rel="nofollow" target="_blank" href="https://www.youtube.com/watch?v=2pWv7GOvuf0">David Silver class on RL</a></li>
<li><a rel="nofollow" target="_blank" href="http://incompleteideas.net/book/the-book-2nd.html">Sutton and Barto - Reinforcement Learning: An Introduction</a></li>
</ul>

Daniele Paliotta

Introduction to Reinforcement Learning with Python

Usman Malik

Python for NLP: Working with the Gensim Library (Part 1)

Marcus Sanatan

Test Driven Development with pytest

Dan Nelson

Overview of Classification Methods in Python with Scikit-Learn

<h2 id="introduction">Introduction</h2>
Lambda functions have been an addition that came with <a rel="nofollow" target="_blank" href="https://www.oracle.com/technetwork/java/javase/overview/java8-2100321.html">Java 8</a>, and was the language's first step towards <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Functional_programming">functional programming</a>, following a general trend toward implementing useful features of various compatible <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Programming_paradigm">paradigms</a>.
The motivation for introducing lambda functions was mainly to reduce the cumbersome repetitive code that went into passing along class instances to simulate anonymous functions of other languages.
Here's an example:
<pre><code class="hljs">String[] arr = { &quot;family&quot;, &quot;illegibly&quot;, &quot;acquired&quot;, &quot;know&quot;, &quot;perplexing&quot;, &quot;do&quot;, &quot;not&quot;, &quot;doctors&quot;, &quot;where&quot;, &quot;handwriting&quot;, &quot;I&quot; };

Arrays.sort(arr, new Comparator&lt;String&gt;() {
 @Override public int compare(String s1, String s2) {
 return s1.length() - s2.length();
 }
});

System.out.println(Arrays.toString(arr));
</code></pre>
As you can see, the whole bit of instancing a new <a rel="nofollow" target="_blank" href="/sorting-algorithms-in-java/#sortinginjava">Comparator</a> class and overriding its contents is a snippet of repetitive code that we may as well do without, since it's always the same.
The entire <code>Arrays.sort()</code> line can be replaced by something much shorter and sweeter, but functionally equivalent:
<pre><code class="hljs">Arrays.sort(arr, (s1,s2) -&gt; s1.length() - s2.length());
</code></pre>
These short and sweet bits of code that do the same thing as their verbose counterparts are called <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Syntactic_sugar">syntactic sugar</a>. This is because they don't add functionality to a language, but instead make it more compact and readable. Lambda functions are an example of syntactic sugar for Java.
Although I highly suggest reading this article in order, if you're unfamiliar with the topic then here's a quick list of what we'll cover for easier reference:
<ul>
<li><a href="#lambdasasobjects">Lambdas as Objects</a>
<ul>
<li><a href="#singlemethodinterfacematching">Single-method Interface Matching</a></li>
</ul>
</li>
<li><a href="#implementation">Implementation</a>
<ul>
<li><a href="#parameters">Parameters</a></li>
<li><a href="#body">Body</a></li>
<li><a href="#variablecapture">Variable Capture</a></li>
<li><a href="#methodreferencing">Method Referencing</a>
<ul>
<li><a href="#staticmethodreference">Static Method Reference</a></li>
<li><a href="#parametermethodreference">Parameter Method Reference</a></li>
<li><a href="#instancemethodreference">Instance Method Reference</a></li>
<li><a href="#constructormethodreference">Constructor Method Reference</a></li>
</ul>
</li>
</ul>
</li>
</ul>
<h2 id="lambdasasobjects">Lambdas as Objects</h2>
Before we get into the nitty-gritty of lambda syntax itself, we should take a look at what lambda functions are in the first place and how are they used.
As mentioned, they're simply syntactic sugar, but they're syntactic sugar specifically for objects implementing a single method interface.
In those objects, the lambda implementation is considered the said method's implementation. If the lambda and the interface match, the lambda function can be assigned to a variable of that interface's type.
<h3 id="singlemethodinterfacematching">Single-Method Interface Matching</h3>
In order to match a lambda to a single method interface, also called a &quot;functional interface&quot;, several conditions need to be met:
<ul>
<li>The functional interface has to have exactly one unimplemented method, and that method (naturally) has to be abstract. The interface can contain static and default methods implemented within it, but what's important is that there's exactly one abstract method.</li>
<li>The abstract method has to accept arguments, in the same order, that correspond to the parameters lambda accepts.</li>
<li>The return type of both the method and the lambda function have to match.</li>
</ul>
If all of that is satisfied, all the conditions for matching have been made and you can assign your lambda to the variable.
Let's define our interface:
<pre><code class="hljs">public interface HelloWorld {
 abstract void world();
}
</code></pre>
As you can see, we have a pretty useless functional interface.
It contains exactly one function, and that function can do anything at all, as long as it accepts no arguments and returns no values.
We're going to make a simple Hello World program using this, though imagination is the limit if you want to play with it:
<pre><code class="hljs">public class Main {
 public static void main(String[] args) {
 HelloWorld hello = () -&gt; System.out.println(&quot;Hello World!&quot;);
 hello.world();
 }
}
</code></pre>
As we can see if we run this, our lambda function has successfully matched to the <code>HelloWorld</code> interface, and the object <code>hello</code> can now be used to access its method.
The idea behind this is that you can use lambdas wherever you'd otherwise use functional interfaces to pass along functions. If you remember our <code>Comparator</code> example, <code>Comparator&lt;T&gt;</code> is actually a functional interface, implementing a single method - <code>compare()</code>.
That's why we could replace it with a lambda that behaves similar to that method.
<h2 id="implementation">Implementation</h2>
The basic idea behind lambda functions is the same as the basic idea behind methods - they take parameters in and use them within the body consisting of expressions.
The implementation is just a bit different. Let's take the example of our <code>String</code> sorting lambda:
<pre><code class="hljs">(s1,s2) -&gt; s1.length() - s2.length()
</code></pre>
Its syntax can be understood as:
<pre><code class="hljs">parameters -&gt; body
</code></pre>
<h3 id="parameters">Parameters</h3>
Parameters are the same as function parameters, those are values passed to a lambda function for it to do something with.
Parameters are usually enclosed in brackets and separated by commas, although in the case of a lambda, which receives only one parameter, the brackets can be omitted.
A lambda function can take any number of parameters, including zero, so you could have something like this:
<pre><code class="hljs">() -&gt; System.out.println(&quot;Hello World!&quot;)
</code></pre>
This lambda function, when matched to a corresponding interface, will work the same as the following function:
<pre><code class="hljs">static void printing(){
 System.out.println(&quot;Hello World!&quot;);
}
</code></pre>
Similarly, we can have lambda functions with one, two, or more parameters.
A classic example of a function with one parameter is working on each element of a collection in a <code>forEach</code> loop:
<pre><code class="hljs">public class Main {
 public static void main(String[] args) {
 LinkedList&lt;Integer&gt; childrenAges = new LinkedList&lt;Integer&gt;(Arrays.asList(2, 4, 5, 7));
 childrenAges.forEach( age -&gt; System.out.println(&quot;One of the children is &quot; + age + &quot; years old.&quot;));
 }
}
</code></pre>
Here, the sole parameter is <code>age</code>. Note that we removed parentheses around it here, because that's allowed when we have only one parameter.
Using more parameters works similarly, they're just separated by a comma and enclosed in parentheses. We've already seen two-parameter lambda when we matched it to <code>Comparator</code> to sort Strings.
<h3 id="body">Body</h3>
A body of a lambda expression consists of a single expression or a statement block.
If you specify only a single expression as the body of a lambda function (whether in a statement block or by itself), the lambda will automatically return the evaluation of that expression.
If you have multiple lines in your statement block, or if you just want to (it's a free country), you can explicitly use a return statement from within a statement block:
<pre><code class="hljs">// just the expression
(s1,s2) -&gt; s1.length() - s2.length()

// statement block
(s1,s2) -&gt; { s1.length() - s2.length(); }

// using return
(s1,s2) -&gt; {
 s1.length() - s2.length();
 return; // because forEach expects void return
}
</code></pre>
You could try substituting any of these into our sorting example at the beginning of the article, and you'll find that they all work exactly the same.
<h3 id="variablecapture">Variable Capture</h3>
Variable capture enables lambdas to use variables declared outside of the lambda itself.
There are three very similar types of variable capture:
<ul>
<li>local variable capture</li>
<li>instance variable capture</li>
<li>static variable capture</li>
</ul>
The syntax is almost identical to how you would access these variables from any other function, but conditions under which you can do so are different.
You can access a local variable only if it's effectively final, which means that it does not change its value after assignment. It doesn't have to be explicitly declared as final, but it's advisable to do so to avoid confusion. If you use it in a lambda function and then change its value, the compiler will start whining.
The reason you can't do this is because the lambda can't reliably reference a local variable, because it may be destroyed before you execute the lambda. Because of this, it makes a <a rel="nofollow" target="_blank" href="https://en.wikipedia.org/wiki/Object_copying#Deep_copy">deep copy</a>. Changing the local variable may lead to some confusing behavior, as the programmer might expect the value within the lambda to change, so to avoid confusion, it's explicitly forbidden.
When it comes to instance variables, if your lambda is within the same class as the variable you're accessing, you can simply use <code>this.field</code> to access a field in that class. Moreover, the field does not have to be final, and can be changed later during the course of the program.
This is because if a lambda is defined within a class, it's instanced along with that class and tied to that class instance, and can thus easily refer to the value of the field it needs.
Static variables are captured much like instance variables, except for the fact that you wouldn't use <code>this</code> to refer to them. They can be changed and don't need to be final for the same reasons.
<h3 id="methodreferencing">Method Referencing</h3>
Sometimes, lambdas are just stand-ins for a specific method. In the spirit of making the syntax short and sweet, you don't actually have to type out the entire syntax when that is the case. For example:
<pre><code class="hljs">s -&gt; System.out.println(s)
</code></pre>
is equivalent to:
<pre><code class="hljs">System.out::println
</code></pre>
The <code>::</code> syntax will let the compiler know that you just want a lambda that passes along the given argument to <code>println</code>. You always just preface the method name with <code>::</code> where you would write a lambda function, otherwise accessing the method as you would normally, meaning you still have to specify the owner class before the double colon.
There are various types of method references, depending on the type of method you're calling:
<ul>
<li>static method reference</li>
<li>parameter method reference</li>
<li>instance method reference</li>
<li>constructor method reference</li>
</ul>
<h4 id="staticmethodreference">Static Method Reference</h4>
We need an interface:
<pre><code class="hljs">public interface Average {
 abstract double average(double a, double b);
}
</code></pre>
A static function:
<pre><code class="hljs">public class LambdaFunctions {
 static double averageOfTwo(double a, double b){
 return (a+b)/2;
 }
}
</code></pre>
And our lambda function and call in <code>main</code>:
<pre><code class="hljs">Average avg = LambdaFunctions::averageOfTwo;
System.out.println(avg.average(20.3, 4.5));
</code></pre>
<h4 id="parametermethodreference">Parameter Method Reference</h4>
Again, we're typing in <code>main</code>.
<pre><code class="hljs">Comparator&lt;Double&gt; cmp = Double::compareTo;
Double a = 20.3;
System.out.println(cmp.compare(a, 4.5));
</code></pre>
The <code>Double::compareTo</code> lambda is equivalent to:
<pre><code class="hljs">Comparator&lt;Double&gt; cmp = (a, b) -&gt; a.compareTo(b)
</code></pre>
<h4 id="instancemethodreference">Instance Method Reference</h4>
If we take our <code>LambdaFunctions</code> class and our function <code>averageOfTwo</code> (from <a href="#staticmethodreference">Static Method Reference</a>) and make it non-static, we'll get the following:
<pre><code class="hljs">public class LambdaFunctions {
 double averageOfTwo(double a, double b){
 return (a+b)/2;
 }
}
</code></pre>
To access this we now need an instance of the class, so we'd have to do this in <code>main</code>:
<pre><code class="hljs">LambdaFunctions lambda = new LambdaFunctions();
Average avg = lambda::averageOfTwo;
System.out.println(avg.average(20.3, 4.5));
</code></pre>
<h4 id="constructormethodreference">Constructor Method Reference</h4>
If we have a class called <code>MyClass</code> and want to call it's constructor through a lambda function, our lambda will look like this:
<pre><code class="hljs">MyClass::new
</code></pre>
It will accept as many arguments as it can match to one of the constructors.
<h2 id="conclusion">Conclusion</h2>
In conclusion, lambdas are a useful feature for making our code simpler, shorter, and more readable.
Some people avoid using them when there's a lot of Juniors on the team, so I'd advise consulting with your team before you refactor all of your code, but when everyone's on the same page they're a great tool.
<h3 id="seealso">See Also</h3>
Here's some further reading into how and where to apply lambda functions:
<ul>
<li><a rel="nofollow" target="_blank" href="/introduction-to-java-8-streams/">Streams</a></li>
<li><a rel="nofollow" target="_blank" href="https://www.dummies.com/programming/java/how-to-use-lambda-expressions-to-handle-events-in-java/">Event Listeners</a></li>
<li><a rel="nofollow" target="_blank" href="https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html">Lambda Expressions on Oracle</a></li>
</ul>

Darinka Zobenica

Lambda Expressions in Java

<h2 id="overview">Overview</h2>
In this article, we'll introduce you to <a rel="nofollow" target="_blank" href="https://spring.io/guides/gs/cloud-circuit-breaker/">Spring Cloud Netflix Hystrix</a>. It is a fault tolerance library, which implements the <a rel="nofollow" target="_blank" href="https://martinfowler.com/bliki/CircuitBreaker.html">Circuit Breaker</a> enterprise pattern - a pattern designed to prevent cascading failures.
In a typical microservice architecture we have many small applications running separately. It's quite common that one service calls another service (may be more than one) to complete a particular request. There is always a possibility that one of these downstream services won't respond correctly or simply fails completely.
A single crash may result in cascading failures which leads to too many failed network calls, wastage in memory and makes the top service which actually got the request slow.
The principle of the circuit breaker pattern is analogous to electronics:
<blockquote>
There are circuit breakers in our houses that watch for any failures. When a failure does occur, it opens the circuit (disconnecting the circuit) and thus isolates the failed area. Once you have rectified the problem, you could manually close the circuit by flipping the switch. This prevents your house from burning down.
</blockquote>
In the same way, Hystrix is watching methods for failing calls to downstream services. If a downstream service call is failing more often than allowed, Hystrix will &quot;open the circuit&quot;, isolating calls to that service.
We can add a fallback method which will be called if the circuit is open, which allows us to recover the application from the failing state. Hystrix automatically closes the circuit after a certain time, which gives time to the downstream failing service to recover.
<h2 id="setup">Setup</h2>
This article assumes that you already have knowledge of <a target="_blank" href="/spring-cloud-service-discovery-with-eureka/">Netflix's Eureka project</a>, which is used as a service registry and for load balancing.
Here's how our back-end service looks like:
<ul>
<li>Eureka Server: Acts as a service registry and runs on port <code>8761</code>.</li>
<li>Recommendation Service: A simple REST service that has a single endpoint of <code>/recommendations</code> and runs on port <code>8070</code>.</li>
<li>User Service: A simple REST service that has a single endpoint of <code>/personalized/{id}</code> and runs on port <code>8060</code>.</li>
</ul>
The user service internally calls recommendation service to get result for <code>/personalized/{id}</code>:
<pre><code class="hljs">@RestController
public class UserRestController {

 @Autowired
 RestTemplate restTemplate;

 @GetMapping(value = &quot;/personalized/{id}&quot;)
 public Product[] personalized(@PathVariable int id) {
 Product[] result = restTemplate.getForObject(&quot;http://recommendation-service/recommendations&quot;, Product[].class);
 return result;
 }
}
</code></pre>
Let's start all services navigate your browser to the Eureka server at <a rel="nofollow" target="_blank" href="http://localhost:8761/">http://localhost:8761/</a>:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-cloud-hystrix-1.png" alt="spring-cloud-hystrix-setup">
Now, let's test user-service endpoint by navigating the browser to the <a rel="nofollow" target="_blank" href="http://localhost:8060/personalized/1">http://localhost:8060/personalized/1</a> endpoint:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-cloud-hystrix-2.png" alt="spring-cloud-hystrix-user-service-result-success">
Now, just to see what happens, stop <code>recommendation-service</code> and hit the above endpoint again:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-cloud-hystrix-3.png" alt="spring-cloud-hystrix-user-service-result-failuer">
So we got a <code>500</code> error response, and this may change depending on the implementation.
It would be bad if this were to happen when an end-user is relying on our application. And what if another service was waiting for a response as well?
To avoid these situations, let's go ahead and implement Hystrix in our application.
<h2 id="addinghystrix">Adding Hystrix</h2>
To add Hystrix to our user-service, we need to import the appropriate dependency in our <code>pom.xml</code>:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.springframework.cloud&lt;/groupId&gt;
 &lt;artifactId&gt;spring-cloud-starter-netflix-hystrix&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
In the case you are building a project from scratch you can select this dependency from <a rel="nofollow" target="_blank" href="https://start.spring.io/">Spring Initializr</a>:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-cloud-hystrix-5.png" alt="spring-cloud-hystrix-spring-intializr">
To enable Hystrix, we have to annotate our main class with either <code>@EnableCircuitBreaker</code> or <code>@EnableHystrix</code>. The former option allows us to implement the circuit breaker pattern with other technologies as well. The latter option allows us to implement the circuit breaker pattern only with Hystrix:
<pre><code class="hljs">@SpringBootApplication
@EnableDiscoveryClient
@EnableCircuitBreaker
public class Application {

 public static void main(String[] args) {
 SpringApplication.run(Application.class, args);
 }

 @LoadBalanced
 @Bean
 RestTemplate restTemplate() {
 return new RestTemplate();
 }
}
</code></pre>
Now, we want to scout for adequate places to implement the circuit breaker pattern. Once we find a point that could fail and where we want to break the circuit if need be, we'll annotate it with <code>@HystrixCommand</code>.
This wraps a potentially risky method and allows us to define a fallback and breakpoint for it, using the <code>fallbackMethod</code> attribute.
Let's add this to our <code>.personalized()</code> method:
<pre><code class="hljs">@GetMapping(value = &quot;/personalized/{id}&quot;)
@HystrixCommand(fallbackMethod = &quot;recommendationFallback&quot;)
public Product[] personalized(@PathVariable int id) {
 Product[] result = restTemplate.getForObject(&quot;http://recommendation-service/recommendations&quot;, Product[].class);
 return result;
}

public Product[] recommendationFallback(int id) {
 System.out.println(&quot;=======recommendationFallback=========&quot; + id);
 return new Product[0];
}
</code></pre>
In the <code>@HystrixCommand</code> annotation, we added an attribute of <code>fallbackMethod</code>, which points to the fallback method we want to run. This attribute has to exactly match our method name, of course.
Notice that the return type and the parameter of the fallback method are the same as the original method. This is because the fallback method must have the same signature as the original. Although, instead of returning any actual data we just return an empty array.
Let's rebuild and start off the user service again. It will work the same as before when the <code>recommendation-service</code> is up.
But if we stop the <code>recommendation-service</code> and hit the user service's <code>/personalized/{id}</code> endpoint again, we will get a very different message:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-cloud-hystrix-5.png" alt="spring-cloud-hystrix-user-service-fallback">
To configure the <code>@HystrixCommand</code> you can use the <a rel="nofollow" target="_blank" href="https://github.com/Netflix/Hystrix/tree/master/hystrix-contrib/hystrix-javanica#configuration">commandProperties</a> attribute with a list of <a rel="nofollow" target="_blank" href="https://github.com/Netflix/Hystrix/wiki/Configuration">@HystrixProperty</a> annotations.
<h2 id="hystrixdashboard">Hystrix Dashboard</h2>
Hystrix also provides an optional feature to monitor all of your circuit breakers in a visually-friendly fashion.
Let's create a new project for this dashboard. As always, the best way to start with a skeleton project is to use Spring Initializr.
Select your preferred version of Spring Boot and add the &quot;Hystrix Dashboard&quot; dependency, and generate it as a Maven project:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-cloud-hystrix-7.png" alt="spring-cloud-hystrix-spring-intializer-hystrix-dashboard">
To enable it we have to add the <code>@EnableHystrixDashboard</code> annotation to our main class:
<pre><code class="hljs">@SpringBootApplication
@EnableHystrixDashboard
public class HystrixDashboardApplication {
 public static void main(String[] args) {
 SpringApplication.run(HystrixDashboardApplication.class, args);
 }
}
</code></pre>
Let's start this service on port <code>9903</code> and navigate our browser to the <a rel="nofollow" target="_blank" href="http://localhost:9903/hystrix">http://localhost:9903/hystrix</a> endpoint:
<img src="https://s3.amazonaws.com/stackabuse/media/spring-cloud-hystrix-7.png" alt="spring-cloud-hystrix-dashboard-ui">
<h3 id="addinghystrixmetricsstream">Adding Hystrix Metrics Stream</h3>
To be able to use the Hystrix dashboard, our fallback-enabled microservices need to provide data to the dashboard via a Hystrix Metrics Stream.
To add this in our user service we need to include the <code>actuator</code> dependency to our project:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt;
 &lt;artifactId&gt;spring-boot-starter-actuator&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
Also, in your <code>application.properties</code> let's include the stream:
<pre><code class="hljs">management.endpoints.web.exposure.include= hystrix.stream
</code></pre>
Doing so exposes the <code>/actuator/hystrix.stream</code> as a management endpoint.
<h3 id="monitoringahystrixstream">Monitoring a Hystrix Stream</h3>
We need to monitor the user-service hystrix metric stream. For that, let's type in <code>http://localhost:8060/actuator/hystrix.stream</code> in the box and click &quot;Monitor Stream&quot;.
<img src="https://s3.amazonaws.com/stackabuse/media/spring-cloud-hystrix-8.png" alt="spring-cloud-hystrix-dashboard-ui">
You could see many metrics regarding the user service endpoint through this stream.
Monitoring many Hystrix-enabled applications could be challenging and so Spring provided another project called <a rel="nofollow" target="_blank" href="https://github.com/spring-cloud/spring-cloud-netflix/tree/master/spring-cloud-netflix-turbine">Turbine</a>, which will aggregate streams to present in one Hystrix Dashboard.
<h2 id="conclusion">Conclusion</h2>
In this article, we've covered how to use the Hystrix fallback mechanism to our microservices to prevent cascading failures. We also set up Hystrix Metrics Streams in the Hystrix Dashboard to monitor metrics for our endpoints.
As always, the code for the examples used in this article can be found on <a rel="nofollow" target="_blank" href="https://github.com/StackAbuse/spring-cloud/tree/master/spring-hystrix">GitHub</a>.

Dhananjay Singh

Spring Cloud:  Hystrix

This is the ninth article in my series of articles on Python for NLP. In the <a target="_blank" href="/python-for-nlp-introduction-to-the-pattern-library/">previous article</a>, we saw how Python's Pattern library can be used to perform a variety of NLP tasks ranging from tokenization to POS tagging, and text classification to sentiment analysis. Before that we explored the <a target="_blank" href="/python-for-nlp-introduction-to-the-textblob-library/">TextBlob</a> library for performing similar natural language processing tasks.
In this article, we will explore <a target="_blank" rel="nofollow" href="https://stanfordnlp.github.io/CoreNLP/index.html">StanfordCoreNLP</a> library which is another extremely handy library for natural language processing. We will see different features of StanfordCoreNLP with the help of examples. So before wasting any further time, let's get started.
<h2 id="settinguptheenvironment">Setting up the Environment</h2>
The installation process for StanfordCoreNLP is not as straightforward as the other Python libraries. As a matter of fact, StanfordCoreNLP is a library that's actually written in Java. Therefore make sure you have Java installed on your system. You can download the <a target="_blank" rel="nofollow" href="https://www.java.com/en/download/">latest version of Java</a> freely.
Once you have Java installed, you need to download the JAR files for the StanfordCoreNLP libraries. The JAR file contains models that are used to perform different NLP tasks. To download the JAR files for the English models, download and unzip the folder located at the <a target="_blank" rel="nofollow" href="https://stanfordnlp.github.io/CoreNLP/download.html">official StanfordCoreNLP website</a>.
Next thing you have to do is run the server that will serve the requests sent by the Python wrapper to the StanfordCoreNLP library. Navigate to the path where you unzipped the JAR files folder. Navigate inside the folder and execute the following command on the command prompt:
<pre><code class="hljs">$ java -mx6g -cp &quot;*&quot; edu.stanford.nlp.pipeline.StanfordCoreNLPServer -timeout 10000
</code></pre>
The above command initiates the StanfordCoreNLP server. The parameter <code>-mx6g</code> specifies that the memory used by the server should not exceed 6 gigabytes. It is important to mention that you should be running a 64-bit system in order to have a heap as big as 6GB. If you are running a 32-bit system, you might have to reduce the memory size dedicated to the server.
Once you run the above command, you should see the following output:
<pre><code class="hljs">[main] INFO CoreNLP - --- StanfordCoreNLPServer#main() called ---
[main] INFO CoreNLP - setting default constituency parser
[main] INFO CoreNLP - warning: cannot find edu/stanford/nlp/models/srparser/englishSR.ser.gz
[main] INFO CoreNLP - using: edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz instead
[main] INFO CoreNLP - to use shift reduce parser download English models jar from:
[main] INFO CoreNLP - http://stanfordnlp.github.io/CoreNLP/download.html
[main] INFO CoreNLP - Threads: 8
[main] INFO CoreNLP - Starting server...
[main] INFO CoreNLP - StanfordCoreNLPServer listening at /0:0:0:0:0:0:0:0:9000
</code></pre>
The server is running at port 9000.
Now the final step is to install the Python wrapper for the StanfordCoreNLP library. The wrapper we will be using is <code>pycorenlp</code>. The following script downloads the wrapper library:
<pre><code class="hljs">$ pip install pycorenlp
</code></pre>
Now we are all set to connect to the StanfordCoreNLP server and perform the desired NLP tasks.
To connect to the server, we have to pass the address of the StanfordCoreNLP server that we initialized earlier to the <code>StanfordCoreNLP</code> class of the <code>pycorenlp</code> module. The object returned can then be used to perform NLP tasks. Look at the following script:
<pre><code class="hljs">from pycorenlp import StanfordCoreNLP

nlp_wrapper = StanfordCoreNLP(&#x27;http://localhost:9000&#x27;)
</code></pre>
<h2 id="performingnlptasks">Performing NLP Tasks</h2>
In this section, we will briefly explore the use of StanfordCoreNLP library for performing common NLP tasks.
<h3 id="lemmatizationpostaggingandnamedentityrecognition">Lemmatization, POS Tagging and Named Entity Recognition</h3>
Lemmatization, parts of speech tagging, and named entity recognition are the most basic NLP tasks. The StanfordCoreNLP library supports pipeline functionality that can be used to perform these tasks in a structured way.
In the following script, we will create an annotator which first splits a document into sentences and then further splits the sentences into words or tokens. The words are then annotated with the POS and named entity recognition tags.
<pre><code class="hljs">doc = &quot;Ronaldo has moved from Real Madrid to Juventus. While messi still plays for Barcelona&quot;
annot_doc = nlp_wrapper.annotate(doc,
 properties={
 &#x27;annotators&#x27;: &#x27;ner, pos&#x27;,
 &#x27;outputFormat&#x27;: &#x27;json&#x27;,
 &#x27;timeout&#x27;: 1000,
 })
</code></pre>
In the script above we have a document with two sentences. We use the <code>annotate</code> method of the StanfordCoreNLP wrapper object that we initialized earlier. The method takes three parameters. The <code>annotator</code> parameter takes the type of annotation we want to perform on the text. We pass <code>'ner, pos'</code> as the value for the <code>annotator</code> parameter which specifies that we want to annotate our document for POS tags and named entities.
The <code>outputFormat</code> variable defines the format in which you want the annotated text. The possible values are <code>json</code> for JSON objects, <code>xml</code> for XML format, <code>text</code> for plain text, and <code>serialize</code> for serialized data.
The final parameter is the timeout in milliseconds which defines the time that the wrapper should wait for the response from the server before timing out.
In the output, you should see a JSON object as follows:
<pre>
<div style="max-height: 400px; overflow-y: auto;">
<code class="hljs json">
{'sentences': [{'index': 0,
 'entitymentions': [{'docTokenBegin': 0,
 'docTokenEnd': 1,
 'tokenBegin': 0,
 'tokenEnd': 1,
 'text': 'Ronaldo',
 'characterOffsetBegin': 0,
 'characterOffsetEnd': 7,
 'ner': 'PERSON'},
 {'docTokenBegin': 4,
 'docTokenEnd': 6,
 'tokenBegin': 4,
 'tokenEnd': 6,
 'text': 'Real Madrid',
 'characterOffsetBegin': 23,
 'characterOffsetEnd': 34,
 'ner': 'ORGANIZATION'},
 {'docTokenBegin': 7,
 'docTokenEnd': 8,
 'tokenBegin': 7,
 'tokenEnd': 8,
 'text': 'Juventus',
 'characterOffsetBegin': 38,
 'characterOffsetEnd': 46,
 'ner': 'ORGANIZATION'}],
 'tokens': [{'index': 1,
 'word': 'Ronaldo',
 'originalText': 'Ronaldo',
 'lemma': 'Ronaldo',
 'characterOffsetBegin': 0,
 'characterOffsetEnd': 7,
 'pos': 'NNP',
 'ner': 'PERSON',
 'before': '',
 'after': ' '},
 {'index': 2,
 'word': 'has',
 'originalText': 'has',
 'lemma': 'have',
 'characterOffsetBegin': 8,
 'characterOffsetEnd': 11,
 'pos': 'VBZ',
 'ner': 'O',
 'before': ' ',
 'after': ' '},
 {'index': 3,
 'word': 'moved',
 'originalText': 'moved',
 'lemma': 'move',
 'characterOffsetBegin': 12,
 'characterOffsetEnd': 17,
 'pos': 'VBN',
 'ner': 'O',
 'before': ' ',
 'after': ' '},
 {'index': 4,
 'word': 'from',
 'originalText': 'from',
 'lemma': 'from',
 'characterOffsetBegin': 18,
 'characterOffsetEnd': 22,
 'pos': 'IN',
 'ner': 'O',
 'before': ' ',
 'after': ' '},
 {'index': 5,
 'word': 'Real',
 'originalText': 'Real',
 'lemma': 'real',
 'characterOffsetBegin': 23,
 'characterOffsetEnd': 27,
 'pos': 'JJ',
 'ner': 'ORGANIZATION',
 'before': ' ',
 'after': ' '},
 {'index': 6,
 'word': 'Madrid',
 'originalText': 'Madrid',
 'lemma': 'Madrid',
 'characterOffsetBegin': 28,
 'characterOffsetEnd': 34,
 'pos': 'NNP',
 'ner': 'ORGANIZATION',
 'before': ' ',
 'after': ' '},
 {'index': 7,
 'word': 'to',
 'originalText': 'to',
 'lemma': 'to',
 'characterOffsetBegin': 35,
 'characterOffsetEnd': 37,
 'pos': 'TO',
 'ner': 'O',
 'before': ' ',
 'after': ' '},
 {'index': 8,
 'word': 'Juventus',
 'originalText': 'Juventus',
 'lemma': 'Juventus',
 'characterOffsetBegin': 38,
 'characterOffsetEnd': 46,
 'pos': 'NNP',
 'ner': 'ORGANIZATION',
 'before': ' ',
 'after': ''},
 {'index': 9,
 'word': '.',
 'originalText': '.',
 'lemma': '.',
 'characterOffsetBegin': 46,
 'characterOffsetEnd': 47,
 'pos': '.',
 'ner': 'O',
 'before': '',
 'after': ' '}]},
 {'index': 1,
 'entitymentions': [{'docTokenBegin': 14,
 'docTokenEnd': 15,
 'tokenBegin': 5,
 'tokenEnd': 6,
 'text': 'Barcelona',
 'characterOffsetBegin': 76,
 'characterOffsetEnd': 85,
 'ner': 'ORGANIZATION'}],
 'tokens': [{'index': 1,
 'word': 'While',
 'originalText': 'While',
 'lemma': 'while',
 'characterOffsetBegin': 48,
 'characterOffsetEnd': 53,
 'pos': 'IN',
 'ner': 'O',
 'before': ' ',
 'after': ' '},
 {'index': 2,
 'word': 'messi',
 'originalText': 'messi',
 'lemma': 'messus',
 'characterOffsetBegin': 54,
 'characterOffsetEnd': 59,
 'pos': 'NNS',
 'ner': 'O',
 'before': ' ',
 'after': ' '},
 {'index': 3,
 'word': 'still',
 'originalText': 'still',
 'lemma': 'still',
 'characterOffsetBegin': 60,
 'characterOffsetEnd': 65,
 'pos': 'RB',
 'ner': 'O',
 'before': ' ',
 'after': ' '},
 {'index': 4,
 'word': 'plays',
 'originalText': 'plays',
 'lemma': 'play',
 'characterOffsetBegin': 66,
 'characterOffsetEnd': 71,
 'pos': 'VBZ',
 'ner': 'O',
 'before': ' ',
 'after': ' '},
 {'index': 5,
 'word': 'for',
 'originalText': 'for',
 'lemma': 'for',
 'characterOffsetBegin': 72,
 'characterOffsetEnd': 75,
 'pos': 'IN',
 'ner': 'O',
 'before': ' ',
 'after': ' '},
 {'index': 6,
 'word': 'Barcelona',
 'originalText': 'Barcelona',
 'lemma': 'Barcelona',
 'characterOffsetBegin': 76,
 'characterOffsetEnd': 85,
 'pos': 'NNP',
 'ner': 'ORGANIZATION',
 'before': ' ',
 'after': ''}]}]}
</code>
</div>
</pre>
If you look at the above script carefully, you can find the POS tags, named entities and the lemmatized version of each word.
<h4 id="lemmatization">Lemmatization</h4>
Let's now explore the annotated results. We'll first print the lemmatization for the words in the two sentences in our dataset:
<pre><code class="hljs">for sentence in annot_doc[&quot;sentences&quot;]:
 for word in sentence[&quot;tokens&quot;]:
 print(word[&quot;word&quot;] + &quot; =&gt; &quot; + word[&quot;lemma&quot;])
</code></pre>
In the script above, the outer loop iterates through each sentence in the document and the inner loop iterates through each word in the sentence. Inside the inner loop, the word and its corresponding lemmatized form are printed on the console. The output looks like this:
<pre><code class="hljs">Ronaldo=&gt;Ronaldo
has=&gt;have
moved=&gt;move
from=&gt;from
Real=&gt;real
Madrid=&gt;Madrid
to=&gt;to
Juventus=&gt;Juventus
.=&gt;.
While=&gt;while
messi=&gt;messus
still=&gt;still
plays=&gt;play
for=&gt;for
Barcelona=&gt;Barcelona
</code></pre>
For example, you can see the word <code>moved</code> has been lemmatized to <code>move</code>, similarly the word <code>plays</code> has been lemmatized to <code>play</code>.
<h4 id="postagging">POS Tagging</h4>
In the same way, we can find the POS tags for each word. Look at the following script:
<pre><code class="hljs">for sentence in annot_doc[&quot;sentences&quot;]:
 for word in sentence[&quot;tokens&quot;]:
 print (word[&quot;word&quot;] + &quot;=&gt;&quot; + word[&quot;pos&quot;])
</code></pre>
In the output, you should see the following results:
<pre><code class="hljs">Ronaldo=&gt;NNP
has=&gt;VBZ
moved=&gt;VBN
from=&gt;IN
Real=&gt;JJ
Madrid=&gt;NNP
to=&gt;TO
Juventus=&gt;NNP
.=&gt;.
While=&gt;IN
messi=&gt;NNS
still=&gt;RB
plays=&gt;VBZ
for=&gt;IN
Barcelona=&gt;NNP
</code></pre>
The tag set used for POS tags is the Penn Treebank tag set and can be found <a target="_blank" rel="nofollow" href="https://www.ling.upenn.edu/courses/Fall_2003/ling001/penn_treebank_pos.html">here</a>.
<h4 id="namedentityrecognition">Named Entity Recognition</h4>
To find named entities in our document, we can use the following script:
<pre><code class="hljs">for sentence in annot_doc[&quot;sentences&quot;]:
 for word in sentence[&quot;tokens&quot;]:
 print (word[&quot;word&quot;] + &quot;=&gt;&quot; + word[&quot;ner&quot;])
</code></pre>
The output looks like this:
<pre><code class="hljs">Ronaldo=&gt;PERSON
has=&gt;O
moved=&gt;O
from=&gt;O
Real=&gt;ORGANIZATION
Madrid=&gt;ORGANIZATION
to=&gt;O
Juventus=&gt;ORGANIZATION
.=&gt;O
While=&gt;O
messi=&gt;O
still=&gt;O
plays=&gt;O
for=&gt;O
Barcelona=&gt;ORGANIZATION
</code></pre>
We can see that <code>Ronaldo</code> has been identified as a <code>PERSON</code> while <code>Barcelona</code> has been identified as <code>Organization</code>, which in this case is correct.
<h3 id="sentimentanalysis">Sentiment Analysis</h3>
To find the sentiment of a sentence, all you have to do is pass <code>sentiment</code> as the value for the <code>annotators</code> property. Look at the following script:
<pre><code class="hljs">doc = &quot;I like this chocolate. This chocolate is not good. The chocolate is delicious. It&#x27;s a very tasty chocolate. This is so bad&quot;
annot_doc = nlp_wrapper.annotate(doc,
 properties={
 &#x27;annotators&#x27;: &#x27;sentiment&#x27;,
 &#x27;outputFormat&#x27;: &#x27;json&#x27;,
 &#x27;timeout&#x27;: 1000,
 })
</code></pre>
To find the sentiment, we can iterate over each sentence and then use the <code>sentimentValue</code> property to find the sentiment. The <code>sentimentValue</code> returns a value between 1 and 4 where 1 corresponds to highly negative sentiment while 4 corresponds to highly positive sentiment. The <code>sentiment</code> property can be used to get sentiment in verbal form i.e <code>positive</code>, <code>negative</code> or <code>neutral</code>.
The following script finds the sentiment for each sentence in the document we defined above.
<pre><code class="hljs">for sentence in annot_doc[&quot;sentences&quot;]:
 print ( &quot; &quot;.join([word[&quot;word&quot;] for word in sentence[&quot;tokens&quot;]]) + &quot; =&gt; &quot; \
 + str(sentence[&quot;sentimentValue&quot;]) + &quot; = &quot;+ sentence[&quot;sentiment&quot;])
</code></pre>
Output:
<pre><code class="hljs">I like this chocolate . =&gt; 2 = Neutral
This chocolate is not good . =&gt; 1 = Negative
The chocolate is delicious . =&gt; 3 = Positive
It's a very tasty chocolate . =&gt; 3 = Positive
This is so bad =&gt; 1 = Negative
</code></pre>
<h2 id="conclusion">Conclusion</h2>
<code>StanfordCoreNLP</code> is another extremely handy library for natural language processing. In this article, we studied how to set up the environment to run StanfordCoreNLP. We then explored the use of StanfordCoreNLP library for common NLP tasks such as lemmatization, POS tagging and named entity recognition and finally, we rounded off the article with sentimental analysis using StanfordCoreNLP.

Python for NLP: Getting Started with the StanfordCoreNLP Library

<h2 id="introduction">Introduction</h2>
The Python Math Library provides us access to some common math functions and constants in Python, which we can use throughout our code for more complex mathematical computations. The library is a built-in Python module, therefore you don't have to do any installation to use it. In this article, we will be showing example usage of the Python Math Library's most commonly used functions and constants.
<h2 id="specialconstants">Special Constants</h2>
The Python Math Library contains two important constants.
<h3 id="pie">Pie</h3>
The first one is Pie (π), a very popular math constant. It denotes the ratio of circumference to diameter of a circle and it has a value of 3.141592653589793. To access it, we first import the Math Library as follows:
<pre><code class="hljs">import math
</code></pre>
We can then access this constant using <code>pi</code>:
<pre><code class="hljs">math.pi
</code></pre>
Output
<pre><code class="hljs">3.141592653589793
</code></pre>
You can use this constant to calculate the area or circumference of a circle. The following example demonstrates this:
<pre><code class="hljs">import math

radius = 2
print(&#x27;The area of a circle with a radius of 2 is:&#x27;, math.pi * (radius ** 2))
</code></pre>
Output
<pre><code class="hljs">The area of a circle with a radius of 2 is: 12.566370614359172
</code></pre>
We raised the value of the radius to a power of 2 then multiplied it by pie, per the area formula of πr2.
<h3 id="eulersnumber">Euler's Number</h3>
The Euler's number (e), which is the base of natural logarithm, is also defined in the Math library. We can access it as follows:
<pre><code class="hljs">math.e
</code></pre>
Output
<pre><code class="hljs">2.718281828459045
</code></pre>
The following example demonstrates how to use the above constant:
<pre><code class="hljs">import math

print((math.e + 6 / 2) * 4.32)
</code></pre>
Output
<pre><code class="hljs">24.702977498943074
</code></pre>
<h2 id="exponentsandlogarithms">Exponents and Logarithms</h2>
In this section, we will explore the Math library functions used to find different types of exponents and logarithms.
<h3 id="theexpfunction">The exp() Function</h3>
The Python Math Library comes with the <code>exp()</code> function that we can use to calculate the power of <code>e</code>. For example, ex, which means the exponential of x. The value of <code>e</code> is 2.718281828459045.
The method can be used with the following syntax:
<pre><code class="hljs">math.exp(x)
</code></pre>
The parameter <code>x</code> can be a positive or negative number. If <code>x</code> is not a number, the method will return an error. Let us demonstrate the usage of this method with the help of an example:
<pre><code class="hljs">import math

# Initializing values
an_int = 6
a_neg_int = -8
a_float = 2.00

# Pass the values to exp() method and print
print(math.exp(an_int))
print(math.exp(a_neg_int))
print(math.exp(a_float))
</code></pre>
Output
<pre><code class="hljs">403.4287934927351
0.00033546262790251185
7.38905609893065
</code></pre>
We have declared three variables and assigned values with different numeric data types to them. We have then passed them to the <code>exp()</code> method to calculate their exponents.
We can also apply this method to inbuilt constants as demonstrated below:
<pre><code class="hljs">import math

print(math.exp(math.e))
print(math.exp(math.pi))
</code></pre>
Output
<pre><code class="hljs">15.154262241479262
23.140692632779267
</code></pre>
If you pass a non-numeric value to the method, it will generate an error, as demonstrated here:
<pre><code class="hljs">import math

print(math.exp(&quot;20&quot;))
</code></pre>
Output
<pre><code class="hljs">Traceback (most recent call last):
 File &quot;C:/Users/admin/mathe.py&quot;, line 3, in &lt;module&gt;
 print (math.exp(&quot;20&quot;))
TypeError: a float is required
</code></pre>
A TypeError has been generated as shown in the above output.
<h3 id="thelogfunction">The log() Function</h3>
This function returns the logarithm of the specified number. The natural logarithm is computed with respect to the base <code>e</code>. The following example demonstrates the usage of this function:
<pre><code class="hljs">import math

print(&quot;math.log(10.43):&quot;, math.log(10.43))
print(&quot;math.log(20):&quot;, math.log(20))
print(&quot;math.log(math.pi):&quot;, math.log(math.pi))
</code></pre>
In the script above, we have passed numeric values with different data types to the method. We have also calculated the natural logarithm of the <code>pi</code> constant. The output looks like this:
Output
<pre><code class="hljs">math.log(10.43): 2.344686269012681
math.log(20): 2.995732273553991
math.log(math.pi): 1.1447298858494002
</code></pre>
<h3 id="thelog10function">The log10() Function</h3>
This method returns the base-10 logarithm of the specified number. For example:
<pre><code class="hljs">import math

# Returns the log10 of 50
print(&quot;The log10 of 50 is:&quot;, math.log10(50))
</code></pre>
Output
<pre><code class="hljs">The log10 of 50 is: 1.6989700043360187
</code></pre>
<h3 id="thelog2function">The log2() Function</h3>
This function calculates the logarithm of a number to base 2. For example:
<pre><code class="hljs">import math

# Returns the log2 of 16
print(&quot;The log2 of 16 is:&quot;, math.log2(16))
</code></pre>
Output
<pre><code class="hljs">The log2 of 16 is: 4.0
</code></pre>
<h3 id="thelogxyfunction">The log(x, y) Function</h3>
This function returns the logarithm of x with y being the base. For example:
<pre><code class="hljs">import math

# Returns the log of 3,4
print(&quot;The log 3 with base 4 is:&quot;, math.log(3, 4))
</code></pre>
Output
<pre><code class="hljs">The log 3 with base 4 is: 0.6309297535714574
</code></pre>
<h3 id="thelog1pxfunction">The log1p(x) Function</h3>
This function calculates the logarithm(1+x), as demonstrated here:
<pre><code class="hljs">import math

print(&quot;Logarithm(1+x) value of 10 is:&quot;, math.log1p(10))
</code></pre>
Output
<pre><code class="hljs">Logarithm(1+x) value of 10 is: 2.3978952727983707
</code></pre>
<h2 id="arithmeticfunctions">Arithmetic Functions</h2>
Arithmetic functions are used to represent numbers in various forms and perform mathematical operations on them. Some of the most common arithmetic functions are discussed below:
<ul>
<li><code>ceil()</code>: returns the ceiling value of the specified number.</li>
<li><code>fabs()</code>: returns the absolute value of the specified number.</li>
<li><code>floor()</code>: returns the floor value of the specified number.</li>
<li><code>gcd(a, b)</code>: returns the greatest common divisor of <code>a</code> and <code>b</code>.</li>
<li><code>fsum(iterable)</code>: returns the sum of all elements in an iterable object.</li>
<li><code>expm1()</code>: returns (e^x)-1.</li>
<li><code>exp(x)-1</code>: when the value of x is small, calculating <code>exp(x)-1</code> may lead to a significant loss in precision. The <code>expm1(x)</code> can return the output with full precision.</li>
</ul>
The following example demonstrates the use of the above functions:
<pre><code class="hljs">import math

num = -4.28
a = 14
b = 8
num_list = [10, 8.25, 75, 7.04, -86.23, -6.43, 8.4]
x = 1e-4 # A small value of x

print(&#x27;The number is:&#x27;, num)
print(&#x27;The floor value is:&#x27;, math.floor(num))
print(&#x27;The ceiling value is:&#x27;, math.ceil(num))
print(&#x27;The absolute value is:&#x27;, math.fabs(num))
print(&#x27;The GCD of a and b is: &#x27; + str(math.gcd(a, b)))
print(&#x27;Sum of the list elements is: &#x27; + str(math.fsum(num_list)))
print(&#x27;e^x (using function exp()) is:&#x27;, math.exp(x)-1)
print(&#x27;e^x (using function expml()) is:&#x27;, math.expm1(x))
</code></pre>
Output
<pre><code class="hljs">The number is: -4.28
The floor value is: -5
The ceiling value is: -4
The absolute value is: 4.28
The GCD of a and b is: 2
Sum of the list elements is: 16.029999999999998
e^x (using function exp()) is: 0.0001000050001667141
e^x (using function expml()) is: 0.00010000500016667084
</code></pre>
Other math functions include the following:
<ul>
<li><code>pow()</code>: takes two float arguments and raises the first argument to the second argument and returns the result. For example, <code>pow(2,2)</code> is equivalent to <code>2**2</code>.</li>
<li><code>sqrt()</code>: returns the square root of the specified number.</li>
</ul>
These methods can be used as demonstrated below:
Power:
<pre><code class="hljs">math.pow(3, 4)
</code></pre>
Output
<pre><code class="hljs">81.0
</code></pre>
Square Root:
<pre><code class="hljs">math.sqrt(81)
</code></pre>
Output
<pre><code class="hljs">9.0
</code></pre>
<h2 id="trigonometricfunctions">Trigonometric Functions</h2>
The Python Math module supports all the trigonometric functions. Some of them have been enlisted below:
<ul>
<li><code>sin(a)</code>: Returns the sine of &quot;a&quot; in radians</li>
<li><code>cos(a)</code>: Returns the cosine of &quot;a&quot; in radians</li>
<li><code>tan(a)</code>: Returns the tangent of &quot;a&quot; in radians</li>
<li><code>asin(a)</code>: Returns the inverse of sine. Also, there are &quot;atan&quot; and &quot;acos&quot;.</li>
<li><code>degrees(a)</code>: Converts an angle &quot;a&quot; from radian to degrees.</li>
<li><code>radians(a)</code>: Converts angle &quot;a&quot; from degrees to radian.</li>
</ul>
Consider the following example:
<pre><code class="hljs">import math

angle_In_Degrees = 62
angle_In_Radians = math.radians(angle_In_Degrees)

print(&#x27;The value of the angle is:&#x27;, angle_In_Radians)
print(&#x27;sin(x) is:&#x27;, math.sin(angle_In_Radians))
print(&#x27;tan(x) is:&#x27;, math.tan(angle_In_Radians))
print(&#x27;cos(x) is:&#x27;, math.cos(angle_In_Radians))
</code></pre>
Output
<pre><code class="hljs">The value of the angle is: 1.0821041362364843
sin(x) is: 0.8829475928589269
tan(x) is: 1.8807264653463318
cos(x) is: 0.46947156278589086
</code></pre>
Note that we first converted the value of the angle from degrees to radians before performing the other operations.
<h2 id="typeconversion">Type Conversion</h2>
You can convert a number from one type to another. This process is known as &quot;coercion&quot;. Python can internally convert a number from one type to another when an expression has values of mixed types. The following example demonstrates this:
<pre><code class="hljs">3 + 5.1
</code></pre>
Output
<pre><code class="hljs">8.1
</code></pre>
In the above example, the integer 3 has been coerced to 3.0, a float, for addition operation and the result is also a float.
However, it is sometimes necessary for you to explicitly coerce a number from one type to another in order to meet the requirements of a function parameter or an operator. This can be done using various Python's built-in functions. For example, to convert an integer to a float, we have to call the <code>float()</code> function as shown below:
<pre><code class="hljs">a = 12
b = float(a)
print(b)
</code></pre>
Output
<pre><code class="hljs">12.0
</code></pre>
The integer has been converted to a float. A float can be converted to an integer as follows:
<pre><code class="hljs">a = 12.65
b = int(a)
print(b)
</code></pre>
Output
<pre><code class="hljs">12
</code></pre>
The float has been converted to an integer by removing the fractional part and keeping the base number. Note that when you convert a value to an int in this way, it will be truncated rather than being rounded off.
<h2 id="conclusion">Conclusion</h2>
The Python Math Library provides us with functions and constants that we can use to perform arithmetic and trigonometric operations in Python. The library comes installed in Python, hence you are not required to perform any additional installation in order to be able to use it. For more info you can find the <a rel="nofollow" target="_blank" href="https://docs.python.org/3/library/math.html">official documentation here</a>.