Neural Networks with scikit
Perceptron Class
We will start with the Perceptron class contained in Scikit-Learn. We will use it on the iris dataset, which we had already used in our chapter on k-nearest neighbor
import numpy as np from sklearn.datasets import load_iris from sklearn.linear_model import Perceptron iris = load_iris() print(iris.data[:3]) print(iris.data[15:18]) print(iris.data[37:40]) # we extract only the lengths and widthes of the petals: X = iris.data[:, (2, 3)]
[[5.1 3.5 1.4 0.2] [4.9 3. 1.4 0.2] [4.7 3.2 1.3 0.2]] [[5.7 4.4 1.5 0.4] [5.4 3.9 1.3 0.4] [5.1 3.5 1.4 0.3]] [[4.9 3.6 1.4 0.1] [4.4 3. 1.3 0.2] [5.1 3.4 1.5 0.2]]
iris.label contains the labels 0, 1 and 2 corresponding three species of Iris flower:
- Iris setosa,
- Iris virginica and
- Iris versicolor.
print(iris.target)
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2]
We turn the three classes into two classes, i.e.
- Iris setosa
- not Iris setosa (this means Iris virginica or Iris versicolor)
y = (iris.target==0).astype(np.int8) print(y)
[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
We create now a Perceptron and fit the data X and y:
p = Perceptron(random_state=42, max_iter=10, tol=0.001) p.fit(X, y)The Python code above returned the following:
Perceptron(alpha=0.0001, class_weight=None, early_stopping=False, eta0=1.0,
fit_intercept=True, max_iter=10, n_iter=None, n_iter_no_change=5,
n_jobs=None, penalty=None, random_state=42, shuffle=True, tol=0.001,
validation_fraction=0.1, verbose=0, warm_start=False)
Now, we are ready for predictions:
values = [[1.5, 0.1], [1.8, 0.4], [1.3,0.2]] for value in X: pred = p.predict([value]) print([pred])
[array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([1], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)] [array([0], dtype=int8)]### Multi-layer Perceptron We will continue with examples using the multilayer perceptron (MLP). The multilayer perceptron (MLP) is a feedforward artificial neural network model that maps sets of input data onto a set of appropriate outputs. An MLP consists of multiple layers and each layer is fully connected to the following one. The nodes of the layers are neurons using nonlinear activation functions, except for the nodes of the input layer. There can be one or more non-linear hidden layers between the input and the output layer.
from sklearn.neural_network import MLPClassifier X = [[0., 0.], [0., 1.], [1., 0.], [1., 1.]] y = [0, 0, 0, 1] clf = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(5, 2), random_state=1) print(clf.fit(X, y))
MLPClassifier(activation='relu', alpha=1e-05, batch_size='auto', beta_1=0.9,
beta_2=0.999, early_stopping=False, epsilon=1e-08,
hidden_layer_sizes=(5, 2), learning_rate='constant',
learning_rate_init=0.001, max_iter=200, momentum=0.9,
n_iter_no_change=10, nesterovs_momentum=True, power_t=0.5,
random_state=1, shuffle=True, solver='lbfgs', tol=0.0001,
validation_fraction=0.1, verbose=False, warm_start=False)
The following diagram depicts the neural network, that we have trained for our classifier clf. We have two input nodes $X_0$ and $X_1$, called the input layer, and one output neuron 'Out'. We have two hidden layers the first one with the neurons $H_{00}$ ... $H_{04}$ and the second hidden layer consisting of $H_{10}$ and $H_{11}$. Each neuron of the hidden layers and the output neuron possesses a corresponding Bias, i.e. $B_{00}$ is the corresponding Bias to the neuron $H_{00}$, $B_{01}$ is the corresponding Bias to the neuron $H_{01}$ and so on.
Each neuron of the hidden layers receives the output from every neuron of the previous layers and transforms these values with a weighted linear summation $$\sum_{i=0}^{n-1}w_ix_i = w_0x_0 + w_1x_1 + ... + w_{n-1}x_{n-1}$$ into an output value, where n is the number of neurons of the layer and $w_i$ corresponds to the ith component of the weight vector. The output layer receives the values from the last hidden layer. It also performs a linear summation, but a non-linear activation function $$g(\cdot):R \rightarrow R$$ like the hyperbolic tan function will be applied to the summation result.
The attribute coefs_ contains a list of weight matrices for every layer. The weight matrix at index i holds the weights between the layer i and layer i + 1.
print("weights between input and first hidden layer:") print(clf.coefs_[0]) print("\nweights between first hidden and second hidden layer:") print(clf.coefs_[1])
weights between input and first hidden layer: [[-0.14203691 -1.18304359 -0.85567518 -4.53250719 -0.60466275] [-0.69781111 -3.5850093 -0.26436018 -4.39161248 0.06644423]] weights between first hidden and second hidden layer: [[ 0.29179638 -0.14155284] [ 4.02666592 -0.61556475] [-0.51677234 0.51479708] [ 7.37215202 -0.31936965] [ 0.32920668 0.64428109]]
The summation formula of the neuron H00 is defined by:
$$\sum_{i=0}^{n-1}w_ix_i = w_0x_0 + w_1x_1 + w_{B_{11}} * B_{11}$$which can be written as
$$\sum_{i=0}^{n-1}w_ix_i = w_0x_0 + w_1x_1 + w_{B_{11}}$$because $B_{11} = 1$.
We can get the values for $w_0$ and $w_1$ from clf.coefs_ like this:
$w_0 =$ clf.coefs_[0][0][0] and $w_1 =$ clf.coefs_[0][1][0]
print("w0 = ", clf.coefs_[0][0][0]) print("w1 = ", clf.coefs_[0][1][0])
w0 = -0.14203691267827162 w1 = -0.6978111149778682
The weight vector of $H_{00}$ can be accessed with
clf.coefs_[0][:,0]The previous code returned the following output:
array([-0.14203691, -0.69781111])
We can generalize the above to access a neuron $H_{ij}$ in the following way:
for i in range(len(clf.coefs_)): number_neurons_in_layer = clf.coefs_[i].shape[1] for j in range(number_neurons_in_layer): weights = clf.coefs_[i][:,j] print(i, j, weights, end=", ") print() print()
0 0 [-0.14203691 -0.69781111], 0 1 [-1.18304359 -3.5850093 ], 0 2 [-0.85567518 -0.26436018], 0 3 [-4.53250719 -4.39161248], 0 4 [-0.60466275 0.06644423], 1 0 [ 0.29179638 4.02666592 -0.51677234 7.37215202 0.32920668], 1 1 [-0.14155284 -0.61556475 0.51479708 -0.31936965 0.64428109], 2 0 [-4.96774269 -0.86330397],
intercepts_ is a list of bias vectors, where the vector at index i represents the bias values added to layer i+1.
print("Bias values for first hidden layer:") print(clf.intercepts_[0]) print("\nBias values for second hidden layer:") print(clf.intercepts_[1])
Bias values for first hidden layer: [-0.14962269 -0.59232707 -0.5472481 7.02667699 -0.87510813] Bias values for second hidden layer: [-3.61417672 -0.76834882]
The main reason, why we train a classifier is to predict results for new samples. We can do this with the predict method. The method returns a predicted class for a sample, in our case a "0" or a "1" :
result = clf.predict([[0, 0], [0, 1], [1, 0], [0, 1], [1, 1], [2., 2.], [1.3, 1.3], [2, 4.8]])
Instead of just looking at the class results, we can also use the predict_proba method to get the probability estimates.
prob_results = clf.predict_proba([[0, 0], [0, 1], [1, 0], [0, 1], [1, 1], [2., 2.], [1.3, 1.3], [2, 4.8]]) print(prob_results)
[[1.00000000e+000 5.25723951e-101] [1.00000000e+000 3.71534882e-031] [1.00000000e+000 6.47069178e-029] [1.00000000e+000 3.71534882e-031] [2.07145538e-004 9.99792854e-001] [2.07145538e-004 9.99792854e-001] [2.07145538e-004 9.99792854e-001] [2.07145538e-004 9.99792854e-001]]
prob_results[i][0] gives us the probability for the class0, i.e. a "0" and results[i][1] the probabilty for a "1". i corresponds to the ith sample.
Another Example
We will populate two clusters (class0 and class1) in a two dimensional space.
import numpy as np from matplotlib import pyplot as plt npoints = 50 X, Y = [], [] # class 0 X.append(np.random.uniform(low=-2.5, high=2.3, size=(npoints,)) ) Y.append(np.random.uniform(low=-1.7, high=2.8, size=(npoints,))) # class 1 X.append(np.random.uniform(low=-7.2, high=-4.4, size=(npoints,)) ) Y.append(np.random.uniform(low=3, high=6.5, size=(npoints,))) learnset = [] learnlabels = [] for i in range(2): # adding points of class i to learnset points = zip(X[i], Y[i]) for p in points: learnset.append(p) learnlabels.append(i) npoints_test = 3 * npoints TestX = np.random.uniform(low=-7.2, high=5, size=(npoints_test,)) TestY = np.random.uniform(low=-4, high=9, size=(npoints_test,)) testset = [] points = zip(TestX, TestY) for p in points: testset.append(p) colours = ["b", "r"] for i in range(2): plt.scatter(X[i], Y[i], c=colours[i]) plt.scatter(TestX, TestY, c="g") plt.show()
<Figure size 640x480 with 1 Axes>
We will train a MLPClassifier for our two classes:
import matplotlib.pyplot as plt from sklearn.datasets import fetch_mldata from sklearn.neural_network import MLPClassifier mlp = MLPClassifier(hidden_layer_sizes=(20, 3), max_iter=150, alpha=1e-4, solver='sgd', verbose=10, tol=1e-4, random_state=1, learning_rate_init=.1) mlp.fit(learnset, learnlabels) print("Training set score: %f" % mlp.score(learnset, learnlabels)) print("Test set score: %f" % mlp.score(learnset, learnlabels)) mlp.classes_
Iteration 1, loss = 0.50079019 Iteration 2, loss = 0.46400111 Iteration 3, loss = 0.42645559 Iteration 4, loss = 0.38630293 Iteration 5, loss = 0.35703136 Iteration 6, loss = 0.32589219 Iteration 7, loss = 0.29516201 Iteration 8, loss = 0.26677878 Iteration 9, loss = 0.24073422 Iteration 10, loss = 0.21667340 Iteration 11, loss = 0.19438790 Iteration 12, loss = 0.17388987 Iteration 13, loss = 0.15530203 Iteration 14, loss = 0.13868463 Iteration 15, loss = 0.12405113 Iteration 16, loss = 0.11130529 Iteration 17, loss = 0.10011663 Iteration 18, loss = 0.09029552 Iteration 19, loss = 0.08169809 Iteration 20, loss = 0.07417581 Iteration 21, loss = 0.06758791 Iteration 22, loss = 0.06180892 Iteration 23, loss = 0.05673045 Iteration 24, loss = 0.05226030 Iteration 25, loss = 0.04833629 Iteration 26, loss = 0.04487704 Iteration 27, loss = 0.04181651 Iteration 28, loss = 0.03910883 Iteration 29, loss = 0.03669848 Iteration 30, loss = 0.03454754 Iteration 31, loss = 0.03262256 Iteration 32, loss = 0.03089441 Iteration 33, loss = 0.02933799 Iteration 34, loss = 0.02793164 Iteration 35, loss = 0.02665732 Iteration 36, loss = 0.02549950 Iteration 37, loss = 0.02444474 Iteration 38, loss = 0.02348141 Iteration 39, loss = 0.02259936 Iteration 40, loss = 0.02178970 Iteration 41, loss = 0.02104464 Iteration 42, loss = 0.02035728 Iteration 43, loss = 0.01972159 Iteration 44, loss = 0.01913238 Iteration 45, loss = 0.01858504 Iteration 46, loss = 0.01807525 Iteration 47, loss = 0.01759938 Iteration 48, loss = 0.01715424 Iteration 49, loss = 0.01673697 Iteration 50, loss = 0.01634503 Iteration 51, loss = 0.01597614 Iteration 52, loss = 0.01562821 Iteration 53, loss = 0.01529952 Iteration 54, loss = 0.01498845 Iteration 55, loss = 0.01469354 Iteration 56, loss = 0.01441349 Iteration 57, loss = 0.01414710 Iteration 58, loss = 0.01389331 Iteration 59, loss = 0.01365116 Iteration 60, loss = 0.01341977 Iteration 61, loss = 0.01319837 Iteration 62, loss = 0.01298624 Iteration 63, loss = 0.01278273 Iteration 64, loss = 0.01258725 Iteration 65, loss = 0.01239927 Iteration 66, loss = 0.01221832 Iteration 67, loss = 0.01204393 Iteration 68, loss = 0.01187567 Iteration 69, loss = 0.01171318 Iteration 70, loss = 0.01155611 Iteration 71, loss = 0.01140413 Iteration 72, loss = 0.01125697 Iteration 73, loss = 0.01111436 Iteration 74, loss = 0.01097603 Iteration 75, loss = 0.01084176 Iteration 76, loss = 0.01071135 Iteration 77, loss = 0.01058459 Iteration 78, loss = 0.01046130 Iteration 79, loss = 0.01034132 Iteration 80, loss = 0.01022448 Iteration 81, loss = 0.01011065 Iteration 82, loss = 0.00999968 Iteration 83, loss = 0.00989145 Iteration 84, loss = 0.00978583 Iteration 85, loss = 0.00968273 Iteration 86, loss = 0.00958202 Iteration 87, loss = 0.00948363 Iteration 88, loss = 0.00938744 Iteration 89, loss = 0.00929339 Iteration 90, loss = 0.00920138 Iteration 91, loss = 0.00911134 Iteration 92, loss = 0.00902320 Iteration 93, loss = 0.00893689 Iteration 94, loss = 0.00885236 Iteration 95, loss = 0.00876958 Iteration 96, loss = 0.00868844 Iteration 97, loss = 0.00860890 Training loss did not improve more than tol=0.000100 for 10 consecutive epochs. Stopping. Training set score: 1.000000 Test set score: 1.000000This gets us the following result:
array([0, 1])
predictions = clf.predict(testset) predictionsThe previous Python code returned the following output:
array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1,
1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1,
1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0,
0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0,
1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0,
0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1,
0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0])
testset = np.array(testset) testset[predictions==1] colours = ['#C0FFFF', "#FFC8C8"] for i in range(2): plt.scatter(X[i], Y[i], c=colours[i]) colours = ["b", "r"] for i in range(2): cls = testset[predictions==i] Xt, Yt = zip(*cls) plt.scatter(Xt, Yt, marker="D", c=colours[i])
MNIST Dataset
We have already used the MNIST dataset in the chapter Testing with MNIST of our tutorial. You will also find some explanations about this dataset.
We want to apply the MLPClassifier on the MNIST data. We can load in the data with pickle:
import pickle with open("data/mnist/pickled_mnist.pkl", "br") as fh: data = pickle.load(fh) train_imgs = data[0] test_imgs = data[1] train_labels = data[2] test_labels = data[3] train_labels_one_hot = data[4] test_labels_one_hot = data[5] image_size = 28 # width and length no_of_different_labels = 10 # i.e. 0, 1, 2, 3, ..., 9 image_pixels = image_size * image_size
mlp = MLPClassifier(hidden_layer_sizes=(100, ), max_iter=480, alpha=1e-4, solver='sgd', verbose=10, tol=1e-4, random_state=1, learning_rate_init=.1) train_labels = train_labels.reshape(train_labels.shape[0],) print(train_imgs.shape, train_labels.shape) mlp.fit(train_imgs, train_labels) print("Training set score: %f" % mlp.score(train_imgs, train_labels)) print("Test set score: %f" % mlp.score(test_imgs, test_labels)) help(mlp.fit)
(60000, 784) (60000,)
Iteration 1, loss = 0.29308647
Iteration 2, loss = 0.12126145
Iteration 3, loss = 0.08665577
Iteration 4, loss = 0.06916886
Iteration 5, loss = 0.05734882
Iteration 6, loss = 0.04697824
Iteration 7, loss = 0.04005900
Iteration 8, loss = 0.03370386
Iteration 9, loss = 0.02848827
Iteration 10, loss = 0.02453574
Iteration 11, loss = 0.02058716
Iteration 12, loss = 0.01649971
Iteration 13, loss = 0.01408953
Iteration 14, loss = 0.01173909
Iteration 15, loss = 0.00925713
Iteration 16, loss = 0.00879338
Iteration 17, loss = 0.00687255
Iteration 18, loss = 0.00578659
Iteration 19, loss = 0.00492355
Iteration 20, loss = 0.00414159
Iteration 21, loss = 0.00358124
Iteration 22, loss = 0.00324285
Iteration 23, loss = 0.00299358
Iteration 24, loss = 0.00268943
Iteration 25, loss = 0.00248878
Iteration 26, loss = 0.00229525
Iteration 27, loss = 0.00218314
Iteration 28, loss = 0.00203129
Iteration 29, loss = 0.00190647
Iteration 30, loss = 0.00180089
Iteration 31, loss = 0.00175467
Iteration 32, loss = 0.00165441
Iteration 33, loss = 0.00159778
Iteration 34, loss = 0.00152206
Iteration 35, loss = 0.00146529
Iteration 36, loss = 0.00143086
Iteration 37, loss = 0.00138042
Iteration 38, loss = 0.00133189
Iteration 39, loss = 0.00128424
Iteration 40, loss = 0.00125897
Iteration 41, loss = 0.00121776
Iteration 42, loss = 0.00118951
Iteration 43, loss = 0.00115738
Training loss did not improve more than tol=0.000100 for 10 consecutive epochs. Stopping.
Training set score: 1.000000
Test set score: 0.980600
Help on method fit in module sklearn.neural_network.multilayer_perceptron:
fit(X, y) method of sklearn.neural_network.multilayer_perceptron.MLPClassifier instance
Fit the model to data matrix X and target(s) y.
Parameters
----------
X : array-like or sparse matrix, shape (n_samples, n_features)
The input data.
y : array-like, shape (n_samples,) or (n_samples, n_outputs)
The target values (class labels in classification, real numbers in
regression).
Returns
-------
self : returns a trained MLP model.
fig, axes = plt.subplots(4, 4) # use global min / max to ensure all weights are shown on the same scale vmin, vmax = mlp.coefs_[0].min(), mlp.coefs_[0].max() for coef, ax in zip(mlp.coefs_[0].T, axes.ravel()): ax.matshow(coef.reshape(28, 28), cmap=plt.cm.gray, vmin=.5 * vmin, vmax=.5 * vmax) ax.set_xticks(()) ax.set_yticks(()) plt.show()
In [ ]:
In [ ]:
In [ ]: