DEV Community: Marius Borcan

Word Cloud Python Tutorial: Create Word Cloud from Text

Marius Borcan — Sun, 05 Apr 2020 09:40:27 +0000

This article was originally written on the Programmer Backpack blog.

A Word Cloud or a Tag Cloud is a data visualization technique where words from a given text are displayed in a chart, with the more important words being written with bigger, bold fonts, while less important words are displayed with smaller, thinner fonts or not displayed at all.

Lots of Natural Language Processing projects can benefit from the use of Word Clouds because this tool can give you a quick glance at what the text you are analyzing is about and because it can help you, as a developer, or your audience, to understand the context of your dataset.

Interested in more stories like this? Follow me on Twitter at @b_dmarius and I'll post there every new article.

Word Cloud Python project

In today's project we are going to download the text from a Wikipedia page, and then generate a word cloud and play with it for a bit - changing colors, removing stopwords and saving the wordcloud to a file.

Project setup

We need to install a few packages before we begin.

pip3 install wikipedia
pip3 install wordcloud

We will also need matplotlib, but this is installed automatically by wordcloud, if you don't have on your local.

Since we've installed our packages, we might as well import them into our project.

import wikipedia
from wordcloud import WordCloud, STOPWORDS
import matplotlib.pyplot as plt

Now we are going to use the wikipedia package to download the text content. All we need for this is to provide the title of the page. We are going to fetch the text for the Natural Language Processing page on Wikipedia.

page = wikipedia.page("Natural Language Processing")
text = page.content

Next we can use this text to generate and display the word cloud.

cloud = WordCloud().generate(text)
plt.figure(figsize=(8, 8), facecolor=None)
plt.imshow(cloud, interpolation="bilinear")
plt.axis("off")
plt.tight_layout(pad=0)
plt.show()

Understanding this word cloud is very intuitive, you can observe that these words are very common when we read something about Natural Language Processing. Let's see another example, this time with the article about Machine Learning.

Again, very obvious results, but we can use this nice technique of representation to make our audience understand a text or a dataset, in the case of a Natural Language Processing task.

You can do lots of personalization on a word cloud: changing fonts, changing colors and the way they are displayed. For more options, you can always check the documentation of the package.

To demonstrate how easy it is, let's at least change the background color. For that, we only need to add a new parameter to the WordCloud constructor.

cloud = WordCloud(background_color='white').generate(text)

Removing stopwords from a word cloud

Stop words are words that are very frequently used in a given language and add absolutely no meaning to the text(because other texts will also contain these words, a stop word does not tell us anything about our text corpus).

The wordcloud package already removes the most common stopwords for us. But if you think that your text corpus has some stop words that are not removed, you can always append new words that will be removed. Here's how:

# Additional import here
from wordcloud import WordCloud, STOPWORDS
###########
stopwords = set(STOPWORDS)
stopwords.update(["stopword1", "stopword2"])
cloud = WordCloud(stopwords=stopwords, background_color='white').generate(text)

Saving our word cloud to a file

We can also save our word cloud with a single line of code.

cloud.to_file("wordcloud.png")

Conclusions

That was quick! We've generated our word cloud in very few lines of code and we can use this to better understand our data whenever we work on some Natural Language Processing project.

Thank you so much for reading this article! Interested in more? Follow me on Twitter at @b_dmarius and I'll post there every new article.

Top 7 Machine Learning Projects on Github

Marius Borcan — Sat, 04 Apr 2020 08:13:14 +0000

This article was originally published at https://programmerbackpack.com/.

Machine Learning has been a buzzword for quite a few years right now and it's the go-to thought for developers wanting to build something cool. One of the things that scare me as a developer about this subject is that it's a lot to take. New research appears every day, new projects over the night and it's really really really hard to keep track of everything.

Another thing equally important is that Machine Learning requires knowledge about Maths and Statistics and so many other fields that I may never feel confident enough to say "One day I will become a Machine Learning expert" 😀

But still, with a lot of research going on in this field, one good thing is that there is a huge list of Machine Learning resources available online(and a lot of them are free) and that includes papers, blog posts and, most important of all, open-source projects.

I love open-source Machine Learning projects(OS projects in general rock!) because they allow me, a beginner to Machine Learning, to play with different concepts in order to understand more and maybe contribute in my own way.

Thank you so much for reading this. Interested in more stories like this? Follow me on Twitter at @b_dmarius and I'll post there every new article.

Having all of these said, let's go to see the top 10 Machine Learning repositories on Github.

Tensorflow (143k stars)

Tensorflow is an open-source Machine Learning framework and it's the go-to framework for many Machine Learning projects. It can be used in Python and C++ but other, unofficial APIs are provided for other programming languages. It is used by lots of big companies and also other open-source projects are built on top of Tensorflow.

Awesome Machine Learning (44.1k stars)

Awesome Machine Learning is a curated collection of Machine Learning projects, software and other resources that a software developer can use during his/her journey of becoming a Machine Learning engineer. The collection of frameworks is organised by programming language and in general the resources are grouped by a sub-field(Computer Vision, NLP and so on).

Scikit-Learn (40k stars)

If you've read at least 3 tutorials about Machine Learning, chances are that in at least 2 of them you've seen this library being used. This is the go-to framework for many Machine Learning projects because it is very powerful, relatively easy to use and very fast.

Machine Learning for software engineers (23.6K stars)

This is another collection of resources for becoming a Machine Learning engineer, but this time more focused on learning resources than on software. It contains references to courses, videos, interviews and preparing for Machine Learning interviews.

Hands-on ML (19.3k stars)

A collection of Jupyter Notebooks that contains code and solutions to exercises for the "Hands-on Machine Learning with Scikit-Learn and TensorFlow" book written by the author of this repository. It contains lots of examples and code implementations for different subjects explained in the book and it's easy to use since it is a collection of Jupyter Notebooks.

Machine Learning from Scratch (15.8k stars)

This repository contains implementations in NumPy and for different Machine Learning models and algorithms, ranging from easy subjects as linear regression to more advanced topics on deep learning. The code is contained in Jupyter Notebooks which are, again, easy to test.

Cheatsheets AI (13.2k stars)

A collection of cheatsheets about different subjects addressed to machine learning and deep learning engineers. This is very useful if you want to refresh your memory on some Machine Learn knowledge or you could use it as a reference that can guide you on your Machine Learning path.

Machine Learning projects come and go every day, but the most important of them stick and will be here to help us all in our journey of learning and applying Machine Learning to our projects.
This list changes frequently as more and more repositories appear everyday. You can always search for new projects by using the Github search page.

Thank you so much for reading this. Interested in more stories like this? Follow me on Twitter at @b_dmarius and I'll post there every new article.

Decision Tree Classifier Tutorial in Python and Scikit-Learn

Marius Borcan — Sat, 21 Mar 2020 17:34:28 +0000

This article was originally published at https://programmerbackpack.com/.

Decision Tree Classifier is a classification model that can be used for simple classification tasks where the data space is not huge and can be easily visualized. Despite being simple, it is showing very good results for simple tasks and outperforms other, more complicated models.

This article is part two of a two-article mini-series on the Decision Tree Classifier. For a detailed overview of the logic and principles behind this model, please check part-one: Decision Tree Classifiers Explained.

Interested in more stories like this? Follow me on Twitter at @b_dmarius and I'll post there every new article.

Dataset for the Decision Tree Classifier

Recently I've created a small dummy dataset to use for simple classification tasks. I'll paste the dataset here again for your convenience.

The purpose of this data is, given 3 facts about a certain moment(the weather, whether it is a weekend or a workday or whether it is morning, lunch or evening), can we predict if there's a traffic jam in the city?

Decision Tree Classifier in Python with Scikit-Learn

We have 3 dependencies to install for this project, so let's install them now. Obviously, the first thing we need is the scikit-learn library, and then we need 2 more dependencies which we'll use for visualization.

pip3 install scikit-learn
pip3 install matplotlib
pip3 install pydotplus

Now let's import what we need from these packages.

from sklearn import preprocessing
from sklearn import tree
from IPython.display import Image
import pydotplus

Now let's load our dataset. In a previous article on the Naive Bayes Classifier I've defined a few helper methods to easily load our simple dataset. Let's reuse that.

def getWeather():
    return ['Clear', 'Clear', 'Clear', 'Clear', 'Clear', 'Clear',
            'Rainy', 'Rainy', 'Rainy', 'Rainy', 'Rainy', 'Rainy',
            'Snowy', 'Snowy', 'Snowy', 'Snowy', 'Snowy', 'Snowy']

def getTimeOfWeek():
    return ['Workday', 'Workday', 'Workday',
            'Weekend', 'Weekend', 'Weekend',
            'Workday', 'Workday', 'Workday',
            'Weekend', 'Weekend', 'Weekend',
            'Workday', 'Workday', 'Workday',
            'Weekend', 'Weekend', 'Weekend']

def getTimeOfDay():
    return ['Morning', 'Lunch', 'Evening',
            'Morning', 'Lunch', 'Evening',
            'Morning', 'Lunch', 'Evening',
            'Morning', 'Lunch', 'Evening',
            'Morning', 'Lunch', 'Evening',
            'Morning', 'Lunch', 'Evening',
            ]

def getTrafficJam():
    return ['Yes', 'No', 'Yes',
            'No', 'No', 'No',
            'Yes', 'Yes', 'Yes',
            'No', 'No', 'No',
            'Yes', 'Yes', 'Yes',
            'Yes', 'No', 'Yes'
            ]

Decision Tree Classifier - preprocessing

We know that computers have a really hard time when dealing with text and we can make their lives easier by converting the text to numerical values.

Label Encoder

We will use this encoder provided by scikit to transform categorical data from text to numbers. If we have n possible values in our dataset, then LabelEncoder model will transform it into numbers from 0 to n-1 so that each textual value has a number representation.

For example, let's encode our time of day values.

 timeOfDay = ['Morning', 'Lunch', 'Evening',
            'Morning', 'Lunch', 'Evening',
            'Morning', 'Lunch', 'Evening',
            'Morning', 'Lunch', 'Evening',
            'Morning', 'Lunch', 'Evening',
            'Morning', 'Lunch', 'Evening',
            ]
    labelEncoder = preprocessing.LabelEncoder()
    encodedTimeOfDay = labelEncoder.fit_transform(timeOfDay)
    print (encodedTimeOfDay)

    # Prints [2 1 0 2 1 0 2 1 0 2 1 0 2 1 0 2 1 0]

Training the Decision Tree Classifier model

Now let's train our model. So remember, since all our features are textual values, we need to encode all our values and only then we can jump to training.

if __name__=="__main__":
    # Get the data
    weather = getWeather()
    timeOfWeek = getTimeOfWeek()
    timeOfDay = getTimeOfDay()
    trafficJam = getTrafficJam()

    labelEncoder = preprocessing.LabelEncoder()

    # Encode the features and the labels
    encodedWeather = labelEncoder.fit_transform(weather)
    encodedTimeOfWeek = labelEncoder.fit_transform(timeOfWeek)
    encodedTimeOfDay = labelEncoder.fit_transform(timeOfDay)
    encodedTrafficJam = labelEncoder.fit_transform(trafficJam)

    # Build the features
    features = []
    for i in range(len(encodedWeather)):
        features.append([encodedWeather[i], encodedTimeOfWeek[i], encodedTimeOfDay[i]])

    classifier = tree.DecisionTreeClassifier()
    classifier = classifier.fit(features, encodedTrafficJam)

Using our model for predictions

Now we can use the model we have trained to make predictions about the traffic jam.

 # ["Snowy", "Workday", "Morning"]
    print(classifier.predict([[2, 1, 2]]))
    # Prints [1], meaning "Yes"
    # ["Clear", "Weekend", "Lunch"]
    print(classifier.predict([[0, 0, 1]]))
    # Prints [0], meaning "No"

And it seems to be working! It correctly predicts the traffic jam situations given our data.

Visualizing our model

Scikit also provides us with a way of visualizing a Decision Tree model. Here's a quick helper method I wrote to generate a .png image from our decision tree.

def printTree(classifier):
    feature_names = ['Weather', 'Time of Week', 'Time of Day']
    target_names = ['Yes', 'No']
    # Build the daya
    dot_data = tree.export_graphviz(classifier, out_file=None,
                                    feature_names=feature_names,
                                    class_names=target_names)
    # Build the graph
    graph = pydotplus.graph_from_dot_data(dot_data)

    # Show the image
    Image(graph.create_png())
    graph.write_png("tree.png")

And here's the result from that.

Yes, so I'm very happy with the results we got today. We used a really small dataset and a really small model, but I think we've learned a lot about this type of classifier.

If you want to explore more about the logic behind the Decision Tree Classifier, then please don't forget to read the other article in this mini-series: Decision Tree Classifiers Explained.

Thank you so much for reading this! Interested in more stories like this? Follow me on Twitter at @b_dmarius and I'll post there every new article.

Naive Bayes Classifier Tutorial in Python and Scikit-Learn

Marius Borcan — Sat, 14 Mar 2020 13:55:23 +0000

This article was originally published on https://programmerbackpack.com.

Naive Bayes Classifier is a simple model that's usually used in classification problems. Despite being simple, it has shown very good results, outperforming by far other, more complicated models.

This is the second article in a series of two about the Naive Bayes Classifier and it will deal with the implementation of the model in Scikit-Learn with Python. For a detailed overview of the math and the principles behind the model, please check the other article: Naive Bayes Classifier Explained.

Interested in more stories like this? Follow me on Twitter at @b_dmarius and I'll post there every new article.

Data for training the Naive Bayes Classifier

In the previous article linked above, I introduced a table of some data that we can train our classifier on. For convenience, I'll paste it again here.

Note: the dataset is built by me for the sake of simplictiy and the values are based on common sense situations.

Naive Bayes Classifier implementation in Scikit-Learn

Now let's get to work. We need only one dependency installed for this, and that is the scikit-learn python library. It is one of the most powerful librarie for machine learning and data science and it is free to use. So let's install the library.

pip3 install scikit-learn

Now let's import the dependencies. We only have two dependencies and I'll explain why we need them.

from sklearn import preprocessing
from sklearn.naive_bayes import GaussianNB

The sklearn library contains more than one Naive Bayes classifiers and each is different by means of implementation. Not every classifier implementation is recommended for one type of problem. That's why we have more than one implementation, because some classifiers perform better on some types of data, while others don't. The types of classifiers that the library contains are:

Gaussian Naive Bayes
Multinomial Naive Bayes
Complement Naive Bayes
Bernoulli Naive Bayes
Categorical Naive Bayes

For today we are going to choose the Gaussian Naive Bayes. For further details on all the other types of classifiers, please read this.

Moving on we need to construct our dataset. For reasons of speed and simplicity and because our dataset is quite small, I've created 4 simple methods to hardcode the data in the dataset.

def getWeather():
    return ['Clear', 'Clear', 'Clear', 'Clear', 'Clear', 'Clear',
            'Rainy', 'Rainy', 'Rainy', 'Rainy', 'Rainy', 'Rainy',
            'Snowy', 'Snowy', 'Snowy', 'Snowy', 'Snowy', 'Snowy']

def getTimeOfWeek():
    return ['Workday', 'Workday', 'Workday',
            'Weekend', 'Weekend', 'Weekend',
            'Workday', 'Workday', 'Workday',
            'Weekend', 'Weekend', 'Weekend',
            'Workday', 'Workday', 'Workday',
            'Weekend', 'Weekend', 'Weekend']

def getTimeOfDay():
    return ['Morning', 'Lunch', 'Evening',
            'Morning', 'Lunch', 'Evening',
            'Morning', 'Lunch', 'Evening',
            'Morning', 'Lunch', 'Evening',
            'Morning', 'Lunch', 'Evening',
            'Morning', 'Lunch', 'Evening',
            ]

def getTrafficJam():
    return ['Yes', 'No', 'Yes',
            'No', 'No', 'No',
            'Yes', 'Yes', 'Yes',
            'No', 'No', 'No',
            'Yes', 'Yes', 'Yes',
            'Yes', 'No', 'Yes'
            ]

No let's try gathering this data and building our model. But first, we need to do a little bit of preprocessing. Computers are generally bad at understanding text, but they are very good with numbers. So we need to transform our text data into numbers so that our model can better understand it.

Label Encoder

This is a encoder provided by scikit that transforms categorical data from text to number. If we have n possible values in our dataset, then LabelEncoder model will transform it into numbers from 0 to n-1 so that each textual value has a number representation. For example, our weather value will be encoded like this.

  weather = ['Clear', 'Clear', 'Clear', 'Clear', 'Clear', 'Clear',
            'Rainy', 'Rainy', 'Rainy', 'Rainy', 'Rainy', 'Rainy',
            'Snowy', 'Snowy', 'Snowy', 'Snowy', 'Snowy', 'Snowy']
  labelEncoder = preprocessing.LabelEncoder();
  print (labelEncoder.fit_transform(weather))

  # Prints [0 0 0 0 0 0 1 1 1 1 1 1 2 2 2 2 2 2]

Let's also represent our traffic jam values.

    trafficJam = ['Yes', 'No', 'Yes',
            'No', 'No', 'No',
            'Yes', 'Yes', 'Yes',
            'No', 'No', 'No',
            'Yes', 'Yes', 'Yes',
            'Yes', 'No', 'Yes'
            ]
    print(labelEncoder.fit_transform(trafficJam))

    # Prints [1 0 1 0 0 0 1 1 1 0 0 0 1 1 1 1 0 1]

Training the model

We need to transform all 4 values(3 features and the label) and then we can train the model.

    # Get the data
    weather = getWeather()
    timeOfWeek = getTimeOfWeek()
    timeOfDay = getTimeOfDay()
    trafficJam = getTrafficJam()

    labelEncoder = preprocessing.LabelEncoder()

    # Encode the features and the labels
    encodedWeather = labelEncoder.fit_transform(weather)
    encodedTimeOfWeek = labelEncoder.fit_transform(timeOfWeek)
    encodedTimeOfDay = labelEncoder.fit_transform(timeOfDay)
    encodedTrafficJam = labelEncoder.fit_transform(trafficJam)

    # Build the features
    features = []
    for i in range(len(encodedWeather)):
        features.append([encodedWeather[i], encodedTimeOfWeek[i], encodedTimeOfDay[i]])

    model = GaussianNB()

    # Train the model
    model.fit(features, encodedTrafficJam)

Using our model for predictions

Now we can use this model to make predictions about the traffic jam.

# ["Snowy", "Workday", "Morning"]
print(model.predict([[2, 1, 2]]))
# Prints [1], meaning "Yes"
# ["Clear", "Weekend", "Lunch"]
print (model.predict([[0, 0, 1]]))
# Prints [0], meaning "No"

That's great! For me, it looks that we managed to build a simple classifier using so little data. For building a more realistic model, we would need more features and more entries. But still, for learning purposes, I think we did a really good job.

Don't forget, if you want dig down the math and principles behind this classifier, you can always check my other article in this mini-series, Naive Bayes Classifier Explained.

Thank you so much for reading this! Interested in more stories like this? Follow me on Twitter at @b_dmarius and I'll post there every new article.

Python Keywords Extraction - Machine Learning Project Series: Part 2

Marius Borcan — Fri, 13 Mar 2020 20:03:29 +0000

This article was originally published at https://programmerbackpack.com.

Interested in more stories like this? Follow me on Twitter at @b_dmarius and I'll post there every new article.

What is Keywords Extraction

Keywords extraction is a subtask of the Information Extraction field which is responsible for extracting keywords from a given text or from a collection of texts to help us summarize the content. This is useful in the context of the huge amount of information we deal with every day. We need to index this information, to organise it and retrieve it later. Keywords extraction becomes more and more important these days and keywords extraction algorithms are researched and improved continuously.

Today we are going to discuss about TextRank, one of the most famous algorithms for keywords extraction and text summarization and play with a short implementation in Python.

In the first article in this series I talked about starting a journey about studying Machine Learning by starting a personal project - a personal knowledge management system that can help me track the things I learn.

In the latest article in this series, we discussed about named entity recognition. Now, another must have functionality that I would like to have is the ability to automatically extract keywords from the content I save to my application. In this way, I can search for it easily in the future or I can organise my content faster and easier.

Understand TextRank for Keywords Extraction

If the name TextRank sounds familiar to you, that's because you may think of another famous algorithm, PageRank. And you'd be right to think of PageRank, because not only the name is inspired from it, but also the basic principles.

PageRank is an algorithm that Google uses to rank web pages against a user search query from a user. It is used to measure the importance of a web page by observing the links/references(by number and by quality and importance) between web pages. The assumption here is that the higher the number of references to a web page, then the more important should that web page be.

You can checkout the Wikipedia page for PageRank for a mathematical explanation of the PageRank algorithm if you're interested in more details, but the main takeaway for this is: more important web pages are referenced by important web pages. By applying the PageRank algorithm, we estimate the probability that a user will click access a given web page.

Now back to TextRank, the same logic is applied. TextRank is a graph-based algorithm and we will represent the data like this:

The nodes in the graph will be represented by the words in our text
The vertices of the graph will be represented by the similarity scores between two given nodes(so two given words in our text)

Basically, the steps for applying the TextRank algorithm are the following:

Split the whole text into words
Calculate word embeddings using any word embedings representation
Calculate similarity scores choosing any similarity metric based on the word embeddings you obtained in the previous step
Build the graph using the words as nodes and similarity scores as vertices
Get the first n words, choosing n to serve your purposes

The math beyond the TextRank algorithm is beyond the scope of this article, because we would also like to play with this algorithm for a little bit. If you think I should write a more detailed blog post about this algorithm, please let me know and I'll gladly do. Now let's move on to the fun stuff.

Python Keyword Extraction using Gensim

Gensim is an open-source Python library for usupervised topic modelling and advanced natural language processing. It is very easy to use and very powerful, making it perfect for our project. This library contains a TextRank implementation that we can use with very few lines of code.

One important thing to note here is that at the moment the Gensim implementation for TextRank only works for English. During the TextRank algorithm words are stemmed and stopwords are removed and this is a language-dependend process, and so the library only contains the implementation for English.

We need very few dependencies installed for this project.

pip3 install gensim
pip3 install networks
pip3 install matplotlib

Next up we should import everything we need for this project. We will use the keywords method from gensim for extracting the keywords and the get_graph to method to display a graph of our text. Next up, matplotlib and networkx are used for visualisation purposes.

from gensim.summarization import keywords
from gensim.summarization.keywords import get_graph
import networkx as nx
import matplotlib.pyplot as plt

Getting the keywords of a text with Gensim is very easily, it's actually a matter of two lines of code. To prove how well this algorithm works, I will provide as a text input the first paragraph of this blog post, the one in which we talk about keywords extraction. This text is returned by the get_text() method.

if __name__=="__main__":

    text = get_text()
    print (keywords(text).split('\n'))

And the result is as follows:

['extracting', 'keywords extraction']

As you can see, the two keywords(or keyphrases) are exactly what I would like to obtain for a paragraph like the given one. The text is exactly about keywords extraction and that is what I obtained.

We now can build the graph of the text so that we can see how our words are related to each other? Then we can use this code.

def displayGraph(textGraph):

    graph = nx.Graph()
    for edge in textGraph.edges():
        graph.add_node(edge[0])
        graph.add_node(edge[1])
        graph.add_weighted_edges_from([(edge[0], edge[1], textGraph.edge_weight(edge))])

        textGraph.edge_weight(edge)
    pos = nx.spring_layout(graph)
    plt.figure()
    nx.draw(graph, pos, edge_color='black', width=1, linewidths=1,
            node_size=500, node_color='seagreen', alpha=0.9,
            labels={node: node for node in graph.nodes()})
    plt.axis('off')
    plt.show()

if __name__=="__main__":

    text = get_text()
    displayGraph(get_graph(text))

And the result should look like this. Don't worry if the words seem a little incomplete to you. It's the result of the stemming in other transformations Gensim does during the TextRank algorithm.

What about if we try with the whole text of this blog?

['python', 'algorithms', 'algorithm', 'extraction', 'extracting', 'extract', 'textrank', 'web', 'words', 'word', 'given text', 'blog', 'continuously', 'steps', 'step', 'machine', 'like', 'topic', 'article', 'entity', 'search', 'language', 'keywords', 'keyword', 'implementation', 'texts']

Then we get a whole lot more keywords, but keep in mind they are ordered by importance. So if we just wanted to extract only 3 words for this blog post, after removing the duplicates, we would have got: python, algorithms and extraction. Sounds like a great result to me!

Wrapping up

So today we discussed a bit about the TextRank algorithm for extracting keywords from a given text. We saw some fundamental principles behind the algorithm and played with an implementation in the Gensim library. And I feel we actually got good results!

Thank you so much for reading this! Interested in more stories like this? Follow me on Twitter at @b_dmarius and I'll post there every new article.

6 Ways To Stay Productive When You Work From Home

Marius Borcan — Thu, 12 Mar 2020 19:10:03 +0000

This article was originally published at https://programmerbackpack.com.

Thank you so much for reading this article! Interested in more? Follow me on Twitter at @b_dmarius and I'll post there every new article.

Working from home or working remotely is an option that more and more people chase because it offers us comfort and it wins us lots and lots of time due to the fact that we don't have to commute(and don't tell me you don't hate commuting, I won't believe you).

But even so, have you ever felt that you are not as productive at home as you are when you're in the office? Is it a matter of too much comfort? Or do we get distracted? Maybe it's harder to stay connected to your colleagues when you're not in the office. If you're in this case or if you just want to improve your work from home routine, then here's 6 ways to stay productive when you work from home.

Choose your best setup

When you work from home it's best if you can find yourself a comfortable place to work. I don't recommend that you work from your bed, as it is bad for your health and can make you feel and be less productive, but if that's what you prefer, then you're free to do it.

Personally I enjoy working on a small table I have in my dining room. I prefer having a desk that's not too cluttered since having a workspace that's not organised steals my concentration away from me. Are you getting tired of sitting on a chair? Then I recommended jumping on your sofa for an hour and then come back to your desk. The change of scenery and a little bit more comfort can make your work from home day more enjoyable and productive.

Do you have a balcony or a terrace and the weather happens to be nice today? Then as long as you have a fully charged battery on your laptop, I don't see why you can't get outside for a bit. I personally really really like working on my balcony when the weather is nice.

Choose a playlist

If you're like me, then you enjoy working while listening to music. I like to listen soundtracks which I've listened many times before(so that I don't get distracted by the lyrics) or movie sountracks(because most of them, again, don't have lyrics). I listen to music in short bursts of highly productive work sessions because after a while I get tired or my ears start to hurt.

But I get more done in one hour of listening to music than maybe 3 hours of working without music. It helps me stay focused and don't fall into distractions, especially because I have an undisciplined mind that likes to carry me away and make me lose focus.

Find your favourite playlist and listen to it for a short period of time. Take a break and then do it again. You'll feel more energized and more productive.

Stay focused

It's usually easier to get distracted while working from home than while working in the office. In the office everybody is at their desk and doing their job, while when you're at home is just you.

And imagine, it's your home, you're surrounded by all your favorite distractions. It's very easy to worry less about your job and more about your game console or about your pet or about that new Netflix special.

My advice is disconnect from anything that is not absolutely necessary. Ideally, you only have your laptop near you. TV shut down, your phone on silent mode unless you really need it not to be. You should treat a work from home day just like any regular work from office day.

Thinking about taking a break? I absolutely recommend breaks, but take them responsibly and just like you would take them in the office. If you think that your colleagues need you anytime soon, stay around your laptop and/or your phone and be available.

Stay connected

Talking about be available, you should always be available to your colleagues or to your bosses when working from home. Working from home has only recently been accepted in most of the big companies around the world and it's only because these companies have seen that employees usually stay at least as productive as while working from the office, if not even more.

So it's important for us that we prove that we can stay productive while working from home and that we take our assignments and responsibilities seriously. Therefore, stay connected by all means of communication that your team uses, be active on all channels. These way, your employer will trust you and allow you to work from home even more in the future.

Dress up

One way to get you in the mood for working is to get dressed up like you do when going to the office. Especially if it's a day when you know you're going to get in a lot of calls with colleagues, clients or bosses, you should be respectful. So don't show up in that ugly hoodie that we all have in our closet, it's not nice.

Moreover, getting dressed for office even if you work from home allows you to stay focused. For me, personally, it gets me in work mode and allows me to be more productive.

Do take breaks

During my first days of working from home, I was usually tempted to work even a lot harder than in the office. Taking breaks made me feel guilty because laying on the couch for 2 minutes felt like I was cheating on my colleagues and my company. Moreover, I used to put in a lot more work hours while working from home, especially because during my first days at home I felt more energized and motivated.

But that should not usually be the case. I get you, if you're on a tight deadline of if something urgent needs to be fixed, then do your best. But don't forget to take a break and most important to stand up. When we're in office, we stand up when we take a break, but when we're at home, we just stay in bed, which is worse for our health. Stand up, do some physical exercises. It's healthy and will make you feel more energized.

Moreover, at the end of the day you should not neglect your other responsibilities. Do you feel like you've acomplished everything you had for today? Then log out, shut down your laptop then do your other stuff. Go out, do your chores or whatever you feel like doing. Working from home does not mean we should be online for 24h.

Thank you so much for reading this article! Interested in more? Follow me on Twitter at @b_dmarius and I'll post there every new article.

Machine Learning Project Series: Part 1 - Python Named Entity Recognition

Marius Borcan — Sat, 07 Mar 2020 17:48:43 +0000

This article was originally published at https://programmerbackpack.com.

Interested in more stories like this? Follow me on Twitter at @b_dmarius and I'll post there every new article.

In an earlier article I talked about starting a journey about studying Machine Learning by starting a personal project - a personal knowledge management system that can help me track the things I learn.

While defining my requirements for an app like this, I also look into new things and share them here, maybe someone else will also find them useful.

Let's say I am caught up in a research session and I stumble upon a name of a researcher which sounds familiar to me. I can of course look that person up on Google, but what if I want to know where do I know this name from? Have I read something published by this author or have I read some piece of news about him/her? It would be useful to have my research history saved somewhere and look this person up in that history and find out I've enjoyed some of this author's work before.

What is Named Entity Recognition

Information Extraction is a very difficult problem. The task of transforming natural language – so something that is very nuanced and can have subtle differences from human to human – to something that all computers can understand is insanely difficult and is a problem we are still very far from solving. Still programmers are used to taking a big problem and solving it piece by piece until, hopefully, the whole task is solved.

Named Entity Recognition is a subtask of the Information Extraction field which is responsible for identifying entities in an unstrctured text and assigning them to a list of predefined entities. The list of entities can be a standard one or a particular one if we train our own linguistic model to a specific dataset. But most of the times, the entities which are usually identified are Persons, Organisations, Locations, Time, Monetary values and so on.

Named Entity Recognition consists actually of two substeps: Named Entity Identification and Named Entity Classification and that means we first find the entities mentioned in a given text and only then we assign them to a particular class in our list of predefined entities.

For example, let's have the following sentence:
"Bill Gates was the CEO of Microsoft until 2000."

Here we can identify that Bill Gates, Microsoft and 2000 are our entities. We then correctly classify them as Person, Organisation and Date respectively. We must take care so that we do not identify Bill and Gates as two different enitities, as we are using both words for talking about the same person!

How does Named Entity Recognition work

Honestly it really dependes on who built the model. I know it sounds superficial, but it's the truth. There is a lot of research going on for finding the perfect NER model, and researchers come up with different methods and approaches. I am also sure that there is a lot of research which has not been published, but that's because companies use proprietary technologies to ensure they build the best model there is.

But of course, there are some steps that every NER model should take, and this is what we are going to talk about now.

First step in Named Entity Recognition is actually preparing the data to be parsed. As we discussed here, preparing the data for NLP is quite a long and complicated journey. We are talking about building a pipeline that can do the following for you:

Sentence boundary segmentation
Word tokenization
Part of Speech tagging

Second step in Named Entity Recognition would be searching the tokens we got from the previous step agains a knowledge base. The knowledge base can be an ontology with words, their meaning and the relationships between them.

The search can also be made using deep learning models. This approach has the advantage that it gets better results when seeing new words which were not seen before(as opposed to the ontology, where we would get no results in this situation).

Third step in Named Entity Recognition would happen in the case that we get more than one result for one search. Then we would need some statistical model to correctly choose the best entity for our input.

Python Named Entity Recognition tutorial with spaCy

Lucky for us, we do not need to spend years researching to be able to use a NER model. We can use one of the best in the industry at the moment, and that is spaCy. I highly encourage you to open this link and look it up. It has lots of functionalities for basic and advanced NLP tasks. And doing NER is ridiculously easy, as you'll see.

First let's install spaCy and download the English model.

pip3 install spacy
python3 -m spacy download en_core_web_sm

Then open up your favourite editor. We will use two extracts from the Wikipedia page about Vue.js.

import spacy
from spacy import displacy

if __name__ == "__main__":

    nlp = spacy.load('en_core_web_sm')
    doc = nlp("Vue is an open-source Model–view–viewmodel "
              "JavaScript framework for building user interfaces and single-page applications."
              " It was created by Evan You, and is maintained by him and the rest of the active core team members coming"
              " from various companies such as Netlify and Netguru."
              " Vue was created by Evan You after working for Google using AngularJS in a number of projects. "
              " He later summed up his thought process: \"I figured, what if I could just extract the part that I really liked about Angular and build something really lightweight\""
              " The first source code commit to the project was dated July 2013, and Vue was first released the following February, in 2014. ")


    for entity in doc.ents:
        print(entity.text, entity.label_)

This will give us the following entities:

Vue ORG
JavaScript ORG
Evan You PERSON
Netlify and Netguru ORG
Google ORG
Angular ORG
first ORDINAL
July 2013 DATE
Vue ORG
first ORDINAL
February DATE
2014 DATE

We can see that most of the entities have been identified correctly. No misidentification(no entity which has been identified as something when it should have been something else) but still we have one example of an entity which has not been identified at all("AngularJS").

But all we needed were 4 lines of code and we got our Named Entity Recognition system! You can check here all the entities that spaCy can identify.

Visualising our Named Entity Recognition results

We can visualise the results we get by adding only one line of code:

displacy.serve(doc, style="ent")

Wrapping up

So in today's article we discussed a little bit about Named Entity Recognition and we saw a simple example of how we can use spaCy to build and use our Named Entity Recognition model. Thank you so much for reading this article, I hope you enjoyed it as much as I did writing it!

Interested in more? Follow me on Twitter at @b_dmarius and I'll post there every new article.

Machine Learning Project Series: Building a Personal Knowledge Management System - Part 0 - Introduction and Purpose

Marius Borcan — Thu, 05 Mar 2020 18:50:02 +0000

This article was originally published at https://programmerbackpack.com.

Interested in more stories like this? Follow me on Twitter at @b_dmarius and I'll post there every new article.

Introduction and purpose - starting a new journey

If you're like me, you're passionate about Technology, Machine Learning and Programming in general and you feel that everyday there's something new to learn. You follow other blogs, you read articles and forums, you watch videos about people building cool stuff. And you want to build your own cool applications that you can share with the world.

If you're even more like me, you feel that the tech field is changing so much and so fast that trying to keep pace becomes overwhelming and at times rather discouraging. Everything looks cool, interesting and sufficiently difficult that your mind says: I wanna learn this too! I am talking back-end, front-end, Cloud, Machine Learning, Deep Learning, Data Science, you name it, you want to learn it all!

Finally, you remember you're a programmer, and the only good way you know for learning something is actually building something. And that is what I want to do now.

I am starting a journey of deepening my knowledge on Machine Learning, Deep Learning and NLP. And I know that reading thousands of articles without actually building something will only get me so far. So I am changing the way I look at the game.

The Project

I want to build a tool that will help me keep track of what I learn everyday. Not just a notes app, but something which will help me remember and retrieve the information I saved in a more efficient way. Something to help me make connections faster between a thing I learned today and that thing I learned 2 years ago that I almost forgot.

And equally important, a tool that is not standing in my way when I want to save a piece of information, but one that allows me to do that fast and in an efficient manner.

It will be something based on Machine Learning stuff for sure. I promised to myself not to overkill it and to introduce only useful features, that I will really enjoy. If it's solvable by ML, then it's a plus, because it also serves my purpose of learning. Otherwise, go with other methods because having features just for the sake of having them will not help me in any way.

Most important of all, I want to learn lots of new things while working on this. I will take every small lesson one at a time, apply it to my project and also share it on this blog, maybe someone else also needs it.

The Plan

While working on this tool I will most definitely learn new things that I'll find interesting and so I will post them here. If I can demo it by something implemented in the application, I'll sure do. If not, I'll find other useful and relevant examples, because, as I said earlier, we as programmers learn by doing.

Just like with my other articles, I'll also share code snippets on Github. All my progress will be documented here and on Twitter at @b_dmarius.

Questions still left open

What kind of app is it going to be?

As I said, I still don't have the full picture. I'll share it as soon as I have it. It might me a mobile app, or a browser extension, or a web app. Whichever I feel will serve me better. I started this project with the idea that this is built primarily for myself.

What technologies are you going to use?

I can just copy-paste the answer from above, but you have it right there! 😃

How often are you going to post?

This is not going to be a regular series. I'll post only whenever I feel like I have something new to show. But I'll post updates as often as possible.

Can I contribute?

Please let me know if you want to contribute to a project like this. If I find enough interest for this, I'll take it open source and we can all work together.

I think this is all for the moment. I'll come up with updates and new ideas as soon as I can. Thank you so much if you decide joining me on this journey. It will be a pleasure to share my progress!

Thank you so much for reading this article. Interested in more? Follow me on Twitter at @b_dmarius and I'll post there every new article.

How I Survived My First Two-Day Hackathon - What Is A Hackathon And How To Get The Most Out Of It

Marius Borcan — Sun, 01 Mar 2020 17:35:07 +0000

This article was originally published at
https://programmerbackpack.com

Interested in more stories like this? Follow me on Twitter at @b_dmarius and I'll post there every new article.

What is a hackathon

A hackathon is a special type of event in which teams of coders come together and spend a day or two on builing a prototype for a business case which is either given a few days before the hackathon or at the very start of the event. At the end of the event, teams pitch their ideas in front of a jury and show off a prototype. Winners usually get money prizes and some of them get investing or networking opportunities to help them transform the prototype into a business.

Last year I took part in a two-day hackathon event in Bucharest and it was one of the most exhausting experiences I ever had - only one hour of sleep in about 40 hours, with the rest of the time being spent on coding, learning, networking with other participants and pitching ideas. Nonetheless, it was maybe the most exciting event I ever attended because I learned lots of new stuff about coding, building a business and pitching an idea in front of investors.

My team(which consisted of me and two other friends) didn't win the hackathon, but we came very close to the top 3 prize winners and the manager of one of the most important banks in Romania offered us her business card and told us to contact her if we ever want to further develop our idea. I am very proud about what we achieved in only one weekend(those who won were already fully fledged businesses) and I want to share the top lessons I learned at this hackathon.

Choose a hackathon wisely - especially if it's your first one

Not all hackathons are cool to attend. Some companies organize hackathons only because they saw it's a trendy event or because their sole purpose is to recruit new people/new ideas. I am sure every experience has something new to offer you, but if this is your first time attending this type of events, then you might as well choose a good one.

Look at who's organising the event, who's in the jury and make sure the prize is a good one - to keep you motivated. If you have the chance to learn the theme before or at least the technologies involved, that's even better - make sure it's something interesting for you or a field in which you have experience. That will make the event even more useful for you and you will really enjoy participating.

Choose your team wisely

Most of the time during a hackathon will be spent with your team, so be sure you'll have a team you'll enjoy working with(at some hackathons you can participate alone, but I do not recommend it). Choose people you've worked with before - either at school, at work or at other hackathons - since you have only a few hours to build a product, you need to know everybody's strengths and weaknesses, no time to discover them now!

Equally important is that you choose people with various sets of skills - usually you'll need at least one back-end and one front-end developer and most of the times you'll also need someone with great ideas for the product and for the presentation.

Most important of all, choose someone you can count on. Time is very short during a hackathon, so you can't spend too much time on everything and you don't have time to take every decision. That's why you'll need people you trust and who can work in parallel.

Choose a good product idea

Most of the time at a hackathon should be spent on the idea - after all, that's what you're selling. And this does not mean only coming up with the idea, but also validating it with other people. Usually at hackathons you will have some mentors or people who represent the jury and/or the company who is organising the event. They'll come by your working area and ask you about your product. Explain your ideas and listen carefully to their feedback - it might be just what you need to win the hackathon.

As I said earlier, a hackathon is an event with lots of networking opportunities and this means also discussing with other teams. Without going too much into the details, you can tell other people your basic ideas and listen to theirs. You never know where inspiration will come from.

My team and I spent many hours on the idea. The event started at 8 am and no line of code had been written until 3 pm that day. And even though we were worried about this, it was still fine - we had the event, the night and the rest of the day for coding. But we wouldn't have had anything to code until we were sure the idea was the best we could come up with.

Build an awesome prototype

You know that saying - fake it 'till you make it - well that is not even remotely true at a hackathon. You can't fake everything, you need at least some working prototype to show off to the jury. Most of the people in the jury are not of technical nature, they are usually business people. They hear lots and lots of ideas every day so your stories about your idea becoming the best product on the market are not enough to convince them. You need some working, real code to prove the viability of your product and also prove that your team is the best at working on this product. Of course there will be lots of hardcoding and lots of errors hidden in the background and I am not even talking about your data structures which will be a mess, but at least build a little bit of your app so that the jury can understand and interact with.

Prepare your best pitch

Your work at a hackathon is not done until you present your idea in front of the jury - you'll need this to win the prize or at least to validate your effort. So make sure the presentation is at least on par with your project - ideally even better.

Gather data from whatever source you can find to validate your idea, present valid use cases, compare yourself to other competitors on the market and make estimations on costs and revenue. It's okay if you exaggerate a bit when making the presentation - the jury is used to it and is even expecting it. But don't lie too much to them, it will become embarassing for you and you team.

Most important of all, present you and your team. Let them know you and find what what are your backgrounds. They might find you interesting enough to offer other opportunities to you, even if your idea does not win the hackathon. Tell them your plans for the future of the app and treat your hackathon idea like a fully fledged startup.

Have fun and learn as much as you can!

All in all, a hackathon is a unique experience and and there's lots to learn from one. Keep your eyes open to every opportunity, meet as many new people as you can, listen to other ideas and share yours. It's a good, fun and constructive way to spend a weekend. Good luck to you!

Thank you so much for reading this article! Interested in more? Follow me on Twitter at @b_dmarius and I'll post there every new article.

Machine Learning Project: Neural Network Learns To Play Tic-Tac-Toe

Marius Borcan — Sun, 01 Mar 2020 09:10:49 +0000

This article was originally published at https://programmerbackpack.com.

A Machine Learning Project about building a Neural Network in Python with Keras and teaching it to play a game of Tic-Tac-Toe.

Motivation

In this article we are going to build a basic Neural Network that tries to learn the simple game of Tic-Tac-Toe. It is an already known fact that this is a solved game and using a Neural Network is a bit overkill, but with it being a simple game with an extremely small search space, it is a nice opportunity for us to play with a Neural Network without worrying too much about data gathering and cleanup.

All the code for this project is available on Github – I'll only post snippets here – so you can check it out there(if you do so, please don't forget to star the repository so I know you've enjoyed this project). Also, feel free to follow me on Twitter at @b_dmarius, I'll post there every new article.

Approach

We are going to build a simple tic-tac-toe game at the command line. I am not going to play the game myself, but I will let two computer players play it a few thousand times by choosing randomly from a list of available moves. We will record every move the players take and the eventual outcome of the game.

After the simulation, we are going to take the recorded data and feed it to a simple neural network and train our model. After training the model, we are going to let it play against the computer players, first as Player 1 and then as Player 2 and see the results.
The Game

For the Tic-Tac-Toe I've chosen a very basic implementation in Python. This part is not the most interesting in this project, so I'll explain the flow and list here the code. You can take it and tweak it as you wish for your project.

We are using a simple Game class to hold the information and process the flow of the game. A cell is marked with 0 if hasn't been chosen by any player, -1 for the Player with X and 1 for the Player with O. Each time, the game offers a list with all the available moves and players take turns choosing randomly from this list. The move is processed and the current state of the board is saved in the history we are going to use for the training. After the game ends(either it's a draw or one player wins), the game result is mapped to every state that the board had during the game. Here's the notations I've used:

PLAYER_X = 'X'
PLAYER_O = 'O'
EMPTY = ' '
PLAYER_X_VAL = -1
PLAYER_O_VAL = 1
EMPTY_VAL = 0
HORIZONTAL_SEPARATOR = ' | '
VERTICAL_SEPARATOR = '---------------'
GAME_STATE_X = -1
GAME_STATE_O = 1
GAME_STATE_DRAW = 0
GAME_STATE_NOT_ENDED = 2

Here's how the training history looks after the first move. This is the game where Player X won(since the -1 in the first item) and the first move in the game was made by Player X - line 3, column 2.

[(-1, [[0, 0, 0], [0, 0, 0], [0, -1, 0]])]

After a whole game the history would look like this:

[(-1, [[0, 0, 0], [0, 0, 0], [0, 1, 0]]), (-1, [[0, 0, 0], [0, -1, 0], [0, 1, 0]]), (-1, [[0, 0, 0], [1, -1, 0], [0, 1, 0]]), (-1, [[0, 0, -1], [1, -1, 0], [0, 1, 0]]), (-1, [[1, 0, -1], [1, -1, 0], [0, 1, 0]]), (-1, [[1, 0, -1], [1, -1, 0], [-1, 1, 0]]), (-1, [[1, 0, -1], [1, -1, 1], [-1, 1, 0]]), (-1, [[1, 0, -1], [1, -1, 1], [-1, 1, -1]]), (-1, [[1, 1, -1], [1, -1, 1], [-1, 1, -1]])]

Imaging how the training data looks after 10000 games! Luckly for us, we have numpy to help us. You'll see later how we are going to process all this data. Here's how we are simulating the game:

def simulate(self, playerToMove):
        while (self.getGameResult() == GAME_STATE_NOT_ENDED):
            availableMoves = self.getAvailableMoves()
            selectedMove = availableMoves[random.randrange(0, len(availableMoves))]
            self.move(selectedMove, playerToMove)
            if playerToMove == PLAYER_X_VAL:
                playerToMove = PLAYER_O_VAL
            else:
                playerToMove = PLAYER_X_VAL
        # Get the history and build the training set
        for historyItem in self.boardHistory:
            self.trainingHistory.append((self.getGameResult(), copy.deepcopy(historyItem)))

    def simulateManyGames(self, playerToMove, numberOfGames):
        playerXWins = 0
        playerOWins = 0
        draws = 0
        for i in range(numberOfGames):
            self.resetBoard()
            self.simulate(playerToMove)
            if i == 0:
                print(self.trainingHistory)
            if self.getGameResult() == PLAYER_X_VAL:
                playerXWins = playerXWins + 1
            elif self.getGameResult() == PLAYER_O_VAL:
                playerOWins = playerOWins + 1
            else: draws = draws + 1
        totalWins = playerXWins + playerOWins + draws
        print ('X Wins: ' + str(int(playerXWins * 100/totalWins)) + '%')
        print('O Wins: ' + str(int(playerOWins * 100 / totalWins)) + '%')
        print('Draws: ' + str(int(draws * 100 / totalWins)) + '%')

For evaluating the result of the game, we use a very basic method. Of course this could be optimized quite a lot, but this is not in scope for this article. Here's the code I used:

def getGameResult(self):
        for i in range(len(self.board)):
            for j in range(len(self.board[i])):
                if self.board[i][j] == EMPTY_VAL:
                    return GAME_STATE_NOT_ENDED

        # Rows
        for i in range(len(self.board)):
            candidate = self.board[i][0]
            for j in range(len(self.board[i])):
                if candidate != self.board[i][j]:
                    candidate = 0
            if candidate != 0:
                return candidate

        # Columns
        for i in range(len(self.board)):
            candidate = self.board[0][i]
            for j in range(len(self.board[i])):
                if candidate != self.board[j][i]:
                    candidate = 0
            if candidate != 0:
                return candidate

        # First diagonal
        candidate = self.board[0][0]
        for i in range(len(self.board)):
            if candidate != self.board[i][i]:
                candidate = 0
        if candidate != 0:
            return candidate

        # Second diagonal
        candidate = self.board[0][2]
        for i in range(len(self.board)):
            if candidate != self.board[i][len(self.board[i]) - i - 1]:
                candidate = 0
        if candidate != 0:
            return candidate

        return GAME_STATE_DRAW

Here are the results of the simulation after 10000 games. It seems that being the second player it's easier in a game of Tic-Tac-Toe and we'll see that also reflected in our Neural Network Simulation.

X Wins: 23%
O Wins: 64%
Draws: 11%

The Neural Network

We are going to build a neural network which will take as input a game board state(the value of each cell in the board: -1, 0, 1) and output the probabilities associated with each possible game result(X wins, O wins or it's a draw). From the output we choose the result with the highest probability as our game result. We will hope that the Neural Network will learn to predict a given board state to the correct eventual result.

So our network will have 9 inputs and 3 outputs. Between the input and the output layers we have 4 Dense layers. I've chosen the number of layers and their dimensions after experimenting with many different combinations. Feel free to try other combinations, I'm sure you'll get even better results! Here's the code to generate the model. You'll need tensorflow and keras installed for this.

def __init__(self, numberOfInputs, numberOfOutputs, epochs, batchSize):
        self.epochs = epochs
        self.batchSize = batchSize
        self.numberOfInputs = numberOfInputs
        self.numberOfOutputs = numberOfOutputs
        self.model = Sequential()
        self.model.add(Dense(64, activation='relu', input_shape=(numberOfInputs, )))
        self.model.add(Dense(128, activation='relu'))
        self.model.add(Dense(128, activation='relu'))
        self.model.add(Dense(128, activation='relu'))
        self.model.add(Dense(numberOfOutputs, activation='softmax'))
        self.model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy'])

Training the model

We'll take the board states and the eventual results and feed them as inputs and outputs to the neural network. We'll split the dataset in 80% training set and 20% evaluation set. The math behind a neural network is well beyond the scope of this article, but let me know if you want me to write an article about this too, I'll gladly do it!

We'll then use the data to train the neural network for 100 epochs in batches of 32. These numbers are also results of experimentation so you can always try new combinations.

 def train(self, dataset):
        input = []
        output = []
        for data in dataset:
            input.append(data[1])
            output.append(data[0])

        X = np.array(input).reshape((-1, self.numberOfInputs))
        y = to_categorical(output, num_classes=3)
        # Train and test data split
        boundary = int(0.8 * len(X))
        X_train = X[:boundary]
        X_test = X[boundary:]
        y_train = y[:boundary]
        y_test = y[boundary:]
        self.model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=self.epochs, batch_size=self.batchSize)

Predicting the best move

Predicting the best move at a given moment in the game is quite simple. The game already offers us the list with all the possible moves and so we can take every possible move, project it on the board and feed the board state through the neural network and note the result that we are interested in(for example if the Neural Network is Player X, we note the probability that Player X wins).

After all the possible moves have been processed by the network, we choose the one with the highest score and keep it as our next move.

 def predict(self, data, index):
        return self.model.predict(np.array(data).reshape(-1, self.numberOfInputs))[0][index]

And here's the code for simulating the games with the Neural Network as one player and then the other.

def simulateNeuralNetwork(self, nnPlayer, model):
        playerToMove = PLAYER_X_VAL
        while (self.getGameResult() == GAME_STATE_NOT_ENDED):
            availableMoves = self.getAvailableMoves()
            if playerToMove == nnPlayer:
                maxValue = 0
                bestMove = availableMoves[0]
                for availableMove in availableMoves:
                    # get a copy of a board
                    boardCopy = copy.deepcopy(self.board)
                    boardCopy[availableMove[0]][availableMove[1]] = nnPlayer
                    if nnPlayer == PLAYER_X_VAL:
                        value = model.predict(boardCopy, 0)
                    else:
                        value = model.predict(boardCopy, 2)
                    if value > maxValue:
                        maxValue = value
                        bestMove = availableMove
                selectedMove = bestMove
            else:
                selectedMove = availableMoves[random.randrange(0, len(availableMoves))]
            self.move(selectedMove, playerToMove)
            if playerToMove == PLAYER_X_VAL:
                playerToMove = PLAYER_O_VAL
            else:
                playerToMove = PLAYER_X_VAL

    def simulateManyNeuralNetworkGames(self, nnPlayer, numberOfGames, model):
        nnPlayerWins = 0
        randomPlayerWins = 0
        draws = 0
        print ("NN player")
        print (nnPlayer)
        for i in range(numberOfGames):
            self.resetBoard()
            self.simulateNeuralNetwork(nnPlayer, model)
            if self.getGameResult() == nnPlayer:
                nnPlayerWins = nnPlayerWins + 1
            elif self.getGameResult() == GAME_STATE_DRAW:
                draws = draws + 1
            else: randomPlayerWins = randomPlayerWins + 1
        totalWins = nnPlayerWins + randomPlayerWins + draws
        print ('X Wins: ' + str(int(nnPlayerWins * 100/totalWins)) + '%')
        print('O Wins: ' + str(int(randomPlayerWins * 100 / totalWins)) + '%')
        print('Draws: ' + str(int(draws * 100 / totalWins)) + '%')

And here are the results of the simulation for our Neural Network games(10000 games each).

Simulating with Neural Network as X Player:
NN player
-1
X Wins: 57%
O Wins: 1%
Draws: 40%

Simulating with Neural Network as O Player:
NN player
1
X Wins: 3%
O Wins: 89%
Draws: 6%

And the results look very good to me!! In both games the Neural Network won a lot more games than the other player. For the first case, even if the Neural Network won only 57% of the games, the other player won only 1% and the rest were draws, which still is a very good result. For the second games the result was even better, as the NN Player won an astounding 89% of the games, with the other player winning only 3%. So in both cases the opponent stood no chance!

Conclusions

In this article we tried a simple approach for building a Neural Network that tries to play Tic-Tac-Toe. We only used a basic model and still got some decent results. If you'd like to obtain even better results, I recommend trying a more complex model and more training data. Also, another good approach will be to use Reinforcement Learning, but that is for another article. The entire code for the project can be found on Github. Feel free to star the project if you enjoyed working with it. Thanks for reading!

Interested in more? Follow me on Twitter at @b_dmarius and I'll post there every new article.