def test_forward_backward(self):
l = ReluLayer()
y = l.forward(np.array([5, 5]))
self.assertEqual(y.shape, (2, ))
assert_almost_equal(y, np.array([5, 5]))
x = np.random.rand(2)
d = l.backward(x)
self.assertEqual(d.shape, (2, ))
assert_almost_equal(d, np.array(x), decimal=5)
return
class cnn(object):
class simple_cnn_model(object):
def __init__(self, epochs, batch_size, lr):
self.epochs = epochs
self.batch_size = batch_size
self.lr = lr
def load_data(self):
# load data from cifar100 folder
(x_train, y_train), (x_test, y_test) = cifar100(1211506319)
return x_train, y_train, x_test, y_test
def train_model(self, layers, loss_metrics, x_train, y_train):
# build model
self.model = Sequential(layers, loss_metrics)
# train the model
loss = self.model.fit(x_train,
y_train,
self.epochs,
self.lr,
self.batch_size,
print_output=True)
avg_loss = np.mean(np.reshape(loss, (self.epochs, -1)), axis=1)
return avg_loss
def test_model(self, x_test, y_test):
# make a prediction
pred_result = self.model.predict(x_test)
accuracy = np.mean(pred_result == y_test)
return accuracy
if __name__ == '__main__':
# define model parameters
epochs = 15
batch_size = 128
lr = [.1]
# define layers
layers = (ConvLayer(3, 16, 3), ReluLayer(), MaxPoolLayer(),
ConvLayer(16, 32, 3), ReluLayer(), MaxPoolLayer(),
FlattenLayer(), FullLayer(2048, 4), SoftMaxLayer())
loss_matrics = CrossEntropyLayer()
# build and train model
model = simple_cnn_model(epochs, batch_size, lr)
x_train, y_train, x_test, y_test = model.load_data()
loss = model.train_model(layers, loss_matrics, x_train, y_train)
accuracy = model.test_model(x_test, y_test)
print("loss: %s" % loss)
print("The accuracy of the model is %s" % accuracy)
def test_numeric_gradient(self):
l = ReluLayer()
x = np.random.rand(2)
gradient = l.numeric_gradient(x)
l.forward(x)
delta = l.backward([1, 1])
assert_almost_equal(np.diag(gradient), delta, decimal=5)
import numpy as np
import matplotlib.pyplot as plt
from layers import (FullLayer, ReluLayer, SoftMaxLayer, CrossEntropyLayer)
from layers.sequential import Sequential
from layers.dataset import cifar100
(x_train, y_train), (x_test, y_test) = cifar100(1213268041)
test_accuracy=[]
epochs=20
lr=[0.1, 0.01, 0.2]
for i in lr:
model = Sequential(layers=(FullLayer(32 * 32 * 3, 2500),
ReluLayer(),
FullLayer(2500, 2000),
ReluLayer(),
FullLayer(2000, 1500),
ReluLayer(),
FullLayer(1500, 1000),
ReluLayer(),
FullLayer(1000, 500),
ReluLayer(),
FullLayer(500, 4),
SoftMaxLayer()),
loss=CrossEntropyLayer())
finalloss = model.fit(x_train, y_train,epochs=20, lr=i)
y_pred = model.predict(x_test)
accuracy=(np.mean(y_test == y_pred))
print('Accuracy: %.2f' % accuracy)
np.append(test_accuracy, accuracy)
plt.plot(range(epochs), finalloss, label=('Learning rate=',i))
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Sun Mar 25 19:52:43 2018
@author: kaushik
"""
import time
import numpy as np
import matplotlib.pyplot as plt
from layers.dataset import cifar100
from layers import (ConvLayer, FullLayer, FlattenLayer, MaxPoolLayer,
ReluLayer, SoftMaxLayer, CrossEntropyLayer, Sequential)
(x_train, y_train), (x_test, y_test) = cifar100(1337)
model = Sequential(layers=(ConvLayer(3, 16, 3), ReluLayer(), MaxPoolLayer(),
ConvLayer(16, 32, 3), ReluLayer(), MaxPoolLayer(),
FlattenLayer(), FullLayer(8 * 8 * 32,
4), SoftMaxLayer()),
loss=CrossEntropyLayer())
start_time = time.clock()
lr_vals = [0.1]
losses_train = list()
losses_test = list()
test_acc = np.zeros(len(lr_vals))
for j in range(len(lr_vals)):
train_loss, test_loss = model.fit(x_train,
y_train,
x_test,
y_test,
epochs=8,
import numpy as np
from layers.dataset import cifar100
# Please make sure that cifar-100-python is present in the same folder as dataset.py
(x_train, y_train), (x_test, y_test) = cifar100(1212356299)
from layers import (FullLayer, ReluLayer, SoftMaxLayer, CrossEntropyLayer,
Sequential_better)
model = Sequential_better(layers=(FullLayer(3072, 1500), ReluLayer(),
FullLayer(1500, 500), ReluLayer(),
FullLayer(500, 4), SoftMaxLayer()),
loss=CrossEntropyLayer())
loss2 = model.fit(x_train, y_train, lr=0.1, epochs=15)
y_predict = model.predict(x_test)
count = 0
for i in range(np.size(y_test)):
if y_predict[i] == y_test[i]:
count += 1
accuracy = (100.0 * count) / np.shape(y_predict)[0]
print "Accuracy of better CIFAR = ", accuracy, "%"
import numpy as np
from layers.dataset import cifar100
import matplotlib.pyplot as plt
# Please make sure that cifar-100-python is present in the same folder as dataset.py
(x_train, y_train), (x_test, y_test) = cifar100(1212356299)
from layers import (FullLayer, ReluLayer, SoftMaxLayer, CrossEntropyLayer,
Sequential)
model = Sequential(layers=(FullLayer(3072,
500), ReluLayer(), FullLayer(500, 4),
SoftMaxLayer()),
loss=CrossEntropyLayer())
lr_accuracies = np.zeros((3, ))
loss1 = model.fit(x_train, y_train, lr=0.01, epochs=15)
y_predict = model.predict(x_test)
count = 0
for i in range(np.size(y_test)):
if y_predict[i] == y_test[i]:
count += 1
lr_accuracies[0] = (100.0 * count) / np.shape(y_predict)[0]
loss2 = model.fit(x_train, y_train, lr=0.1, epochs=15)
y_predict = model.predict(x_test)