def main():
# loads, encodes and normalizes the dataset
X_train, y_train, X_test, y_test, N_class = load_data()
encoder = OneHotEncoder(sparse=True)
y_train = encoder.fit_transform(y_train.reshape(-1, 1)).toarray()
y_test = encoder.transform(y_test.reshape(-1, 1)).toarray()
X_train = normalize(X_train)
X_train, y_train = shuffle(X_train, y_train)
X_test = normalize(X_test)
X_test, X_validation, y_test, y_validation = train_test_split(
X_test, y_test, test_size=0.50, random_state=0)
# Convolutional neural network using 2 filters
nn = CNN(name="test",
imageWidth=100,
imageHeight=100,
hiddenSize=256,
outputSize=N_class,
filters=[(5, 5, 3, 20), (3, 3, 20, 50)],
poolSize=(2, 2),
learningRate=0.0001,
decay=0.99,
momentum=0.90)
nn.train(X_train,
y_train,
X_validation,
y_validation,
batchSize=128,
epochs=2)
count = 0
for i in range(len(X_test)):
j = nn.predictOne(X_test[i])
p = np.zeros(N_class)
p[j] = 1
if j != np.argmax(y_test[i]):
count += 1
plt.imshow(X_test[i])
plt.show()
print(encoder.inverse_transform([p]), ':',
encoder.inverse_transform([y_test[i]]))
print((len(X_test) - count) / len(X_test))
nn.close()
def main(argv=None):
try:
p = Pool(5) # process 5 images simultaneously
images_train, image_labels_train, images_val, image_labels_val = load_data(Constants.WORDS_FILE, p)
# Write the raw image files to images.tfrecords.
# First, process the two images into tf.Example messages.
# Then, write to a .tfrecords file.
record_file = Constants.TRAIN_TFRECORD
with tf.io.TFRecordWriter(record_file) as writer:
for i in range(len(images_train)):
tf_example = image_example(images_train[i], image_labels_train[i])
writer.write(tf_example.SerializeToString())
print("Successfully generated "+record_file)
record_file = Constants.VAL_TFRECORDS
with tf.io.TFRecordWriter(record_file) as writer:
for i in range(len(images_val)):
tf_example = image_example(images_val[i], image_labels_val[i])
writer.write(tf_example.SerializeToString())
print("Successfully generated "+record_file)
except:
raise
def main():
# loads, encodes and normalizes the dataset
X_train, y_train, X_test, y_test, N_class = load_data()
encoder = OneHotEncoder(sparse=True)
y_train = encoder.fit_transform(y_train.reshape(-1, 1)).toarray()
y_test = encoder.transform(y_test.reshape(-1, 1)).toarray()
X_train = normalize(X_train)
X_train, y_train = shuffle(X_train, y_train)
X_test = normalize(X_test)
X_test, X_validation, y_test, y_validation = train_test_split(X_test, y_test, test_size=0.50, random_state=0)
""" IN THIS SECTION WE COMPARE DIFFENT REGULARIZATIONS """
nn1 = CNN(
name="No_regularization",
imageWidth=100,
imageHeight=100,
hiddenSize=256,
outputSize=N_class,
filters=[(3, 3, 3, 20), (3, 3, 20, 50)],
poolSize=(2, 2),
initialization="xavier_glorot",
regularization="None"
)
cost1, accuracy1 = nn1.train(X_train, y_train, X_validation, y_validation, batchSize=128, epochs=20)
nn2 = CNN(
name="dropout_regularization",
imageWidth=100,
imageHeight=100,
hiddenSize=256,
outputSize=N_class,
filters=[(3, 3, 3, 20), (3, 3, 20, 50)],
poolSize=(2, 2),
initialization="xavier_glorot",
regularization="dropout"
)
cost2, accuracy2 = nn2.train(X_train, y_train, X_validation, y_validation, batchSize=128, epochs=20)
nn3 = CNN(
name="l1_regularization",
imageWidth=100,
imageHeight=100,
hiddenSize=256,
outputSize=N_class,
filters=[(3, 3, 3, 20), (3, 3, 20, 50)],
poolSize=(2, 2),
initialization="xavier_glorot",
regularization="l1"
)
cost3, accuracy3 = nn3.train(X_train, y_train, X_validation, y_validation, batchSize=128, epochs=20)
nn4 = CNN(
name="l2_regularization",
imageWidth=100,
imageHeight=100,
hiddenSize=256,
outputSize=N_class,
filters=[(3, 3, 3, 20), (3, 3, 20, 50)],
poolSize=(2, 2),
initialization="xavier_glorot",
regularization="l2"
)
cost4, accuracy4 = nn4.train(X_train, y_train, X_validation, y_validation, batchSize=128, epochs=20)
plt.xlabel("Epochs")
plt.ylabel("Cost")
plt.plot(cost1, label='None')
plt.plot(cost2, label='dropout')
plt.plot(cost3, label='l1')
plt.plot(cost4, label='l2')
plt.legend(loc='upper left')
plt.show()
plt.xlabel("Epochs")
plt.ylabel("Validation Accuracy")
plt.plot(accuracy1, label='None')
plt.plot(accuracy2, label='dropout')
plt.plot(accuracy3, label='l1')
plt.plot(accuracy4, label='l2')
plt.legend(loc='upper left')
plt.show()
count1=np.zeros((4,4),dtype=int)
count2=np.zeros((4,4),dtype=int)
count3=np.zeros((4,4),dtype=int)
count4=np.zeros((4,4),dtype=int)
for i in range(len(X_test)):
k = np.argmax(y_test[i])
j1 = nn1.predictOne(X_test[i])
j2 = nn2.predictOne(X_test[i])
j3 = nn3.predictOne(X_test[i])
j4 = nn4.predictOne(X_test[i])
if j1!=k:
count1[k][j1] += 1
if j2!=k:
count2[k][j2] += 1
if j3!=k:
count3[k][j3] += 1
if j4!=k:
count4[k][j4] += 1
for i in range(N_class):
p = np.zeros(N_class)
p[i] = 1
print(i,':',encoder.inverse_transform([p]))
print("Test phase")
print("------")
print("None:")
print("mistakes")
print(count1)
print("Test accuracy:",(len(X_test)-np.sum(count1))/len(X_test))
print("------")
print("dropout:")
print("mistakes")
print(count2)
print("Test accuracy:",(len(X_test)-np.sum(count2))/len(X_test))
print("------")
print("l1:")
print("mistakes")
print(count3)
print("Test accuracy:",(len(X_test)-np.sum(count3))/len(X_test))
print("------")
print("l2:")
print("mistakes")
print(count4)
print("Test accuracy:",(len(X_test)-np.sum(count4))/len(X_test))
def main():
# loads, encodes and normalizes the dataset
X_train, y_train, X_test, y_test, N_class = load_data()
encoder = OneHotEncoder(sparse=True)
y_train = encoder.fit_transform(y_train.reshape(-1, 1)).toarray()
y_test = encoder.transform(y_test.reshape(-1, 1)).toarray()
X_train = normalize(X_train)
X_train, y_train = shuffle(X_train, y_train)
X_test = normalize(X_test)
X_test, X_validation, y_test, y_validation = train_test_split(X_test, y_test, test_size=0.50, random_state=0)
# Convolutional neural network using 2 filters
nn = CNN(
name="test",
imageWidth=100,
imageHeight=100,
hiddenSize=256,
outputSize=N_class,
filters=[(12, 12, 3, 20), (12, 12, 20, 50)],
poolSize=(2,2),
initialization="xavier_glorot",
regularization="l2"
)
cost, accuracy = nn.train(X_train, y_train, X_validation, y_validation, batchSize=128, epochs=9)
plt.xlabel("Epochs")
plt.ylabel("Cost")
plt.plot(cost)
plt.show()
plt.xlabel("Epochs")
plt.ylabel("Validation Accuracy")
plt.plot(accuracy)
plt.show()
count=np.zeros((4,4),dtype=int)
for i in range(len(X_test)):
k = np.argmax(y_test[i])
j = nn.predictOne(X_test[i])
if j!=k:
count[k][j] += 1
#To turn on output of individual images misclassified simply change to true
if False:
p = np.zeros(N_class)
p[j] = 1
print("This picture should be classed as ",encoder.inverse_transform([y_test[i]]))
plt.imshow(X_test[i])
plt.show()
print("It has instead been classified as ",encoder.inverse_transform([p]))
for i in range(N_class):
p = np.zeros(N_class)
p[i] = 1
print(i,':',encoder.inverse_transform([p]))
print("Test phase")
print("mistakes")
print(count)
print("Test accuracy:",(len(X_test)-np.sum(count))/len(X_test))
nn.close()
def main():
# loads, encodes and normalizes the dataset
X_train, y_train, X_test, y_test, N_class = load_data()
encoder = OneHotEncoder(sparse=True)
y_train = encoder.fit_transform(y_train.reshape(-1, 1)).toarray()
y_test = encoder.transform(y_test.reshape(-1, 1)).toarray()
X_train = normalize(X_train)
X_train, y_train = shuffle(X_train, y_train)
X_test = normalize(X_test)
X_test, X_validation, y_test, y_validation = train_test_split(
X_test, y_test, test_size=0.50, random_state=0)
""" IN THIS SECTION WE COMPARE DIFFENT FILTER SIZES """
# 3x3 filters
nn3 = CNN(name="small_filter_size",
imageWidth=100,
imageHeight=100,
hiddenSize=256,
outputSize=N_class,
filters=[(3, 3, 3, 20), (3, 3, 20, 50)],
poolSize=(2, 2),
initialization="xavier_glorot",
regularization="dropout")
cost3, accuracy3 = nn3.train(X_train,
y_train,
X_validation,
y_validation,
batchSize=128,
epochs=20)
# 6X6 filters
nn6 = CNN(name="medium_filter_size",
imageWidth=100,
imageHeight=100,
hiddenSize=256,
outputSize=N_class,
filters=[(6, 6, 3, 20), (6, 6, 20, 50)],
poolSize=(2, 2),
initialization="xavier_glorot",
regularization="dropout")
cost6, accuracy6 = nn6.train(X_train,
y_train,
X_validation,
y_validation,
batchSize=128,
epochs=20)
# 12x12 filters
nn12 = CNN(name="large_filter_size",
imageWidth=100,
imageHeight=100,
hiddenSize=256,
outputSize=N_class,
filters=[(12, 12, 3, 20), (12, 12, 20, 50)],
poolSize=(2, 2),
initialization="xavier_glorot",
regularization="dropout")
cost12, accuracy12 = nn12.train(X_train,
y_train,
X_validation,
y_validation,
batchSize=128,
epochs=20)
plt.xlabel("Epochs")
plt.ylabel("Cost")
plt.plot(cost3, label='3')
plt.plot(cost6, label='6')
plt.plot(cost12, label='12')
plt.legend(loc='upper left')
plt.show()
plt.xlabel("Epochs")
plt.ylabel("Validation Accuracy")
plt.plot(accuracy3, label='3')
plt.plot(accuracy6, label='6')
plt.plot(accuracy12, label='12')
plt.legend(loc='upper left')
plt.show()
count3 = np.zeros((4, 4), dtype=int)
count6 = np.zeros((4, 4), dtype=int)
count12 = np.zeros((4, 4), dtype=int)
for i in range(len(X_test)):
k = np.argmax(y_test[i])
j3 = nn3.predictOne(X_test[i])
j6 = nn6.predictOne(X_test[i])
j12 = nn12.predictOne(X_test[i])
if j3 != k:
count3[k][j3] += 1
if j6 != k:
count6[k][j6] += 1
if j12 != k:
count12[k][j12] += 1
for i in range(N_class):
p = np.zeros(N_class)
p[i] = 1
print(i, ':', encoder.inverse_transform([p]))
print("Test phase")
print("------")
print("3:")
print("mistakes")
print(count3)
print("Test accuracy:", (len(X_test) - np.sum(count3)) / len(X_test))
print("------")
print("6:")
print("mistakes")
print(count6)
print("Test accuracy:", (len(X_test) - np.sum(count6)) / len(X_test))
print("------")
print("12:")
print("mistakes")
print(count12)
print("Test accuracy:", (len(X_test) - np.sum(count12)) / len(X_test))
def main():
X_train, y_train, X_test, y_test, N_class = load_data()
img_width = X_train.shape[1]
img_height = X_train.shape[1]
img_size = img_width * img_height
# Encode targets
encoder = OneHotEncoder(sparse=True)
y_train = encoder.fit_transform(y_train.reshape(-1, 1)).toarray()
y_test = encoder.transform(y_test.reshape(-1, 1)).toarray()
# Need to scale! don't leave as 0..255
# Also need indicator matrix for cost calculation
X_train = normalize(X_train)
X_train, y_train = shuffle(X_train, y_train)
X_test = normalize(X_test)
# gradient descent params
max_iter = 6
print_period = 10
N = X_train.shape[0]
batch_sz = 128
n_batches = N // batch_sz
# initial weights
M = 256
K = N_class
W1_shape = (
5, 5, 3, 20
) # (filter_width, filter_height, num_color_channels, num_feature_maps)
W1_init = init_filter(W1_shape)
b1_init = np.zeros(W1_shape[-1],
dtype=np.float32) # one bias per output feature map
W2_shape = (
5, 5, 20, 50
) # (filter_width, filter_height, old_num_feature_maps, num_feature_maps)
W2_init = init_filter(W2_shape)
b2_init = np.zeros(W2_shape[-1], dtype=np.float32)
# vanilla ANN weights
W3_init = np.random.randn(W2_shape[-1] * 25 * 25,
M) / np.sqrt(W2_shape[-1] * 25 * 25 + M)
b3_init = np.zeros(M, dtype=np.float32)
W4_init = np.random.randn(M, K) / np.sqrt(M + K)
b4_init = np.zeros(K, dtype=np.float32)
# define variables and expressions
# using None as the first shape element takes up too much RAM unfortunately
X = tf.placeholder(tf.float32,
shape=(None, img_width, img_height, 3),
name='X')
T = tf.placeholder(tf.int32, shape=(None, N_class), name='T')
W1 = tf.Variable(W1_init.astype(np.float32))
b1 = tf.Variable(b1_init.astype(np.float32))
W2 = tf.Variable(W2_init.astype(np.float32))
b2 = tf.Variable(b2_init.astype(np.float32))
W3 = tf.Variable(W3_init.astype(np.float32))
b3 = tf.Variable(b3_init.astype(np.float32))
W4 = tf.Variable(W4_init.astype(np.float32))
b4 = tf.Variable(b4_init.astype(np.float32))
Z1 = convpool(X, W1, b1)
Z2 = convpool(Z1, W2, b2)
Z2_shape = Z2.get_shape().as_list()
Z2r = tf.reshape(Z2, [-1, np.prod(Z2_shape[1:])])
Z3 = tf.nn.relu(tf.matmul(Z2r, W3) + b3)
Yish = tf.matmul(Z3, W4) + b4
cost = tf.reduce_sum(
tf.nn.softmax_cross_entropy_with_logits_v2(logits=Yish, labels=T))
train_op = tf.train.RMSPropOptimizer(0.0001, decay=0.99,
momentum=0.9).minimize(cost)
# we'll use this to calculate the error rate
predict_op = tf.argmax(Yish, 1)
t0 = datetime.now()
LL = []
W1_val = None
W2_val = None
init = tf.global_variables_initializer()
with tf.Session() as session:
session.run(init)
error = []
accuracy = []
for i in range(max_iter):
epochErr = 0
for j in range(n_batches):
print("\rEpoch " + str(i + 1) + " of " + str(max_iter) +
" | Training batch " + str(j + 1) + " of " +
str(n_batches),
end="")
Xbatch = X_train[j * batch_sz:(j * batch_sz + batch_sz), ]
Ybatch = y_train[j * batch_sz:(j * batch_sz + batch_sz), ]
session.run(train_op, feed_dict={X: Xbatch, T: Ybatch})
epochErr += session.run(cost, feed_dict={X: Xbatch, T: Ybatch})
# after one epoch calculates the accuracy
testSucc = 0
testAcc = 0
for k in range(0, len(y_test) // batch_sz):
Xbatch = X_test[k * batch_sz:(k + 1) * batch_sz, ]
Ybatch = y_test[k * batch_sz:(k + 1) * batch_sz, ]
prediction = session.run(predict_op,
feed_dict={
X: Xbatch,
T: Ybatch
})
testSucc += np.sum(prediction == np.argmax(Ybatch))
testAcc = testSucc / len(y_test)
error.append(epochErr)
accuracy.append(testAcc)
print(" | Epoch error: {0:.0f}".format(epochErr) +
" | Accuracy: {0:.2f}".format(testAcc))
W1_val = W1.eval()
W2_val = W2.eval()
print("Elapsed time:", (datetime.now() - t0))
# plt.plot(LL)
# plt.show()
print(error)