import matplotlib.pyplot as plt
from cs231n.classifiers.cnn import *
from cs231n.data_utils import get_CIFAR10_data
from cs231n.gradient_check import eval_numerical_gradient_array, eval_numerical_gradient
from cs231n.layers import *
from cs231n.fast_layers import *
from cs231n.solver import Solver
data = get_CIFAR10_data()
from cs231n.classifiers.convnet import *
log = open("log.txt", "w")
for i in xrange(10):
lr = np.random.uniform(1e-2, 1e-5)
model = ConvNet(weight_scale=0.001, hidden_dim=500, reg=0.001, filter_size=3, num_filters=(16, 16, 16, 16))
print("lr: %e" % (lr))
solver = Solver(model, data,
num_epochs=2, batch_size=50,
update_rule="adam",
optim_config={"learning_rate":lr},
verbose=True, print_every=50)
solver.train()
acc = solver.check_accuracy(solver.X_val, solver.y_val)
log.write("lr: %e, acc: %f\n" % (lr, acc))
log.close()
bn_solver = Solver(bn_model,
data,
num_epochs=100,
batch_size=50,
update_rule='adam',
optim_config={
'learning_rate': 1e-3,
},
verbose=True,
print_every=200)
bn_solver.train()
################################################################################
# END OF YOUR CODE #
################################################################################
## Test you model
# Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set.
# In[]:
X_val, X_test, y_val, y_test = data['X_val'], data['X_test'], data[
'y_val'], data['y_test']
#y_test_pred = np.argmax(best_model.loss(X_test), axis=1)
#y_val_pred = np.argmax(best_model.loss(X_val), axis=1)
#print 'Validation set accuracy: ', (y_val_pred == y_val).mean()
#print 'Test set accuracy: ', (y_test_pred == y_test).mean()
val_acc = bn_solver.check_accuracy(X_val, y_val)
tst_acc = bn_solver.check_accuracy(X_test, y_test)
print 'Validation set accuracy: ', (val_acc)
print 'Test set accuracy: ', (tst_acc)
learning_rate = 10**np.random.uniform(low=-9,high=-6,size =20)
reg = np.random.uniform(low=0.4,high=0.9,size =20)
for lr in learning_rate:
for rg in reg:
# model = FullyConnectedNet([100, 100],
# weight_scale=weight_scale,reg=rg, dtype=np.float64,normalization="batchnorm",dropout = 0.5)
model = model_prev
solver = Solver(model,data,
print_every=10, num_epochs=num_epochs, batch_size=batch_size,
update_rule="rmsprop",verbose=False,
optim_config={
'learning_rate': lr,
}
)
solver.train()
result = solver.check_accuracy(X, y, num_samples=None, batch_size=65)
if result > acc:
acc = result
marker = "cs231n/data_record/lr_%f_end_rg_%f_end_acc_%f"%(lr,rg,acc)
solver.checkpoint_name = marker
solver._save_checkpoint()
print("\ntest accuracy = %f\n"%(acc))
print("\nlearning rate = %f\n"%(lr))
print("\nreg = %f\n"%(rg))
print("\n####################################################################################################################################\n")
print("\ntest 3 layer feedforward net: with dropouts and batchnormalization\n")
print("\n####################################################################################################################################\n")
if not test:
#state = np.random.get_state()
tic = time.time()
model = FullyConnectedNet(hidden_dims,
reg=reg,
weight_scale=5e-2,
dropout=p,
use_batchnorm=True)
solver = Solver(model,
data,
num_epochs=num_epoch,
batch_size=200,
update_rule="adam",
optim_config={'learning_rate': lr},
verbose=True)
solver.train()
val_acc = solver.check_accuracy(data["X_val"],
data["y_val"],
batch_size=200)
est_time = toc - tic
results[(hidden_dims, lr, reg, p)] = (val_acc, est_time)
if val_acc > best_val:
best_val = val_acc
best_model = model
print(
"best val accuracy : %f when lr: %2.e , reg: %.2f and p: %.2f"
% (val_acc, lr, reg, p))
pass
# Print out results.
for hidden_dims, lr, reg, p in sorted(results):
val_accuracy, est_time = results[(hidden_dims, lr, reg, p)]
[print(key, value.shape) for (key, value) in data.items()]
# In[4]:
cnn = ThreeLayerConvNet(reg=1e-3)
# In[5]:
solver = Solver(cnn,
data,
update_rule='adam',
optim_config={
'learning_rate': 1e-3,
},
lr_decay=0.95,
num_epochs=50,
batch_size=100,
print_every=100)
# In[6]:
solver.train()
# In[7]:
print(solver.check_accuracy(data['X_train'], data['y_train']))
print(solver.check_accuracy(data['X_test'], data['y_test']))
# In[ ]:
data = load_data()
checkpoint = pickle.load(open('RBM_epoch_10.pkl', 'rb'))
rbm_params = checkpoint['model']
model = TwoLayerNet(input_dim=28 * 28)
solver = Solver(model,
data,
update_rule='sgd',
optim_config={'learning_rate': 1e-3},
print_every=100,
lr_decay=0.9,
num_epochs=10,
batch_size=200)
solver.train()
solver.check_accuracy(data['X_test'], data['y_test'])
plot_solver(solver)
model = TwoLayerNet(input_dim=28 * 28)
model.params = rbm_params
solver = Solver(model,
data,
update_rule='sgd',
optim_config={'learning_rate': 1e-3},
print_every=100,
lr_decay=0.9,
num_epochs=10,
batch_size=200)
solver.train()
solver.check_accuracy(data['X_test'], data['y_test'])
plot_solver(solver)
data = get_CIFAR10_data()
for k, v in data.items():
print('{}: '.format(k), v.shape)
# set up model
model = ThreeLayerConvNet(hidden_dim=512, reg=0.001)
# encapsulate it into solver
solver = Solver(model,
data,
num_epochs=1,
batch_size=50,
update_rule='adam',
optim_config={
'learning_rate': 1e-3,
},
verbose=True,
print_every=50,
checkpoint_name="checkpoint/cnn")
solver.train()
solver.check_accuracy(data["X_test"], data["y_test"])
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111)
ax.set_xlabel("Iteration")
ax.set_ylabel("Loss")
ax.plot(solver.loss_history)
fig.savefig("fig/loss.pdf", format="pdf")
num_epochs=80, batch_size=32,
update_rule='adam',
lr_decay=0.99,
max_jitter=2,
flipOrNot=True,
h5_file='newcon',
optim_config={
'learning_rate': learning_rate,
#1e-4
'beta2': 0.99999,
},
verbose=True, print_every=1000)
solver.train()
#actrain = solver.check_accuracy(data['X_train'],data['y_train'])
acxval = solver.check_accuracy(data['X_val'], data['y_val'])
actest = solver.check_accuracy(data['X_test'], data['y_test'])
print learning_rate,regr
print acxval,actest
print
plt.subplot(2, 1, 1)
plt.plot(solver.loss_history, 'o',label=str(learning_rate) + ' ' + str(regr))
plt.xlabel('iteration')
plt.ylabel('loss')
plt.legend()
plt.subplot(2, 1, 2)
plt.plot(solver.train_acc_history, '-o',label='train:' + str(learning_rate) + ' ' + str(regr))
plt.plot(solver.val_acc_history, '-o',label='val:' + str(learning_rate) + ' ' + str(regr))
plt.legend(['train', 'val'], loc='upper left')
plt.xlabel('epoch')
