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 elu():
net = None
for j in range(RUNS):
print "num %s, leaky relu, with regularization %s" % (j, 0.0001)
net = Network([
ConvPoolLayer(image_shape=(MB_SIZE, 1, IMAGE_SIZE, IMAGE_SIZE),
filter_shape=(5, 1, 12, 12),
poolsize=(3, 3),
activation_fn=ELU),
ConvPoolLayer(image_shape=(MB_SIZE, 5, 30, 30),
filter_shape=(10, 5, 3, 3),
poolsize=(2, 2),
activation_fn=ELU),
FullyConnectedLayer(
n_in=10 * 14 * 14, n_out=200, activation_fn=ELU),
FullyConnectedLayer(n_in=200, n_out=200, activation_fn=ELU),
FullyConnectedLayer(n_in=200, n_out=100, activation_fn=ELU),
SoftmaxLayer(n_in=100, n_out=2)
], MB_SIZE)
net.SGD("ELU",
training_data,
EPOCHS,
MB_SIZE,
ETA,
validation_data,
test_data,
lmbda=0.0001)
return net
def dbl_conv_relu():
for lmbda in [0.0, 0.00001, 0.0001, 0.001, 0.01, 0.1, 1.0, 10.0, 100.0]:
for j in range(3):
print("Conv + Conv + FC num %s, relu, with regularization %s") % (
j, lmbda)
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=lmbda)
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 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():
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 shallow():
for j in range(3):
print "A shallow net with 100 hidden neurons"
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 omit_FC():
for j in range(3):
print "Conv only, no FC"
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)
return net
def test_drop(mini_batch_size):
size = 100
f_s = 7
padding = 1
conv_stride = 1
pool_stride = 1
pool_size = 4
n_f1 = 20
n_f2 = 40
n_f3 = 80
co1 = ((size - f_s + 2 * padding) / conv_stride) + 1
po1 = ((co1 - pool_size) / pool_stride) + 1
print(po1)
co2 = ((po1 - f_s + 2 * padding) / conv_stride) + 1
po2 = ((co2 - pool_size) / pool_stride) + 1
print(po2)
co3 = ((po2 - f_s + 2 * padding) / conv_stride) + 1
po3 = ((co3 - pool_size) / pool_stride) + 1
print(po3)
layer1 = ConvPoolLayer(input_shape=(mini_batch_size, 1, size, size),
filter_shape=(n_f1, 1, f_s, f_s),
poolsize=(4, 4),
activation_fn=ReLU)
layer2 = ConvPoolLayer(input_shape=(mini_batch_size, n_f1, po1, po1),
filter_shape=(n_f2, n_f1, f_s, f_s),
poolsize=(4, 4),
activation_fn=ReLU)
layer3 = ConvPoolLayer(input_shape=(mini_batch_size, n_f2, po2, po2),
filter_shape=(n_f3, n_f2, f_s, f_s),
poolsize=(4, 4),
activation_fn=ReLU)
layer4 = FullyConnectedLayer(n_in=n_f3 * po3 * po3,
n_out=1000,
activation_fn=ReLU,
p_dropout=0.0)
layer5 = FullyConnectedLayer(n_in=1000,
n_out=500,
activation_fn=ReLU,
p_dropout=0.0)
layer6 = SoftmaxLayer(n_in=500, n_out=2, p_dropout=0.0)
net = Network([layer1, layer2, layer3, layer4, layer5, layer6],
mini_batch_size)
net.SGD(training_data,
10,
mini_batch_size,
0.001,
validation_data,
test_data,
lmbda=0.0)
def digit_recognize_test():
#载入数据
train = pd.read_csv('../../input/train.csv').sample(20000)
print('train: ' + str(train.shape))
test = pd.read_csv('../../input/test.csv')
print('test: ' + str(test.shape))
train.head()
#train: (2000, 785)
#test: (28000, 784)
# feature matrix
X = train.ix[:, 1:]
# response vector
X = X.values
Y = train['label']
Y = Y.values
#训练数据
training_inputs = [x for x in X]
training_results = [y for y in Y]
training_data = [training_inputs[:10000], training_results[:10000]]
validation_data = [training_inputs[10000:], training_results[10000:]]
print(np.shape(training_results))
#测试数据
test_data = test.values
#predit_inputs = [np.reshape(x, (784, 1)) for x in test_data]
training_data = shared(training_data)
validation_data = shared(validation_data)
test_data = theano.shared(np.asarray(test_data,
dtype=theano.config.floatX),
borrow=True)
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)
predictions = net.SGD_kaggle(training_data, 20, mini_batch_size, 0.1,
validation_data, test_data)
####尚未解决
#输出数据
digit_preds = pd.Series(predictions)
image_ids = pd.Series(np.arange(1, len(digit_preds) + 1))
submission = pd.DataFrame([image_ids, digit_preds]).T
submission.columns = ['ImageId', 'Label']
submission.to_csv('../../output/dr_result.csv', index=False, header=True)
print("finished!")
def shallow(n=3, epochs=60):
nets = []
for j in range(n):
print("A shallow net with 100 hidden neurons")
net = Network([
FullyConnectedLayer(n_in=784, n_out=100),
SoftmaxLayer(n_in=100, n_out=10)
], mini_batch_size)
net.SGD(training_data, epochs, mini_batch_size, 0.1, validation_data,
test_data)
nets.append(net)
return nets
def basic_conv(n=3, epochs=60):
for j in range(n):
print "Conv + FC architecture"
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)
net.SGD(
training_data, epochs, mini_batch_size, 0.1, validation_data, test_data)
return net
def test_conv(mini_batch_size):
nets = []
net = Network(
[
# Layer 0
# 1 Input image of size = 100 x 100
# 20 Filters of size = 5 x 5
# poolsize = 2 x 2 ( stride length 2)
# output of layer 0 = 20 feature Images of size 48 x 48
ConvPoolLayer(input_shape=(mini_batch_size, 1, 224, 224),
filter_shape=(64, 1, 3, 3),
poolsize=(2, 2),
activation_fn=ReLU),
# Layer 1
# 20 Input images of size = 48 x 48
# 40 Filters of size = 5 x 5
# poolsize = 2 x 2 ( stride length = 2)
# output of layer 1 = 40 feature Images of size 22 x 22
ConvPoolLayer(input_shape=(mini_batch_size, 64, 112, 112),
filter_shape=(128, 64, 3, 3),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(input_shape=(mini_batch_size, 128, 56, 56),
filter_shape=(256, 128, 3, 3),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(input_shape=(mini_batch_size, 256, 28, 28),
filter_shape=(512, 256, 3, 3),
poolsize=(2, 2),
activation_fn=ReLU),
ConvPoolLayer(input_shape=(mini_batch_size, 512, 14, 14),
filter_shape=(512, 512, 3, 3),
poolsize=(2, 2),
activation_fn=ReLU),
# Layer 2
FullyConnectedLayer(n_in=512 * 7 * 7,
n_out=4096,
activation_fn=ReLU,
p_dropout=0.0),
FullyConnectedLayer(
n_in=4096, n_out=1000, activation_fn=ReLU, p_dropout=0.0),
SoftmaxLayer(n_in=1000, n_out=2, p_dropout=0.0)
],
mini_batch_size)
# End of Network Architecture
net.SGD(training_data, 10, mini_batch_size, 0.01, validation_data,
test_data)
nets.append(net)
return nets
def basic_softmax_NN():
mini_batch_size = 10
train_data, val_data, test_data = go_parser.parse_games(1000,
test_percent=0.2,
val_percent=0.2,
onehot=False)
net = Network(
[
# FullyConnectedLayer(n_in=361, n_out=200),
SoftmaxLayer(n_in=361, n_out=361)
],
mini_batch_size)
net.SGD(shared(train_data), 50, mini_batch_size, 0.1, shared(val_data),
shared(test_data))
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 dbl_conv(activation_fn=sigmoid):
for j in range(3):
print "Conv + Conv + FC architecture"
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2),
activation_fn=activation_fn),
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
filter_shape=(40, 20, 5, 5),
poolsize=(2, 2),
activation_fn=activation_fn),
FullyConnectedLayer(
n_in=40*4*4, n_out=100, activation_fn=activation_fn),
SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size)
net.SGD(training_data, 60, mini_batch_size, 0.1, validation_data, test_data)
return net
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 test_ding(mini_batch_size):
size = 32
f_s = 5
padding = 1
conv_stride = 1
pool_stride = 1
pool_size = 3
n_f1 = 20
n_f2 = 40
co1 = ((size - f_s + 2 * padding) / conv_stride) + 1
po1 = ((co1 - pool_size) / pool_stride) + 1
#print(po1)
co2 = ((po1 - f_s + 2 * padding) / conv_stride) + 1
po2 = ((co2 - pool_size) / pool_stride) + 1
#print(po2)
layer1 = ConvPoolLayer(input_shape=(mini_batch_size, 1, size, size),
filter_shape=(n_f1, 1, f_s, f_s),
poolsize=(pool_size, pool_size),
activation_fn=ReLU)
#layer2 = ConvPoolLayer(input_shape=(mini_batch_size, n_f1, po1 , po1),
# filter_shape=(n_f2, n_f1, f_s, f_s),
# poolsize=(pool_size, pool_size),
# activation_fn=ReLU)
layer3 = FullyConnectedLayer(n_in=n_f1 * po1 * po1,
n_out=500,
activation_fn=ReLU,
p_dropout=0.0)
layer4 = SoftmaxLayer(n_in=500, n_out=2, p_dropout=0.0)
net = Network([layer1, layer3, layer4], mini_batch_size)
net.SGD(training_data,
50,
mini_batch_size,
0.3,
validation_data,
training_data,
lmbda=0.0)
def test_small(mini_batch_size):
size = 100
f_s = 5
padding = 1
conv_stride = 1
pool_stride = 1
pool_size = 3
n_f1 = 30
n_f2 = 60
co1 = ((size - f_s + 2 * padding) / conv_stride) + 1
po1 = ((co1 - pool_size) / pool_stride) + 1
co2 = ((po1 - f_s + 2 * padding) / conv_stride) + 1
po2 = ((co2 - pool_size) / pool_stride) + 1
net = Network([
ConvPoolLayer(input_shape=(mini_batch_size, 1, size, size),
filter_shape=(n_f1, 1, f_s, f_s),
poolsize=(pool_size, pool_size),
activation_fn=ReLU),
ConvPoolLayer(input_shape=(mini_batch_size, n_f1, po1, po1),
filter_shape=(n_f2, n_f1, f_s, f_s),
poolsize=(pool_size, pool_size),
activation_fn=ReLU),
FullyConnectedLayer(n_in=n_f2 * po2 * po2,
n_out=100,
activation_fn=ReLU,
p_dropout=0.0),
SoftmaxLayer(n_in=100, n_out=2, p_dropout=0.0)
], mini_batch_size)
net.SGD(training_data,
100,
mini_batch_size,
0.01,
validation_data,
test_data,
lmbda=0.0)
f = open('../data/network.cnn', 'wb')
cPickle.dump(net, f, protocol=2)
f.close()
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_digit(mini_batch_size):
size = 100
f_s = 10
padding = 1
conv_stride = 1
pool_stride = 1
pool_size = 5
n_f1 = 25
n_f2 = 50
co1 = ((size - f_s + 2 * padding) / conv_stride) + 1
po1 = ((co1 - pool_size) / pool_stride) + 1
co2 = ((po1 - f_s + 2 * padding) / conv_stride) + 1
po2 = ((co2 - pool_size) / pool_stride) + 1
net = Network(
[
ConvPoolLayer(input_shape=(mini_batch_size, 1, size, size),
filter_shape=(n_f1, 1, f_s, f_s),
poolsize=(pool_size, pool_size),
activation_fn=ReLU),
ConvPoolLayer(input_shape=(mini_batch_size, n_f1, po1, po1),
filter_shape=(n_f2, n_f1, f_s, f_s),
poolsize=(pool_size, pool_size),
activation_fn=ReLU),
FullyConnectedLayer(n_in=n_f2 * po2 * po2,
n_out=500,
activation_fn=ReLU,
p_dropout=0.0),
#FullyConnectedLayer(n_in=1000, n_out=1000, activation_fn=ReLU, p_dropout=0.0),
SoftmaxLayer(n_in=500, n_out=2, p_dropout=0.0)
],
mini_batch_size)
net.SGD(training_data,
100,
mini_batch_size,
0.01,
validation_data,
test_data,
lmbda=0.0)
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 test_basic(mini_batch_size):
nets = []
net = Network(
[
ConvPoolLayer(input_shape=(mini_batch_size, 1, 224, 224),
filter_shape=(64, 1, 3, 3),
poolsize=(2, 2),
activation_fn=ReLU),
# Layer 2
FullyConnectedLayer(
n_in=64 * 112 * 112, n_out=40, activation_fn=ReLU),
# Activation function
SoftmaxLayer(n_in=40, n_out=2)
],
mini_batch_size)
# End of Network Architecture
net.SGD(training_data, 10, mini_batch_size, 0.001, validation_data,
test_data)
nets.append(net)
return nets
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))
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,
test_data)
####Plot the weights of first layer
weights0 = np.load("/home/syrine92/Syrine_Belakaria/weights0.npy")
i = -1
fig, ax = plt.subplots(nrows=4, ncols=5)
for row in ax:
for col in row:
col.axes.get_xaxis().set_visible(False)
col.axes.get_yaxis().set_visible(False)
i = i + 1
col.imshow(weights0[i][0], cmap='Greys')
fig.savefig('/home/syrine92/Syrine_Belakaria/weights0.png')
####Plot the weights of second layer
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([
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)
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([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
filter_shape=(20, 1, 5, 5),
poolsize=(2, 2),
activation_fn=network3.tanh),
FullyConnectedLayer(
n_in=20 * 12 * 12, n_out=100, activation_fn=network3.tanh),
SoftmaxLayer(n_in=100, n_out=10)
], mini_batch_size)
net.SGD(training_data, 60, mini_batch_size, 0.1, validation_data, test_data)
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)
# 导入网络类和mnist数据集
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()
# expanded_training_data, _, _ = network3.load_data_sharaed("../data/mnist_expanded.pkl.gz")
mini_batch_size = 10
# 使用卷积网络优化分类问题
# 测试1，仅适用一个隐藏层，包含100个隐藏层神经元，小批量数据大小为10，
# 60次迭代期，学习速率为0.1
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)
# 测试2，使用一个卷积层，使用5*5局部感受野，20个特征映射，2*2混合窗口，一个全连接隐藏层
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)
net.SGD(training_data, 60, mini_batch_size, 0.1, validation_data, test_data)
# 测试3，使用两个卷积层，均为5*5局部感受野，20个特征映射，2*2混合窗口，一个全连接隐藏层
net = Network([
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
