Building a single layer neural network
by Alberto Boschetti, Luca Massaron, Bastiaan Sjardin, John Hearty, Prateek Joshi
Python: Real World Machine Learning
- Python: Real World Machine Learning
- Table of Contents
- Python: Real World Machine Learning
- Python: Real World Machine Learning
- Credits
- Preface
- I. Module 1
- 1. The Realm of Supervised Learning
- Introduction
- Preprocessing data using different techniques
- Label encoding
- Building a linear regressor
- Computing regression accuracy
- Achieving model persistence
- Building a ridge regressor
- Building a polynomial regressor
- Estimating housing prices
- Computing the relative importance of features
- Estimating bicycle demand distribution
- 2. Constructing a Classifier
- Introduction
- Building a simple classifier
- Building a logistic regression classifier
- Building a Naive Bayes classifier
- Splitting the dataset for training and testing
- Evaluating the accuracy using cross-validation
- Visualizing the confusion matrix
- Extracting the performance report
- Evaluating cars based on their characteristics
- Extracting validation curves
- Extracting learning curves
- Estimating the income bracket
- 3. Predictive Modeling
- 4. Clustering with Unsupervised Learning
- Introduction
- Clustering data using the k-means algorithm
- Compressing an image using vector quantization
- Building a Mean Shift clustering model
- Grouping data using agglomerative clustering
- Evaluating the performance of clustering algorithms
- Automatically estimating the number of clusters using DBSCAN algorithm
- Finding patterns in stock market data
- Building a customer segmentation model
- 5. Building Recommendation Engines
- Introduction
- Building function compositions for data processing
- Building machine learning pipelines
- Finding the nearest neighbors
- Constructing a k-nearest neighbors classifier
- Constructing a k-nearest neighbors regressor
- Computing the Euclidean distance score
- Computing the Pearson correlation score
- Finding similar users in the dataset
- Generating movie recommendations
- 6. Analyzing Text Data
- Introduction
- Preprocessing data using tokenization
- Stemming text data
- Converting text to its base form using lemmatization
- Dividing text using chunking
- Building a bag-of-words model
- Building a text classifier
- Identifying the gender
- Analyzing the sentiment of a sentence
- Identifying patterns in text using topic modeling
- 7. Speech Recognition
- 8. Dissecting Time Series and Sequential Data
- Introduction
- Transforming data into the time series format
- Slicing time series data
- Operating on time series data
- Extracting statistics from time series data
- Building Hidden Markov Models for sequential data
- Building Conditional Random Fields for sequential text data
- Analyzing stock market data using Hidden Markov Models
- 9. Image Content Analysis
- Introduction
- Operating on images using OpenCV-Python
- Detecting edges
- Histogram equalization
- Detecting corners
- Detecting SIFT feature points
- Building a Star feature detector
- Creating features using visual codebook and vector quantization
- Training an image classifier using Extremely Random Forests
- Building an object recognizer
- 10. Biometric Face Recognition
- Introduction
- Capturing and processing video from a webcam
- Building a face detector using Haar cascades
- Building eye and nose detectors
- Performing Principal Components Analysis
- Performing Kernel Principal Components Analysis
- Performing blind source separation
- Building a face recognizer using Local Binary Patterns Histogram
- 11. Deep Neural Networks
- Introduction
- Building a perceptron
- Building a single layer neural network
- Building a deep neural network
- Creating a vector quantizer
- Building a recurrent neural network for sequential data analysis
- Visualizing the characters in an optical character recognition database
- Building an optical character recognizer using neural networks
- 12. Visualizing Data
- 1. The Realm of Supervised Learning
- II. Module 2
- 1. Unsupervised Machine Learning
- 2. Deep Belief Networks
- 3. Stacked Denoising Autoencoders
- 4. Convolutional Neural Networks
- 5. Semi-Supervised Learning
- 6. Text Feature Engineering
- 7. Feature Engineering Part II
- 8. Ensemble Methods
- 9. Additional Python Machine Learning Tools
- A. Chapter Code Requirements
- III. Module 3
- 1. First Steps to Scalability
- 2. Scalable Learning in Scikit-learn
- 3. Fast SVM Implementations
- 4. Neural Networks and Deep Learning
- The neural network architecture
- Neural networks and regularization
- Neural networks and hyperparameter optimization
- Neural networks and decision boundaries
- Deep learning at scale with H2O
- Deep learning and unsupervised pretraining
- Deep learning with theanets
- Autoencoders and unsupervised learning
- Summary
- 5. Deep Learning with TensorFlow
- 6. Classification and Regression Trees at Scale
- 7. Unsupervised Learning at Scale
- 8. Distributed Environments – Hadoop and Spark
- 9. Practical Machine Learning with Spark
- A. Introduction to GPUs and Theano
- A. Bibliography
- Index
Now that we know how to create a perceptron, let's create a single layer neural network. A single layer neural network consists of multiple neurons in a single layer. Overall, we will have an input layer, a hidden layer, and an output layer.
- Create a new Python file, and import the following packages:
import numpy as np import matplotlib.pyplot as plt import neurolab as nl
- We will use the data in the
data_single_layer.txtfile. Let's load this:# Define input data input_file = 'data_single_layer.txt' input_text = np.loadtxt(input_file) data = input_text[:, 0:2] labels = input_text[:, 2:]
- Let's plot the input data:
# Plot input data plt.figure() plt.scatter(data[:,0], data[:,1]) plt.xlabel('X-axis') plt.ylabel('Y-axis') plt.title('Input data') - Let's extract the minimum and maximum values:
# Min and max values for each dimension x_min, x_max = data[:,0].min(), data[:,0].max() y_min, y_max = data[:,1].min(), data[:,1].max()
- Let's define a single layer neural network with two neurons in the hidden layer:
# Define a single-layer neural network with 2 neurons; # Each element in the list (first argument) specifies the # min and max values of the inputs single_layer_net = nl.net.newp([[x_min, x_max], [y_min, y_max]], 2)
- Train the neural network until 50 epochs:
# Train the neural network error = single_layer_net.train(data, labels, epochs=50, show=20, lr=0.01)
- Plot the results, as follows:
# Plot results plt.figure() plt.plot(error) plt.xlabel('Number of epochs') plt.ylabel('Training error') plt.title('Training error progress') plt.grid() plt.show() - Let's test the neural network on new test data:
print single_layer_net.sim([[0.3, 4.5]]) print single_layer_net.sim([[4.5, 0.5]]) print single_layer_net.sim([[4.3, 8]])
- The full code is in the
single_layer.pyfile that's already provided to you. If you run this code, you will see two figures. The first figure displays the input data:
The second figure displays the training error progress:
You will see the following printed on your Terminal, indicating where the input test points belong:
[[ 0. 0.]] [[ 1. 0.]] [[ 1. 1.]]
You can verify that the outputs are correct based on our labels.
-
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.