notebook.community

Edit and run 





In [2]:



    


%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
from IPython.html.widgets import interact
import sknn.mlp as neurnet

from sklearn.datasets import load_digits
digits = load_digits()

trainingdata = digits.data[0:1200]
traininganswers = digits.target[0:1200]
lc = 0.02

#convert the integer answers into a 10-dimension array
traininganswervectors = np.zeros((1200,10))
for n in range(1200):
    traininganswervectors[n][digits.target[n]] = 1
    
testdata = digits.data[1200:1700]
testanswers = digits.target[1200:1700]

testanswervectors = np.zeros((500,10))
for n in range(500):
    testanswervectors[n][digits.target[n + 1200]] = 1
    
    
trainingtuples = np.array(zip(trainingdata, traininganswervectors))
testtuples = np.array(zip(testdata, testanswervectors))



    


















    






:0: FutureWarning: IPython widgets are experimental and may change in the future.

















In [3]:



    


def accuracy(inputs, results, answers):
    correct = 0
    binresults = results
    for n in range(0, len(results)):
        #converts the output into a binary y/n for each digit
        for n2 in range(len(results[n])):
            if results[n][n2] == max(results[n]):
                binresults[n][n2] = 1
            else:
                binresults[n][n2] = 0
        
        if np.array_equal(answers[n], binresults[n]):
            correct += 1
    return correct / len(results)



    











In [21]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=80),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=100,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 9.9 s per loop
0.924

















In [22]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=40),
        neurnet.Layer("Sigmoid", units=40),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=100,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 9.54 s per loop
0.9

















In [23]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=100,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 9.24 s per loop
0.898

















In [24]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=10),
        neurnet.Layer("Sigmoid", units=10),
        neurnet.Layer("Sigmoid", units=10),
        neurnet.Layer("Sigmoid", units=10),
        neurnet.Layer("Sigmoid", units=10),
        neurnet.Layer("Sigmoid", units=10),
        neurnet.Layer("Sigmoid", units=10),
        neurnet.Layer("Sigmoid", units=10),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=100,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 9.73 s per loop
0.846

















In [25]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=5),
        neurnet.Layer("Sigmoid", units=5),
        neurnet.Layer("Sigmoid", units=5),
        neurnet.Layer("Sigmoid", units=5),
        neurnet.Layer("Sigmoid", units=5),
        neurnet.Layer("Sigmoid", units=5),
        neurnet.Layer("Sigmoid", units=5),
        neurnet.Layer("Sigmoid", units=5),
        neurnet.Layer("Sigmoid", units=5),
        neurnet.Layer("Sigmoid", units=5),
        neurnet.Layer("Sigmoid", units=5),
        neurnet.Layer("Sigmoid", units=5),
        neurnet.Layer("Sigmoid", units=5),
        neurnet.Layer("Sigmoid", units=5),
        neurnet.Layer("Sigmoid", units=5),
        neurnet.Layer("Sigmoid", units=10),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=100,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 11.7 s per loop
0.09

















In [26]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=4),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=100,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 12.9 s per loop
0.1

















In [27]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=2),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=100,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 12.4 s per loop
0.1

















In [30]:



    


time = [9.9, 9.54, 9.24, 9.73, 11.7, 12.9, 12.4]
acc = [0.924, 0.9, 0.898, 0.846, 0.09, 0.1, 0.1]

plt.scatter(time, acc)
plt.xlabel("Time")
plt.ylabel("Accuracy")



    


















    
Out[30]:








<matplotlib.text.Text at 0x7fcbfa536be0>










    
























In [38]:



    


fig = plt.figure()
ax = fig.add_subplot(111)

plt.scatter(time[0:4], acc[0:4])
ax.annotate("1x80", xy=(9.9, 0.928))
ax.annotate("2x40", xy=(9.54, 0.905))
ax.annotate("4x20", xy=(9.24, 0.902))
ax.annotate("8x10", xy=(9.73, 0.850))



    


















    
Out[38]:








<matplotlib.text.Annotation at 0x7fcbff485470>










    
























In [12]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=80),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=1,
    batch_size=1)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 478 ms per loop
0.864

















In [13]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=80),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=2,
    batch_size=2)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 364 ms per loop
0.858

















In [8]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=80),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=5,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 435 ms per loop
0.876

















In [9]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=80),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=10,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 1.01 s per loop
0.896

















In [45]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=80),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=20,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 1.77 s per loop
0.906

















In [46]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=80),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=40,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 3.47 s per loop
0.914

















In [47]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=80),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=60,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 5.27 s per loop
0.916

















In [48]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=80),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=80,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 6.98 s per loop
0.922

















In [5]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=80),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=100,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 8.77 s per loop
0.924

















In [6]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=80),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=120,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 10.5 s per loop
0.926

















In [7]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=80),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=400,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 34.9 s per loop
0.924

















In [18]:



    


_1x80time = [.478, .364, .435, 1.01, 1.77, 3.47, 5.27, 6.98, 8.77, 10.5, 34.9]
_1x80acc = [.864, .858, .876, .896, .906, .914, .916, .922, .924, .926, .924]



    











In [4]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=1,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






The slowest run took 8.40 times longer than the fastest. This could mean that an intermediate result is being cached 
1 loops, best of 3: 193 ms per loop
0.43

















In [5]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=2,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






The slowest run took 4.05 times longer than the fastest. This could mean that an intermediate result is being cached 
1 loops, best of 3: 317 ms per loop
0.526

















In [6]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=5,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 541 ms per loop
0.776

















In [7]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=10,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 833 ms per loop
0.864

















In [8]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=20,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 1.68 s per loop
0.88

















In [9]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=40,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 3.33 s per loop
0.894

















In [10]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=60,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 5.02 s per loop
0.9

















In [11]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=80,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 6.76 s per loop
0.898

















In [12]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=100,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 8.67 s per loop
0.898

















In [13]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=120,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 10.1 s per loop
0.898

















In [14]:



    


nn = neurnet.Regressor(
    layers=[
        neurnet.Layer("Sigmoid", units=64),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=20),
        neurnet.Layer("Sigmoid", units=10)],
    learning_rate=0.2,
    n_iter=400,
    batch_size=5)

%timeit -n 1 nn.fit(trainingdata, traininganswervectors)

y_valid = nn.predict(testdata)
print(accuracy(testdata, y_valid, testanswervectors))



    


















    






1 loops, best of 3: 35.6 s per loop
0.896

















In [19]:



    


_4x20time = [.193, .317, .541, .833, 1.68, 3.33, 5.02, 6.76, 8.67, 10.1, 35.6]
_4x20acc = [.43, .526, .776, .864, .88, .894, .9, .898, .898, .898, .896]



    











In [34]:



    


fig = plt.figure()
ax = fig.add_subplot(111)

plt.scatter(_1x80time, _1x80acc)
plt.scatter(_4x20time, _4x20acc, color="r")
ax.set_xscale("log")
plt.xlabel("Time (log)")
plt.ylabel("Accuracy")
plt.ylim((0, 1))



    


















    
Out[34]:








(0, 1)










    
























In [ ]:

Content source: SJSlavin/phys202-project

Similar notebooks:

notebook.community | gallery | about