def expanded_data():
expanded_training_data, _, _ = network3.load_data_shared(
"../data/mnist_expanded.pkl.gz")
for j in range(3):
print "Training with expanded data, run num %s" % j
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
FullyConnectedLayer(n_in=40 * 4 * 4, n_out=100,
activation_fn=ReLU),
SoftmaxLayer(n_in=100, n_out=10)
], mini_batch_size)
net.SGD(expanded_training_data,
20,
mini_batch_size,
0.03,
validation_data,
test_data,
lmbda=0.1)
def test_4():
"""全连接 + 卷积混合层 + 卷积混合层 + 全连接 + softmax
激活函数:修正线性单元
代价函数：L2规范化
测试准确率：99.18%
"""
name = sys._getframe().f_code.co_name
print(name + "\n")
training_data, validation_data, test_data = network3.load_data_shared()
mini_batch_size = 10
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
FullyConnectedLayer(n_in=40 * 4 * 4, n_out=100, activation_fn=ReLU),
SoftmaxLayer(n_in=100, n_out=10)
], mini_batch_size)
net.SGD(training_data,
60,
mini_batch_size,
0.03,
validation_data,
test_data,
lmbda=0.1)
def double_fc_dropout(p0, p1, p2, repetitions):
expanded_training_data, _, _ = network3.load_data_shared(
"../data/mnist_expanded.pkl.gz")
nets = []
for j in range(repetitions):
print "\n\nTraining using a dropout network with parameters ", p0, p1, p2
print "Training with expanded data, run num %s" % j
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
FullyConnectedLayer(
n_in=40 * 4 * 4, n_out=1000, activation_fn=ReLU, p_dropout=p0),
FullyConnectedLayer(
n_in=1000, n_out=1000, activation_fn=ReLU, p_dropout=p1),
SoftmaxLayer(n_in=1000, n_out=10, p_dropout=p2)], mini_batch_size)
net.SGD(expanded_training_data, 40, mini_batch_size, 0.03,
validation_data, test_data)
nets.append(net)
return nets
def double_fc_dropout(p0, p1, p2, repetitions):
expanded_training_data, _, _ = network3.load_data_shared(
"../data/mnist_expanded.pkl.gz")
nets = []
for j in range(repetitions):
print("\n\nTraining using a dropout network with parameters "
), p0, p1, p2
print("Training with expanded data, run num %s") % j
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
FullyConnectedLayer(
n_in=40 * 4 * 4, n_out=1000, activation_fn=ReLU, p_dropout=p0),
FullyConnectedLayer(
n_in=1000, n_out=1000, activation_fn=ReLU, p_dropout=p1),
SoftmaxLayer(n_in=1000, n_out=10, p_dropout=p2)
], mini_batch_size)
net.SGD(expanded_training_data, 40, mini_batch_size, 0.03,
validation_data, test_data)
nets.append(net)
return nets
def expanded_data_double_fc(n=100):
"""n is the number of neurons in both fully-connected layers. We'll
try n=100, 300, and 1000.
"""
expanded_training_data, _, _ = network3.load_data_shared(
"../data/mnist_expanded.pkl.gz")
for j in range(3):
print(
"Training with expanded data, %s neurons in two FC layers, run num %s"
) % (n, j)
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
FullyConnectedLayer(n_in=40 * 4 * 4, n_out=n, activation_fn=ReLU),
FullyConnectedLayer(n_in=n, n_out=n, activation_fn=ReLU),
SoftmaxLayer(n_in=n, n_out=10)
], mini_batch_size)
net.SGD(expanded_training_data,
60,
mini_batch_size,
0.03,
validation_data,
test_data,
lmbda=0.1)
def test_0():
"""全连接 + 全连接 + softmax, 测试准确率97:80%
"""
name = sys._getframe().f_code.co_name
print(name + "\n")
training_data, validation_data, test_data = network3.load_data_shared()
mini_batch_size = 10
net = Network([
FullyConnectedLayer(n_in=784, n_out=100),
SoftmaxLayer(n_in=100, n_out=10)
], mini_batch_size)
net.SGD(training_data, 60, mini_batch_size, 0.1, validation_data,
test_data)
def train():
training_data, validation_data, dummy = network3.load_data_shared(
filename="data/mnist_1_percent_expanded_10_step.pkl.gz")
mini_batch_size = 10
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2)),
FullyConnectedLayer(n_in=20*12*12, n_out=100),
SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size)
accuracies = net.SGD(training_data, 10000, mini_batch_size, 0.1, validation_data)
with open("result/accuracy_1_percent_expanded_10_step.pkl", "w") as f:
f.write(pickle.dumps(accuracies))
f.close()
def test_1():
"""全连接 + 卷积混合层 + softmax，测试准确率98.48%
"""
name = sys._getframe().f_code.co_name
print(name + "\n")
training_data, validation_data, test_data = network3.load_data_shared()
mini_batch_size = 10
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2)),
SoftmaxLayer(n_in=20 * 12 * 12, n_out=10)
], mini_batch_size)
net.SGD(training_data, 60, mini_batch_size, 0.1, validation_data,
test_data)
def sample(p0,p1,p2,repetitions):
expanded_training_data, _, _ = network3.load_data_shared(
"../data/face256.pkl.gz")
nets = []
for j in range(repetitions):
print "\n\nTraining using a dropout network with parameters ",p0,p1,p2
print "Training with expanded data, run num %s" % j
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 256, 256),
filter_shape=(20, 1, 3, 3),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 127, 127),
filter_shape=(40, 20, 2, 2),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 40, 63, 63),
filter_shape=(80, 40, 2, 2),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 80, 31, 31),
filter_shape=(100, 80, 2, 2),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 100, 15, 15),
filter_shape=(160, 100, 2, 2),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 160, 7, 7),
filter_shape=(200, 160, 2, 2),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 200, 3, 3),
filter_shape=(240, 200, 2, 2),
poolsize=(2, 2),
activation_fn=ReLU),
FullyConnectedLayer(
n_in=240*1*1, n_out=5000, activation_fn=ReLU, p_dropout=p0),
FullyConnectedLayer(
n_in=5000, n_out=2000, activation_fn=ReLU, p_dropout=p1),
SoftmaxLayer(n_in=2000, n_out=7, p_dropout=p2)], mini_batch_size)
net.SGD(expanded_training_data, 10, mini_batch_size, 0.3,
validation_data, test_data)
nets.append(net)
return nets
def test_6():
"""全连接 + 卷积混合层 + 卷积混合层 + 全连接 + softmax
激活函数:修正线性单元
代价函数：L2规范化
训练数据：使用扩展数据集，将数据集多扩张8倍
测试准确率：99.45% (60 epochs), 99.58% (600 epochs)
"""
name = sys._getframe().f_code.co_name
print(name + "\n")
# 扩展数据集多扩展8倍
src_path = '../../minst-data/data/mnist.pkl.gz'
dst_path = '../../minst-data/data/mnist_expanded_8.pkl.gz'
study_note.mnistTest().expand_mnist(src_path=src_path,
dst_path=dst_path,
expand_count=8)
training_data, validation_data, test_data = \
network3.load_data_shared(dst_path)
mini_batch_size = 10
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
FullyConnectedLayer(n_in=40 * 4 * 4, n_out=100, activation_fn=ReLU),
SoftmaxLayer(n_in=100, n_out=10)
], mini_batch_size)
net.SGD(training_data,
60,
mini_batch_size,
0.03,
validation_data,
test_data,
lmbda=0.1)
def test_3():
"""全连接 + 卷积混合层 + 卷积混合层 + 全连接 + softmax，测试准确率99.09%
"""
name = sys._getframe().f_code.co_name
print(name + "\n")
training_data, validation_data, test_data = network3.load_data_shared()
mini_batch_size = 10
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2)),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2, 2)),
FullyConnectedLayer(n_in=40 * 4 * 4, n_out=100),
SoftmaxLayer(n_in=100, n_out=10)
], mini_batch_size)
net.SGD(training_data, 60, mini_batch_size, 0.1, validation_data,
test_data)
def test_7():
"""全连接 + 卷积混合层 + 卷积混合层 + 全连接 + 全连接 + softmax
激活函数:修正线性单元
代价函数：L2规范化
训练数据：使用扩展数据集
测试准确率：99.49%
"""
name = sys._getframe().f_code.co_name
print(name + "\n")
# 扩展数据集
expand_mnist.expand_mnist_data()
dst_path = "../../minst-data/data/mnist_expanded.pkl.gz"
training_data, validation_data, test_data = \
network3.load_data_shared(dst_path)
mini_batch_size = 10
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
FullyConnectedLayer(n_in=40 * 4 * 4, n_out=100, activation_fn=ReLU),
FullyConnectedLayer(n_in=100, n_out=100, activation_fn=ReLU),
SoftmaxLayer(n_in=100, n_out=10)
], mini_batch_size)
net.SGD(training_data,
60,
mini_batch_size,
0.03,
validation_data,
test_data,
lmbda=0.1)
def expanded_data_double_fc(n=100):
"""n is the number of neurons in both fully-connected layers. We'll
try n=100, 300, and 1000.
"""
expanded_training_data, _, _ = network3.load_data_shared(
"../data/mnist_expanded.pkl.gz")
for j in range(3):
print "Training with expanded data, %s neurons in two FC layers, run num %s" % (n, j)
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
FullyConnectedLayer(n_in=40 * 4 * 4, n_out=n, activation_fn=ReLU),
FullyConnectedLayer(n_in=n, n_out=n, activation_fn=ReLU),
SoftmaxLayer(n_in=n, n_out=10)], mini_batch_size)
net.SGD(expanded_training_data, 60, mini_batch_size, 0.03,
validation_data, test_data, lmbda=0.1)
def main_03():
t1 = time.gmtime(time.time())
print('training NN3 running....%d:%d:%d' %
(t1.tm_hour, t1.tm_min, t1.tm_sec))
from network3 import Network
from network3 import ConvPoolLayer, FullyConnectedLayer, SoftmaxLayer
training_data, validation_data, test_data = network3.load_data_shared()
mini_batch_size = 10
net = network3.Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2)),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2, 2)),
FullyConnectedLayer(n_in=40 * 4 * 4, n_out=100),
SoftmaxLayer(n_in=100, n_out=10)
], mini_batch_size)
net.SGD(training_data, 60, mini_batch_size, 0.1, validation_data,
test_data)
t1 = time.gmtime(time.time())
print('training NN3 running....%d:%d:%d end' %
(t1.tm_hour, t1.tm_min, t1.tm_sec))
import network3
test_data = network3.load_data_shared()[2]
import cPickle
gg = open('net3.p', 'rb')
net3= cPickle.load(gg)
gg.close()
import mnist_loader
training_data, validation_data, test_data = mnist_loader.load_data_wrapper()
imgIndex = 45
testImg = mnist_loader.load_data_wrapper()[2][imgIndex]
print str(net3.feedback2(testImg[0]))
result[0], result[1], result[2], result[3], result[4], result[5],
result[6], result[7], result[8], result[9]).split(',')
return result
#return [float(i) for i in result]
if __name__ == '__main__':
import network3
from network3 import Network
from network3 import ConvPoolLayer, FullyConnectedLayer, SoftmaxLayer
from network3 import ReLU
import os, struct, csv
from collections import Counter
expanded_training_data, training_data, validation_data, test_data = \
network3.load_data_shared(expanded_time=15)
mini_batch_size = 100
voters = 1
vote_box = []
vote_prob_box = []
for vote in xrange(voters):
#expanded_training_data, validation_data, test_data = \
# network3.load_data_shared(expanded_time=10)
# from book chap6
#'''
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 29, 29),
filter_shape=(6, 1, 17, 17),
poolsize=(1, 1),
activation_fn=ReLU),
import network3
from network3 import Network
from network3 import ConvPoolLayer, FullyConnectedLayer, SoftmaxLayer
from network3 import ReLU
training_data, validation_data, test_data = network3.load_data_shared()
expanded_training_data, _, _ = network3.load_data_shared("mnist_expanded.pkl.gz")
mini_batch_size = 10
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
FullyConnectedLayer(n_in=40*4*4, n_out=100, activation_fn=ReLU),
SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size)
net.SGD(expanded_training_data, 30, mini_batch_size, 0.03,
validation_data, test_data, lmbda=0.1)
import network3 from network3 import Network from network3 import SoftmaxLayer, FullyConnectedLayer, ConvPoolLayer import winsound mini_batch_size = 10 f = FullyConnectedLayer(n_in = 20 * 12 * 12, n_out = 100) s = SoftmaxLayer(n_in = 100, n_out = 25) c = ConvPoolLayer(image_shape = (mini_batch_size, 1, 28, 28), filter_shape = (20, 1, 5, 5), poolsize = (2,2)) net = Network([c, f ,s], mini_batch_size) print "\n Network Created. Now Loading Data. Please be patient. \n" train, valid, test = network3.load_data_shared() print "\n \n \nData Sucessfully Loaded \n" #winsound.Beep(2100, 1000) net.SGD(train, 30, mini_batch_size, 0.1, valid, test)
import mnist_loader
import network3
expanded_training_data, _, _ = network3.load_data_shared(
"../data/mnist_expanded.pkl.gz")
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
FullyConnectedLayer(
n_in=40*4*4, n_out=1000, activation_fn=ReLU, p_dropout=0.5),
FullyConnectedLayer(
n_in=1000, n_out=1000, activation_fn=ReLU, p_dropout=0.5),
SoftmaxLayer(n_in=1000, n_out=10, p_dropout=0.5)],
mini_batch_size)
net.SGD(expanded_training_data, 40, mini_batch_size, 0.03,
validation_data, test_data)
# 调用SGD随机梯度下降算法 (使用cross-entropy函数)
# net.large_weight_initializer()
# net.SGD(training_data, 30, 10, 0.5, evaluation_data=test_data, monitor_evaluation_accuracy=True)
# import network2
# net = network2.Network([784, 100, 10], cost=network2.CrossEntropyCost)
# net.large_weight_initializer()
# print 'begin to learn'
# net.SGD(training_data, 60, 10, 0.5, lmbda=5.0,evaluation_data=validation_data,monitor_evaluation_accuracy=True)
# print 'finish learn'
import network3
from network3 import ReLU
from network3 import Network
from network3 import ConvPoolLayer, FullyConnectedLayer, SoftmaxLayer
training_data, validation_data, test_data = network3.load_data_shared(
"../data1/elastic_rotate_expand.pkl")
mini_batch_size = 10
# expanded_training_data, _, _ = network3.load_data_shared(
# "../data/mnist_expanded.pkl.gz")
# net = Network([
# FullyConnectedLayer(n_in=784, n_out=100),
# SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size)
# net.SGD(training_data, 60, mini_batch_size, 0.1,
# validation_data, test_data)
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
import network3
import numpy as np
import scipy
import matplotlib.pyplot as plt
import PIL
training_data, _, _ = network3.load_data_shared()
training_x, training_y = training_data
x = training_x.get_value()[0] # vector corresponding to a 5
x_img = np.reshape(x, (-1, 28)) # recognizable 5
y = training_y.eval()[0] # label: 5
#### Translate
# Randomly translate the image by -1, 0 or 1 pixel right and down
x_tr = np.random.randint(-1, 2) # x > 0 means translated to the right
print("translation: {} pixel right".format(x_tr))
y_tr = np.random.randint(-1, 2) # y > 0 means translated down
print("translation: {} pixel down".format(y_tr))
if x_tr != 0:
x_img = np.roll(x_img, x_tr, 1) # 1: x axis
if x_tr > 0:
# The image is to be translated to the right
x_img[:, 0:x_tr] = np.zeros((28, x_tr))
else:
# The image is to be translated to the left
x_img[:, 28+x_tr:] = np.zeros((28, -x_tr))
if y_tr != 0:
x_img = np.roll(x_img, y_tr, 0) # 0: y axis
result = "{:.3},{:.3},{:.3},{:.3},{:.3},{:.3},{:.3},{:.3},{:.3},{:.3}".format(
result[0],result[1],result[2],result[3],result[4],result[5],result[6],result[7],result[8],result[9]).split(',')
return result
#return [float(i) for i in result]
if __name__ == '__main__':
import network3
from network3 import Network
from network3 import ConvPoolLayer, FullyConnectedLayer, SoftmaxLayer
from network3 import ReLU
import os, struct, csv
from collections import Counter
expanded_training_data, training_data, validation_data, test_data = \
network3.load_data_shared(expanded_time=15)
mini_batch_size = 100
voters = 1
vote_box = []
vote_prob_box = []
for vote in xrange(voters):
#expanded_training_data, validation_data, test_data = \
# network3.load_data_shared(expanded_time=10)
# from book chap6
#'''
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 29, 29),
filter_shape=(6, 1, 17, 17), poolsize=(1, 1),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 6, 13, 13),
import network3
import matplotlib.pyplot as plt
from network3 import Network
from network3 import ConvPoolLayer, FullyConnectedLayer, SoftmaxLayer
from network3 import ReLU
training_data, validation_data, test_data = \
network3.load_data_shared('../data/bird_image_full.pkl.gz')
mini_batch_size = 10
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2,2),
activation_fn=ReLU),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2,2),
activation_fn=ReLU),
FullyConnectedLayer(n_in=40*4*4, n_out=100, activation_fn=ReLU, p_dropout=0.5),
SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size)
costs, train_acc = net.SGD(training_data, 200, mini_batch_size, 0.1, validation_data, test_data, lmbda=0.4,
diminishing_lr=True)
it = range(0, 1000 * len(costs), 1000)
plt.plot(it, costs)
plt.ylabel('cost')
plt.show()
#net.save("out.txt")
# -*- coding: utf-8 -*-
"""
Created on Thu Nov 16 12:22:00 2017
@author: Syrine Belakaria
"""
import network3
from network3 import Network
from network3 import ConvPoolLayer, FullyConnectedLayer, SoftmaxLayer
from network3 import ReLU
from network3 import sigmoid
import numpy as np
import matplotlib.pyplot as plt
expanded_training_data, validation_data, test_data = network3.load_data_shared(
"../data/quickdraw_expanded.pkl.gz")
mini_batch_size = 10
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2)),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 3, 3),
poolsize=(2, 2)),
FullyConnectedLayer(
n_in=40 * 5 * 5, n_out=500, activation_fn=sigmoid, p_dropout=0.1),
FullyConnectedLayer(
n_in=500, n_out=500, activation_fn=sigmoid, p_dropout=0.1),
SoftmaxLayer(n_in=500, n_out=10, p_dropout=0.1)
], mini_batch_size)
net.SGD(expanded_training_data, 70, mini_batch_size, 0.01, validation_data,
# m_test = test_data[0].shape[0]
# ind_test = list(range(m_test))
# random.shuffle(ind_test)
# ind_test = ind_test[0:m_test // percentage]
# training_data = (training_data[0][ind_train, :],
# training_data[1][ind_train])
# validation_data = (validation_data[0][ind_val, :],
# validation_data[1][ind_val])
# test_data = (test_data[0][ind_test, :],
# test_data[1][ind_test])
# return training_data, validation_data, test_data
training_data, validation_data, test_data = network3.load_data_shared(
percentage=10)
mini_batch_size = 30
net = Network([
ConvPoolLayer(input_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(input_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2, 2),
activation_fn=ReLU),
FullyConnectedLayer(n_in=40 * 4 * 4, n_out=100, activation_fn=ReLU),
SoftmaxLayer(n_in=100, n_out=10)
], mini_batch_size)
import network3
from network3 import Network
from network3 import ConvPoolLayer, FullyConnectedLayer, SoftmaxLayer
from network3 import ReLU
training_data, validation_data, test_data = network3.load_data_shared()
expanded_training_data, _, _ = network3.load_data_shared("mnist_expanded.pkl.gz")
mini_batch_size = 10
net = Network(
[
ConvPoolLayer(
image_shape=(mini_batch_size, 1, 28, 28), filter_shape=(20, 1, 5, 5), poolsize=(2, 2), activation_fn=ReLU
),
ConvPoolLayer(
image_shape=(mini_batch_size, 20, 12, 12), filter_shape=(40, 20, 5, 5), poolsize=(2, 2), activation_fn=ReLU
),
FullyConnectedLayer(n_in=40 * 4 * 4, n_out=100, activation_fn=ReLU),
SoftmaxLayer(n_in=100, n_out=10),
],
mini_batch_size,
)
net.SGD(expanded_training_data, 30, mini_batch_size, 0.03, validation_data, test_data, lmbda=0.1)
import network3 as nw
expanded_training_data, validation_data, test_data = nw.load_data_shared(
"../data/mnist.pkl.gz")
mini_batch_size = 30
net = nw.Network([
nw.ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2),
activation_fn=nw.ReLU),
nw.ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2, 2),
activation_fn=nw.ReLU),
nw.FullyConnectedLayer(
n_in=40*4*4, n_out=1000, activation_fn=nw.ReLU, p_dropout=0.5),
nw.FullyConnectedLayer(
n_in=1000, n_out=1000, activation_fn=nw.ReLU, p_dropout=0.5),
nw.SoftmaxLayer(n_in=1000, n_out=10, p_dropout=0.5)],
mini_batch_size)
net.SGD(expanded_training_data, 60, mini_batch_size, 0.03,
validation_data, test_data, lmbda=0.1)
import network3 from network3 import Network from network3 import ConvPoolLayer, FullyConnectedLayer, SoftmaxLayer training_data, validation_data, test_data = network3.load_data_shared() mini_batch_size = 10 net = Network([FullyConnectedLayer(n_in=784, n_out=100), SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size) net.SGD(training_data, 60, mini_batch_size, 0.1, validation_data, test_data)
#!python35
# -*- coding: utf-8 -*-
import network3
from network3 import Network, ConvPoolLayer, FullyConnectedLayer, SoftmaxLayer # softmax plus log-likelihood cost is more common in modern image classification networks.
# read data:
training_data, validation_data, test_data = network3.load_data_shared(
'../data/mnist.pkl.gz')
# mini-batch size:
mini_batch_size = 10
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2)),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2, 2)),
FullyConnectedLayer(n_in=40 * 4 * 4, n_out=100),
SoftmaxLayer(n_in=100, n_out=10)
], mini_batch_size)
net.SGD_kaggle(training_data, 60, mini_batch_size, 0.1, validation_data,
test_data)
