34,79 €
Mehr erfahren.
- Herausgeber: Packt Publishing
- Kategorie: Fachliteratur
- Sprache: Englisch
Go is the perfect language for machine learning; it helps to clearly describe complex algorithms, and also helps developers to understand how to run efficient optimized code. This book will teach you how to implement machine learning in Go to make programs that are easy to deploy and code that is not only easy to understand and debug, but also to have its performance measured.
The book begins by guiding you through setting up your machine learning environment with Go libraries and capabilities. You will then plunge into regression analysis of a real-life house pricing dataset and build a classification model in Go to classify emails as spam or ham. Using Gonum, Gorgonia, and STL, you will explore time series analysis along with decomposition and clean up your personal Twitter timeline by clustering tweets. In addition to this, you will learn how to recognize handwriting using neural networks and convolutional neural networks. Lastly, you'll learn how to choose the most appropriate machine learning algorithms to use for your projects with the help of a facial detection project.
By the end of this book, you will have developed a solid machine learning mindset, a strong hold on the powerful Go toolkit, and a sound understanding of the practical implementations of machine learning algorithms in real-world projects.
Das E-Book können Sie in Legimi-Apps oder einer beliebigen App lesen, die das folgende Format unterstützen:
Seitenzahl: 396
Veröffentlichungsjahr: 2018
Ähnliche
Go Machine Learning Projects
Copyright © 2018 Packt Publishing
All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.
Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing or its dealers and distributors, will be held liable for any damages caused or alleged to have been caused directly or indirectly by this book.
Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.
Commissioning Editor: Pravin DhandreAcquisition Editor: Nelson MorrisContent Development Editor: Snehal KolteTechnical Editor: Dharmendra YadavCopy Editor: Safis EditingProject Coordinator: Manthan PatelProofreader: Safis EditingIndexer: Tejal Daruwale SoniGraphics: Jisha ChirayilProduction Coordinator: Deepika Naik
First published: November 2018
Production reference: 1301118
Published by Packt Publishing Ltd. Livery Place 35 Livery Street Birmingham B3 2PB, UK.
ISBN 978-1-78899-340-1
www.packtpub.com
Mapt is an online digital library that gives you full access to over 5,000 books and videos, as well as industry leading tools to help you plan your personal development and advance your career. For more information, please visit our website.
Why subscribe?
Spend less time learning and more time coding with practical eBooks and Videos from over 4,000 industry professionals
Improve your learning with Skill Plans built especially for you
Get a free eBook or video every month
Mapt is fully searchable
Copy and paste, print, and bookmark content
Packt.com
Did you know that Packt offers eBook versions of every book published, with PDF and ePub files available? You can upgrade to the eBook version at www.packt.com and as a print book customer, you are entitled to a discount on the eBook copy. Get in touch with us at [email protected] for more details.
At www.packt.com, you can also read a collection of free technical articles, sign up for a range of free newsletters, and receive exclusive discounts and offers on Packt books and eBooks.
Contributors
About the author
Xuanyi Chew is the Chief Data Scientist of a Sydney-based logistics startup. He is the primary author of Gorgonia, an open source deep learning package for Go. He's been practicing machine learning for the past 12 years, applying them typically to help startups. His goal in life is to make an artificial general intelligence a reality. He enjoys learning new things.
About the reviewer
Dr. Janani Selvaraj works as a senior research and analytics consultant for a start-up in Trichy, Tamil Nadu. She is a mathematics graduate with an interdisciplinary Ph.D in environmental management. Her research interests include mathematical and statistical modeling, spatial modeling, and environmental epidemiology. She currently trains students in data science and works as a consultant on several data-driven projects in a variety of domains. She is an R programming expert and founder of the R-Ladies Trichy group, a group that promotes gender diversity.
Packt is searching for authors like you
If you're interested in becoming an author for Packt, please visit authors.packtpub.com and apply today. We have worked with thousands of developers and tech professionals, just like you, to help them share their insight with the global tech community. You can make a general application, apply for a specific hot topic that we are recruiting an author for, or submit your own idea.
Table of Contents
Title Page
Copyright and Credits
Go Machine Learning Projects
About Packt
Why subscribe?
Packt.com
Contributors
About the author
About the reviewer
Packt is searching for authors like you
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Conventions used
Get in touch
Reviews
How to Solve All Machine Learning Problems
What is a problem?
What is an algorithm?
What is machine learning?
Do you need machine learning?
The general problem solving process
What is a model?
What is a good model?
On writing and chapter organization
Why Go?
Quick start
Functions
Variables
Values
Types
Methods
Interfaces
Packages and imports
Let's Go!
Linear Regression - House Price Prediction
The project
Exploratory data analysis
Ingestion and indexing
Janitorial work
Encoding categorical data
Handling bad numbers
Final requirement
Writing the code
Further exploratory work
The conditional expectation functions
Skews
Multicollinearity
Standardization
Linear regression
The regression
Cross-validation
Running the regression
Discussion and further work
Summary
Classification - Spam Email Detection
The project
Exploratory data analysis
Tokenization
Normalizing and lemmatizing
Stopwords
Ingesting the data
Handling errors
The classifier
Naive Bayes
TF-IDF
Conditional probability
Features
Bayes' theorem
Implementating the classifier
Class
Alternative class design
Classifier part II
Putting it all together
Summary
Decomposing CO2 Trends Using Time Series Analysis
Exploratory data analysis
Downloading from non-HTTP sources
Handling non-standard data
Dealing with decimal dates
Plotting
Styling
Decomposition
STL
LOESS
The algorithm
Using STL
How to lie with statistics
More plotting
A primer on Gonum plots
The residuals plotter
Combining plots
Forecasting
Holt-Winters
Summary
References
Clean Up Your Personal Twitter Timeline by Clustering Tweets
The project
K-means
DBSCAN
Data acquisition
Exploratory data analysis
Data massage
The processor
Preprocessing a single word
Normalizing a string
Preprocessing stopwords
Preprocessing Twitter entities
Processing a single tweet
Clustering
Clustering with K-means
Clustering with DBSCAN
Clustering with DMMClust
Real data
The program
Tweaking the program
Tweaking distances
Tweaking the preprocessing step
Summary
Neural Networks - MNIST Handwriting Recognition
A neural network
Emulating a neural network
Linear algebra 101
Exploring activation functions
Learning
The project
Gorgonia
Getting the data
Acceptable format
From images to a matrix
What is a tensor?
From labels to one-hot vectors
Visualization
Preprocessing
Building a neural network
Feed forward
Handling errors with maybe
Explaining the feed forward function
Costs
Backpropagation
Training the neural network
Cross-validation
Summary
Convolutional Neural Networks - MNIST Handwriting Recognition
Everything you know about neurons is wrong
Neural networks – a redux
Gorgonia
Why?
Programming
What is a tensor? – part 2
All expressions are graphs
Describing a neural network
One-hot vector
The project
Getting the data
Other things from the previous chapter
CNNs
What are convolutions?
How Instagram filters work
Back to neural networks
Max-pooling
Dropout
Describing a CNN
Backpropagation
Running the neural network
Testing
Accuracy
Summary
Basic Facial Detection
What is a face?
Viola-Jones
PICO
A note on learning
GoCV
API
Pigo
Face detection program
Grabbing an image from the webcam
Displaying the image
Doodling on images
Face detection 1
Face detection 2
Putting it all together
Evaluating algorithms
Summary
Hot Dog or Not Hot Dog - Using External Services
MachineBox
What is MachineBox?
Signing in and up
Docker installation and setting up
Using MachineBox in Go
The project
Training
Reading from the Webcam
Prettifying the results
The results
What does this all mean?
Why MachineBox?
Summary
What's Next?
What should the reader focus on?
The practitioner
The researcher
The researcher, the practitioner, and their stakeholder
What did this book not cover?
Where can I learn more?
Thank you
Other Books You May Enjoy
Leave a review - let other readers know what you think
Preface
Go is the perfect language for machine learning. Its simple syntax helps to clearly describe complex algorithms, but does not obscure developers from understand how to run efficient optimized code. This book will teach you how to implement machine learning in Go to make programs that are easy to deploy and code that is not only easy to understand and debug, but that can also have its performance measured.
The book begins by guiding you in setting up your machine learning environment with Go libraries and capabilities. You will then plunge into regression analysis of a real-life house pricing dataset and build a classification model in Go to classify emails as spam or ham. Using Gonum, Gorgonia, and STL, you will explore time series analysis, along with decomposition and how to clean up your personal Twitter timeline by clustering tweets. In addition to this, you will learn how to recognize handwriting using neural networks and convolutional neural networks, both of which are deep learning techniques. Once you've covered all the techniques, you'll learn how to choose the most appropriate machine learning algorithms to use for your projects with the help of a facial detection project.
By the end of this book, you will have developed a solid machine learning mindset, a strong hold on the powerful Go libraries, and a sound understanding of the practical implementations of machine learning algorithms in real-world projects.
Who this book is for
If you're a machine learning engineer, data science professional, or Go programmer who wants to implement machine learning in your real-world projects and make smarter applications more easily, this book is for you.
What this book covers
Chapter 1, How To Solve All Machine Learning Problems, introduces two classes of machine learning: regression and classification. By the end of this chapter, you should feel comfortable with the data structures used to build machine learning programs. Most machine learning algorithms are built based on the data structures introduced here. We are then going to introduce Go machine learning and get you up and running for further projects.
Chapter 2, Linear Regression – House Price Prediction, goes into a regression analysis on a real-life dataset on house pricing. We will start off by building the necessary data structures to perform such analyses, along with initial exploration of the dataset.
Chapter 3, Classification – Spam Email Detection, covers the construction of a classification model in Go. The dataset is the classic spam and ham email dataset in which our goal is to build a model that classifies the emails as spam or ham. Then, we will learn how to write the algorithms themselves, while leveraging external libraries (such as Gonum) for data structure support.
Chapter 4, Decomposing CO2 Trends Using Time Series Analysis, introduces us to the subtleties of time series analysis. Data in time series can often be decomposed for descriptive purposes. This chapter shows us how to perform such decompositions, and how to display them using Gonum's plotting tools as well as gnuplot.
Chapter 5, Clean Up Your Personal Twitter Timeline by Clustering Tweets, covers the clustering of tweets on Twitter. We will be using two different clustering techniques, K-Means and DBSCAN. For this chapter, we're going to rely on a number of skills we built up inChapter 2, Linear Regression – House Price Prediction. We will also be using the same libraries used in the aforementioned chaper. On top of that, we will also be using the clusters library by Marcin Praski
Chapter 6, Neural Networks – MNIST Handwriting Recognition,opens up the rich world of image recognition to us. Images are difficult, because useful features are nonlinear products of the input features. The aim of this project is to introduce the various methods of handling high-dimensional data; specifically, the use of PCA algorithms in the Gonum library to whiten data.
Chapter 7, Convolutional Neural Networks – MNIST Handwriting Recognition, explains how to use recent advancements in deep learning to perform handwriting recognition, by building a convolutional neural network using Gorgonia tp achieve 99.87% accuracy.
Chapter 8, Basic Facial Detection,explores a basic implementation of facial detection. By the end of this chapter, we will have implemented a usable facial detection system using GoCV and PIGO. This chapter teaches an important lesson in learning to choose the correct algorithm for the job.
Chapter 9, Hot Dog or Not Hot Dog - Using External Servicesculminates the book by showing how one may integrate external services in machine learning projects, and what to look out for when doing so.
Chapter 10, What Is Next, lists the further avenues for machine learning in Go.
To get the most out of this book
Some coding experience in Golang and knowledge of basic machine learning concepts will aid you in understanding the concepts covered in this book.
Download the example code files
You can download the example code files for this book from your account at www.packt.com. If you purchased this book elsewhere, you can visit www.packt.com/support and register to have the files emailed directly to you.
You can download the code files by following these steps:
Log in or register at
www.packt.com
.
Select the
SUPPORT
tab.
Click on
Code Downloads & Errata
.
Enter the name of the book in the
Search
box and follow the onscreen instructions.
Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:
WinRAR/7-Zip for Windows
Zipeg/iZip/UnRarX for Mac
7-Zip/PeaZip for Linux
The code bundle for the book is also hosted on GitHub athttps://github.com/PacktPublishing/Go-Machine-Learning-Projects. In case there's an update to the code, it will be updated on the existing GitHub repository.
We also have other code bundles from our rich catalog of books and videos available athttps://github.com/PacktPublishing/. Check them out!
Conventions used
There are a number of text conventions used throughout this book.
CodeInText: Indicates code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles. Here is an example: "We sketched out a dummy Classifier type that does nothing."
A block of code is set as follows:
Word: she - trueWord: shan't - falseWord: be - falseWord: learning - trueWord: excessively. - true
Any command-line input or output is written as follows:
go get -u github.com/go-nlp/tfidf
Bold: Indicates a new term, an important word, or words that you see on screen. For example, words in menus or dialog boxes appear in the text like this. Here is an example: "Select System info from the Administration panel."
Get in touch
Feedback from our readers is always welcome.
General feedback: If you have questions about any aspect of this book, mention the book title in the subject of your message and email us at [email protected].
Errata: Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you have found a mistake in this book, we would be grateful if you would report this to us. Please visit www.packt.com/submit-errata, selecting your book, clicking on the Errata Submission Form link, and entering the details.
Piracy: If you come across any illegal copies of our works in any form on the internet, we would be grateful if you would provide us with the location address or website name. Please contact us at [email protected] with a link to the material.
If you are interested in becoming an author: If there is a topic that you have expertise in, and you are interested in either writing or contributing to a book, please visit authors.packtpub.com.
Reviews
Please leave a review. Once you have read and used this book, why not leave a review on the site that you purchased it from? Potential readers can then see and use your unbiased opinion to make purchase decisions, we at Packt can understand what you think about our products, and our authors can see your feedback on their book. Thank you!
For more information about Packt, please visit packt.com.
How to Solve All Machine Learning Problems
Welcome to the book Go Machine Learning Projects. This is a rather odd book. It's not a book about how machine learning (ML) works. In fact, originally it was decided that we will assume that the readers are familiar with the machine learning (ML) algorithms I am to introduce in these chapters. Doing so would yield a rather empty book, I feared. If the reader knows the ML algorithm, what happens next is to simply apply the ML algorithm in the correct context of the problem! The ten or so chapters in this book would be completed in under 30 pages—anyone who's written a grant report for government agencies would have experience writing such things.
So what is this book going to be about?
It's going to be about applying ML algorithms within a specific, given context of the problem. These problems are concrete, and are specified by me on a whim. But in order to explore the avenues of the application of ML algorithms to problems, the reader must first be familiar with algorithms and the problems! So, this book has to strike a very delicate balance between understanding the problem, and understanding the specific algorithm used to solve the problem.
But before we go too far, what is a problem? And what do I mean when I say algorithm? And what's with this machine learning business?
What is a problem?
In colloquial use, a problem is something to be overcome. When people say they have money problems, the problem may be overcome simply by having more money. When someone has a mathematical problem, the problem may be overcome by mathematics. The thing or process used to overcome a problem is called a solution.
At this point, it may seem a little strange for me to define what is a common word. Ah, but precision and clarity of mind are required in order to solve problems with ML. You have to be precise about what exactly you are trying to solve.
Problems can be broken down into subproblems. But at some point, it no longer makes sense to break down those problems any further. I put it to the reader that there are different types of problems out there. So numerous are the types of problems that it is not worthwhile enumerating them all. Nonetheless, the urgency of a problem should be considered.
If you're building a photo organization tool (perhaps you are planning to rival Google Photos or Facebook), then recognizing faces in a photo is less urgent than knowing where to store, and how to retrieve a photo. If you do not know how to solve the latter, all the knowledge in the world to solve the former would be wasted.
I argue that urgency, despite its subjectivity, is a good metric to use when considering subproblems of the larger problem. To use a set of more concrete examples, consider three scenarios that all require some sort of ML solutions, but the solutions required are of different urgency. These examples are clearly made up examples, and have little or no bearing on real life. Their entire purpose is to make a point.
First, consider a real estate intelligence business. The entire survival of the business depends on being able to correctly predict the prices of houses to be sold, although perhaps they also make their money on some form of second market. To them, the ML problem faced is urgent. They would have to fully understand the ins and outs of the solution, otherwise they risk going out of business. In the view of the popular urgency/importance split, the ML problem can also be considered important and urgent.
Second, consider an online supermarket. They would like to know which groupings of products sell best together so they can bundle them to appear more competitive. This is not the core business activity, hence the ML problem faced is less urgent than the previous example. Some knowledge about how the solution works would be necessary. Imagine their algorithm says that they should bundle diarrhea medication with their home brand food products. They'd need to be able to understand how the solution came to that.
Lastly, consider the aforementioned photo application. Facial recognition is a nice bonus feature, but not the main feature. Therefore, the ML problem is least urgent amongst the three.
Different urgencies lead to different requirements when it comes to solving the problems.
What is an algorithm?
The previous section has been pretty diligent in the use of the term algorithm. Throughout this book, the term is liberally sprinkled, but is always used judiciously. But what is an algorithm?
To answer that, well, we must first ask, what is a program? A program is a series of steps to be performed by the computer. An algorithm is a set of rules that will solve the problem. A ML algorithm is hence a set of rules to solve a problem. They are implemented as a program on a computer.
One of the most eye-opening moments in truly and deeply understanding what exactly an algorithm is for me was an experience I had about 15 years ago. I was staying over at a friend's place. My friend had a seven year old child, and the friend was exasperated at trying to get her child to learn programming as her child had been too stubborn to learn the discipline of syntax. The root cause, I surmised, was that the child had not understood the idea of an algorithm. So the following morning, we tasked the child to make his own breakfast. Except he wasn't to make his own breakfast. He was to write down a series of steps that his mother was to follow to the letter.
The breakfast was simple—a bowl of cornflakes in milk. Nonetheless, it took the child some eleven attempts to get a bowl of cereal. It ended in tears and plenty of milk and cereal on the countertop, but it was a lesson well learned for the child.
This may seem like wanton child abuse. but it served me well too. In particular, the child said to his mother and me, in paraphrase, But you already know how to make cereal; why do you need instructions to do so? His mum responded, think of this as teaching me how to to make computer games. Here we have a meta notion of an algorithm. The child giving instructions on how to make cereal is teaching the child how to program; is itself an algorithm!
A ML algorithm can refer to the algorithm that is learned, or the algorithm that teaches the machine to use the correct algorithm. For the most part of this book, we shall refer to the latter, but it's quite useful to think of the former as well, if only as a mental exercise of sorts. For the most parts since Turing, we can substitute algorithm with machine.
Take some time to go through these sentences after reading the following section. It will help in clarifying what I mean upon a second read.
What is machine learning?
So what then is ML? As the word may hint, it's the ML to do something. Machines cannot learn the same way as humans can, but they can definitely emulate some parts of human learning. But what are they supposed to learn? Different algorithms learn different things, but the shared themes are that the machines learn a program. Or to put in less specific terms, the machine learns to do the correct thing.
What then is the correct thing? Not wanting to open a philosophical can of worms, the correct thing is what we, as human programmers of the computer, define as the correct thing.
There are multiple classification schemes of ML systems, but amongst the most common classification schemes, is one that splits ML into two types: supervised learning and unsupervised learning. Throughout this book we will see examples of both, but it's my opinion that such forms of classification are squarely in the good to know but not operationally important area of the brain. I say so because outside of a few well-known algorithms, unsupervised learning is still very much under active research. Supervised learning algorithms are too, but have been used in industry for longer than the unsupervised algorithms. That is not to say that unsupervised learning is not of value—a few have escaped the ivory towers of academia and have proven to be quite useful. We shall explore K-means and k-Nearest Neighbors (KNN) in one of the chapters.
Let's suppose for now we have a machine learning algorithm. The algorithm is a black box - we don't know what goes on inside. We feed it some data. And through its internal mechanisms, it produces an output. The output may not be correct. So it checks for whether the output is correct or not. If the output is not correct, it changes its internal mechanism, and tries again and again until the output is correct. This is how machine learning algorithms work in general. This is called training.
There are notions of what "correct" means of course. In supervised learning situations, we, the humans provide the machine with examples of correct data. In unsupervised learning situations, the notion of correctness relies on other metrics like distances between values. Each algorithm has its own specifics, but in general machine learning algorithms are as described.
Do you need machine learning?
Perhaps the most surprising question to ask, is whether you need machine learning to solve your problem. There is after all, a good reason why this section is the fourth in the chapter—we must understand what exactly is a problem is; and understand what an algorithm is before we can raise the question: do you need machine learning?
The first question to ask is of course: do you have a problem you need to solve? I assume the answer is yes, because we live in the world and are part of the world. Even ascetics have problems they need solved. But perhaps the question should be more specific: do you have a problem that can be solved with machine learning?
I've consulted a fair bit, and in my early days of consulting, I'd eagerly say yes to most enquiries. Ah, the things one does when one is young and inexperienced. The problems would often show up after I said yes. It turns out many of these consulting enquiries would be better served by having a more thorough understanding of the business domain and a more thorough understanding of computer science in general.
A common variant of a problem that is brought to me often requires information retrieval solutions, not machine learning solutions. Consider the following request I received several years ago:
Naturally, this piqued my interest—relationship extraction is a particularly challenging task in machine learning. I was young, and ever so eager to get my hands on tough problems. So I sat down with the company, and we worked out what was needed based on surface information. I suggested several models, all of which were greeted with enthusiasm. We finally settled on an SVM-based model. Then I got to work.
The first step in any machine learning project is to collect data. So I did. Much to my surprise, the data was already neatly classified, and entities already identified. Further, the entities have a static, unchanging relationship. One type of entity would have a permanent relationship with another type of entity. What was the machine learning problem?
I brought this up after one and a half month's worth of data gathering. What was going on? We have clean data, we have clean relationships. All new data had clean relationships. Where is the need for machine learning?
It later emerged that the data came from manual data input, which was at the time required by law. The entity relationships were defined fairly strictly. The only data requirement they really needed was a cleaned up database entity-relationship diagram. Because their database structure was so convoluted, they could not really see that all they needed to do was to define a foreign-key relationship to enforce the relationship. When I had requested the data, the data had came from individual SQL queries. There was no need for machine learning!
To their DBA's credit, that was what their DBA had been saying all along.
This taught me a lesson: Always find out if someone really needs machine learning solutions before spending time working on it.
I've since settled on a very easy way of determining if someone needs machine learning. These are my rules of thumb
Can the problem in this form: "Given X, I want to predict Y"
A what-question is generally suspect. A what question looks like this: "I want to know what is our conversion rate for XYZ product"
The general problem solving process
Only if the general rules of thumbs are fulfilled then will I engage to further. The general problem solving process goes as follows for me:
Identify clearly the problems.
Translate the problems into a more concrete statement.
Gather data
Perform exploratory data analysis
Determine the correct machine learning solution to use
Build a model.
Train the model.
Test the model.
Throughout the chapters in this book, the pattern above will be followed. The exploratory data analysis sections will be only done for the first few chapters. It's implicit that those would have been done in the later chapters.
I have attempted to be clear in the section headings on what exactly are we trying to solve, but writing is a difficult task, so I may miss some.
What is a model?
Model train are a fairly common hobby, despite being lampooned by the likes of The Big Bang Theory. A model train is not a real train. For one, the sizes are different. Model trains do not work exactly the same way a real train does. There are gradations of model trains, each being more similar to actual trains than the previous.
A model is in that sense a representation of reality. What do we represent it with? By and large, numbers. A model is a bunch of numbers that describes reality, and a bit more.
Every time I try to explain what a model is I inevitably get responses along the lines of "You can't just reduce us to a bunch of numbers!". So what do I mean "numbers"?
Consider the following right angle triangle:
How do we describe all right angle triangles? We might say something like this:
This says that the sum of all angles in a right angle adds up to 180 degrees, and there exists an angle that is 90 degrees. This is sufficient to describe all right angle triangles in Cartesian space.
But is the description the triangle itself? It is not. This issue has plagued philosophers ever since the days of Aristotle. We shall not enter into a philosophical discussion for such a discussion will only serve to prolong the agony of this chapter.
So for our purposes in this chapter, we'll say that a model is the values that describe reality, and the algorithm that produces those values. These values are typically numbers, though they may be of other types as well.
What is a good model?
A model is a bunch of values that describe the world, alongside the program that produces these values. That much, we have concluded from the previous section. Now we have to pass some value judgments on models - whether a model is good or bad.
A good model needs to describe the world accurately. This is said in the most generic way possible. Described thus, this statement about a good model encompasses many notions. We shall have to make this abstract idea a bit more concrete to proceed.
A machine learning algorithm is trained on a bunch of data. To the machine, this bunch of data is the world. But to us, the data that we feed the machine in for training is not the world. To us humans, there is much more to the world than what the machine may know about. So when I say "a good model needs to describe the world accurately", there are two senses to the word "world" that applies - the world as the machine knows, and the world as we know it.
The machine has only seen portions of the world as we know it. There are parts of the world the machine has not seen. So it is then a good machine learning model when it is able to provide the correct outputs for inputs it has not seen yet.
As a concrete example, let's once again suppose that we have a machine learning algorithm that determines if an image is that of a hot dog or not. We feed the model images of hot dogs and hamburgers. To the machine, the world are simply images of hot dogs and hamburgers. What happens when we pass in as input, an image of vegetables? A good model would be able to generalize and say it's not a hot dog. A poor model would simply crash.
And thus with this analogy, we have defined a good model to be one that generalizes well to unknown situations.
Often, as part of the process of building machine learning systems, we would want to put this notion to test. So we would have to split our dataset into testing and training datasets. The machine would be trained on the training dataset, and to test how good the model is once the training has completed, we will then feed in the testing dataset to the machine. It's assumed of course that the machine has never seen the testing dataset. A good machine learning model hence would be able to generate the correct output for the testing dataset, despite never having seen it.
On writing and chapter organization
A note on the writing in this book. As you may already have guessed, I have decided to settle upon a more conversational tone. I find this tone to be friendlier to the reader who may be intimidated by machine algorithms. I am also, if you have not yet noticed, quite opinionated in my writing. I strive to make clear, through my writing, what is and what ought to be. Application of Hume's fork is at the discretion at the reader. But as a quick guide, when talking about algorithms and how they work, they are is statements. When talking about what should be done, and organization of code, they are ought statements.
There are two general patterns in the design of the chapters of this book. First, the problems get harder as the chapters go on. Second, one may optionally want to mentally divide the chapters into three different parts. Part 1—Chapters 2, Linear Regression - House Price Prediction, Chapter 3, Classification - Spam Email Detection, Chapter 4, Decomposing CO2 Trends Using Time Series Analysis, Chapter 7, Convolutional Neural Networks - MNIST Handwriting Recognition, Chapter 8, Basic Facial Detection) correspond to readers who have an urgent ML problem. Part 2—Chapters 5, Clean Up Your Personal Twitter Timeline by Clustering Tweets, Chapter 9, Hot Dog or Not Hot Dog - Using External Services, Chapter 6, Neural Networks; MNIST Handwriting Recognition, Chapter 7, Convolutional Neural Networks - MNIST Handwriting Recognition, Chapter 8, Basic Facial Detection) are for those who have ML problems akin to the second example. Part 3, the last two chapters, are for people whose machine learning problems are not as urgent, but still require a solution.
Up to Chapter 8, Basic Facial Detection, for each chapter there will typically be one or two sections dedicated to the explanation of the algorithm itself. I strongly believe that one cannot write any meaningful program without at least a basic understanding of the algorithms they are using. Sure, you may use an algorithm that has been provided by someone else, but, without a proper understanding, it's meaningless. Sometimes meaningless programs may produce results, just as sometimes an elephant may appear to know how to do arithmetic, or a pet dog may appear to do a sophisticated feat, like speak.
This also means that I may sound rather dismissive of some ideas. For example, I am dismissive of using ML algorithms to predict stock prices. I do not believe that doing so will be a productive endeavor, because of an understanding of the basic processes that generate prices in a stock market, and the confounding effects of time.
Time, however, will tell if I am right or wrong. It may well be that one day someone will invent a ML algorithm that will work perfectly well on dynamical systems, but not right now, right here. We are at the dawn of a new era of computation, and we must strive to understand things as best as we can. Often you can learn quite a bit from history. Therefore, I also strive to insert important historical anecdotes on how certain things came to be. These are by no means a comprehensive survey. In fact, it is done without much regularity. However, I do rather hope that it adds to the flavor of the book.
Why Go?
This book is a book on ML using Go. Go is a rather opinionated programming language. There's the Go way, or no other way at all. This may sound rather fascist, but it has resulted in a very enjoyable programming experience. It also makes working in teams rather efficient.
Further, Go is a fairly efficient language when compared to Python. I have moved on almost exclusively to using Go to do my ML and data science work.
Go also has the benefit of working well cross-platform. At work, developers may choose to work on different operating systems. Go works well across all of them. The programs that are written in Go can be trivially cross-compiled for other platforms. This makes deployment a lot easier. There's no unnecessary mucking around with Docker or Kubernetes.
Are there drawbacks when using Go for ML? Only as a library author. In general, using Go ML libraries is painless. But in order for it to be painless, you must let go of any previous ways you programmed.
Quick start
First install Go, which can be found at https://golang.org. It provides comprehensive guides to Go. And now, quick start.
Functions
Functions are the main way that anything is computed in Go.
This is a function:
func addInt(a, b int) int { return a + b }
We call func addInt(a, b int) int, which is the function signature. The function signature is composed of the function name, parameters, and return type(s).
The name of the function is addInt. Note the formatting being used. The function name is in camelCase—this is the preferred casing of names in Go. The first letter of any name, when capitalized, like AddInt indicates that it should be exported. By and large in this book we shan't worry about exported or unexported names, as we will be mostly using functions. But if you are writing a package, then it matters. Exported names are available from outside a package.
Next, note that a and b are parameters, and both have the type int. We'll discuss types in a bit, but the same function can also be written as:
func addInt(a int, b int) int { return a + b }
Following that, this is what the function returns. This function addInt returns an int. This means when a function is called correctly, like so:
z := addInt(1, 2)
z will have a type int.
After the return type is defined, {...} denotes the body. When {...} is written in this book, it means the content of the function body is not as important for the discussion at hand. Some parts of the book may have snippets of function bodies, but without the signature func foo(...). Again those snippets are the snippets under discussion. It's expected that the reader will piece together the function from context in the book.
A Go function may return multiple results. The function signature looks something like this:
func divUint(a, b uint) (uint, error) { ... } func divUint(a, b uint) (retVal uint, err error) { ... }
Again, the difference is mainly in naming the return values. In the second example, the return values are named retVal and err respectively. retVal is of type uint and err is of type error.
