def taskXor():
XTrain, YTrain, XVal, YVal, XTest, YTest = loadXor()
# Create a NeuralNetwork object 'nn1' as follows with optimal parameters. For parameter definition#, refer to nn.py file.
nn1 = nn.NeuralNetwork(0.01, 10, 100)
# Add layers to neural network corresponding to inputs and outputs of given data
nn1.addLayer(nn.FullyConnectedLayer(XTrain.shape[1], 10, activation='relu'))
nn1.addLayer(nn.FullyConnectedLayer(10, YTrain.shape[1], activation='softmax'))
#print(XTrain.shape[1], YTrain.shape[1])
# Add layers to neural network corresponding to inputs and outputs of given data
# Eg. nn1.addLayer(FullyConnectedLayer(x,y))
###############################################
# TASK 3a (Marks 7) - YOUR CODE HERE
#raise NotImplementedError
###############################################
nn1.train(XTrain, YTrain, XVal, YVal)
pred, acc = nn1.validate(XTest, YTest)
with open("predictionsXor.csv", 'w') as file:
writer = csv.writer(file)
writer.writerow(["id", "prediction"])
for i, p in enumerate(pred):
writer.writerow([i, p])
print('Test Accuracy',acc)
return nn1
def test_forward_pass(self):
data_layer = nn.BatchDataLayer(self.train_data.inputs,
self.train_data.targets,
batch_size=64,
shuffle=False)
inputs, targets = next(data_layer.forward())
fc_layer = nn.FullyConnectedLayer(self.train_data.target_dim)
fc_layer.initialize(self.train_data.input_dim, batch_size=64)
outputs = fc_layer.forward(inputs)
def taskMnist():
XTrain, YTrain, XVal, YVal, XTest, _ = loadMnist()
# Create a NeuralNetwork object 'nn1' as follows with optimal parameters. For parameter definition, refer to nn.py file.
# nn1 = nn.NeuralNetwork(lr, batchSize, epochs)
# Add layers to neural network corresponding to inputs and outputs of given data
# Eg. nn1.addLayer(FullyConnectedLayer(x,y))
###############################################
# TASK 3b (Marks 13) - YOUR CODE HERE
nn1 = nn.NeuralNetwork(0.01, 1, 100)
nn1.addLayer(nn.FullyConnectedLayer(784,41, 'relu'))
nn1.addLayer(nn.FullyConnectedLayer(41,10, 'softmax'))
# raise NotImplementedError
###############################################
nn1.train(XTrain, YTrain, XVal, YVal)
pred, _ = nn1.validate(XTest, None)
with open("predictionsMnist.csv", 'w') as file:
writer = csv.writer(file)
writer.writerow(["id", "prediction"])
for i, p in enumerate(pred):
writer.writerow([i, p])
return nn1
def taskXor():
print("Training XOR...")
XTrain, YTrain, XVal, YVal, XTest, YTest = loadXor()
# Create a NeuralNetwork object 'nn1' as follows with optimal parameters. For parameter definition, refer to nn.py file.
nn1 = nn.NeuralNetwork(lr=0.005, batchSize=8, epochs=50)
# Add layers to neural network corresponding to inputs and outputs of given data
nn1.addLayer(nn.FullyConnectedLayer(2, 12, 'relu'))
#nn1.addLayer(nn.FullyConnectedLayer(12,64,'relu'))
nn1.addLayer(nn.FullyConnectedLayer(12, 2, 'softmax'))
###############################################
# TASK 3a (Marks 7) - YOUR CODE HERE
###############################################
nn1.train(XTrain, YTrain, XVal, YVal)
pred, acc = nn1.validate(XTest, YTest)
with open("predictionsXor.csv", 'w') as file:
writer = csv.writer(file)
writer.writerow(["id", "prediction"])
for i, p in enumerate(pred):
writer.writerow([i, p])
print('Test Accuracy', acc)
return nn1
def taskMnist():
print("Training: MNIST...")
XTrain, YTrain, XVal, YVal, XTest, _ = loadMnist()
# Create a NeuralNetwork object 'nn1' as follows with optimal parameters. For parameter definition, refer to nn.py file.
nn1 = nn.NeuralNetwork(lr=0.005, batchSize=8, epochs=50)
# Add layers to neural network corresponding to inputs and outputs of given data
nn1.addLayer(nn.FullyConnectedLayer(28 * 28, 256, 'relu'))
#nn1.addLayer(nn.FullyConnectedLayer(128,256,'relu'))
nn1.addLayer(nn.FullyConnectedLayer(256, 10, 'softmax'))
###############################################
# TASK 3b (Marks 13) - YOUR CODE HERE
###############################################
nn1.train(XTrain, YTrain, XVal, YVal)
pred, acc = nn1.validate(XVal, YVal)
print(acc)
pred, _ = nn1.validate(XTest, None)
with open("predictionsMnist.csv", 'w') as file:
writer = csv.writer(file)
writer.writerow(["id", "prediction"])
for i, p in enumerate(pred):
writer.writerow([i, p])
return nn1
def test_fully_connected_as_special_case(self):
filter_size = (self.train_data.image_width,
self.train_data.image_height)
stride = (1, 1)
pad = (0, 0)
num_filters = self.train_data.target_dim
# get a data batch
data_layer = nn.BatchDataLayer(self.train_data.inputs,
self.train_data.targets,
batch_size=64,
shuffle=False)
inputs, targets = next(data_layer.forward())
# forward pass
# get forward output of fully connected layer
np.random.seed(0)
fc_layer = nn.FullyConnectedLayer(self.train_data.target_dim,
scale=0.01)
fc_layer.initialize(self.train_data.input_dim, batch_size=64)
fc_outputs = fc_layer.forward(inputs)
# get forward output of convolutional layer
np.random.seed(0)
conv_layer = nn.ConvolutionalLayer(filter_size,
stride,
pad,
num_filters,
scale=0.01)
conv_layer.initialize(self.train_data.input_dim, batch_size=64)
conv_outputs = conv_layer.forward(inputs)
# compare forward outputs
np.testing.assert_array_equal(fc_layer.W, conv_layer.W)
np.testing.assert_array_equal(fc_layer.b, conv_layer.b)
np.testing.assert_array_equal(
inputs, conv_layer.input_rows.reshape(inputs.shape))
np.testing.assert_array_almost_equal(fc_outputs,
conv_outputs.reshape(
fc_outputs.shape),
decimal=10)
# dot_prod1 = np.dot(conv_layer.input_rows.reshape(inputs.shape), conv_layer.W)
# dot_prod2 = np.dot(conv_layer.input_rows, conv_layer.W)
# out1 = dot_prod1 + conv_layer.b
# out2 = (dot_prod2 + conv_layer.b).reshape(out1.shape)
# print(dot_prod1.shape)
# print(dot_prod2.shape)
# print(dot_prod1)
# print(dot_prod2)
# print(np.sum(np.abs(dot_prod1 - dot_prod2)))
# np.testing.assert_array_equal(dot_prod1, dot_prod2.reshape(dot_prod1.shape))
# np.testing.assert_array_equal(fc_outputs, out1)
# np.testing.assert_array_equal(fc_outputs, out2)
# backward pass
# get grad from loss layer
loss_layer = nn.CrossEntropyLayer()
loss_layer.forward(fc_outputs + 1.0, targets)
grad_out = loss_layer.backward()
# backward pass of fully connected layer
fc_grad = fc_layer.backward(grad_out)
# backward pass of convolutional layer
conv_grad = conv_layer.backward(grad_out)
# compare backward outputs
np.testing.assert_array_equal(fc_grad,
conv_grad.reshape(fc_grad.shape))
