def setUpClass(cls):
n_data = 10
img_dim = 20
train_data = load_batch("cifar-10-batches-py/data_batch_1")
cls.X_mat = train_data["pixel_data"][:img_dim, :n_data]
cls.Y_mat = conv_y_to_onehot_mat(train_data["labels"])[:, :n_data]
cls.dtype = np.float64
cls.in_dim = cls.X_mat.shape[0]
cls.out_dim = cls.Y_mat.shape[0]
def setUpClass(cls):
n_data = 100
train_data = load_batch("cifar-10-batches-py/data_batch_1")
cls.train_img = train_data["pixel_data"][:, :n_data].T
cls.train_labels = train_data["labels"][:n_data]
cls.params = {
"n_epochs": 500,
"lambda_": 0,
"verbose": False,
"lrate_scheme": {
"scheme": "cyclic",
"eta_lim": [1e-5, 1e-1],
"step_size": 500
}
}
def setUpClass(cls):
d = 20
m = 15
k = 10
n = 5
dtype = 'float64'
cls.W_mat1 = np.random.randn(m, d).astype(dtype) * np.sqrt(1.0 / d)
cls.W_mat2 = np.random.randn(k, m).astype(dtype) * np.sqrt(1.0 / m)
cls.b_vec1 = np.random.randn(m, 1).astype(dtype)
cls.b_vec2 = np.random.randn(k, 1).astype(dtype)
train_data = load_batch("cifar-10-batches-py/data_batch_1")
X_mat = train_data["pixel_data"][:d, :n]
cls.X_mat = normalize_data(X_mat)['normalized'].astype(dtype)
one_hot_mat = get_label_to_one_hot(train_data["labels"])
cls.Y_mat = one_hot_mat[:k, :n].astype(dtype)
"""
For Assignment 1:
"""
from utils.load_batch import load_batch
from clsr.one_layer_network import OneLayerNetwork
from time import time
if __name__ == '__main__':
# load data
train_data = load_batch("cifar-10-batches-py/data_batch_1")
valid_data = load_batch("cifar-10-batches-py/data_batch_2")
test_data = load_batch("cifar-10-batches-py/test_batch")
ann = OneLayerNetwork()
ann.set_valid_data(valid_data["pixel_data"].T, valid_data["labels"])
# training time
st = time()
ann.fit(train_data["pixel_data"].T, train_data["labels"])
ts = time() - st
print("Total used time = ", ts)
score = ann.score(test_data["pixel_data"].T, test_data["labels"])
print("Accuracy: {}".format(score))
2. The starting loss is around 2.24 and it is reasonable
3. Use the simplest scheduler i.e. StepLR
4. with / without batchnorm should behave the same
"""
import numpy as np
from utils.load_batch import cifar10_DataLoader
from utils.load_batch import load_batch
from utils.handle_data import data_split
from utils import train
from utils.lrate import StepLR
from utils.lrate import CyclicLR
from clsr.nn_kl import KLayerNeuralNetwork
from utils.preprocess import StandardScaler
if __name__ == "__main__":
train_data = load_batch("cifar-10-batches-py/data_batch_1")
net = KLayerNeuralNetwork(n_hidden_nodes=[50, 50],
p_dropout=0.0,
batch_norm=False,
batch_norm_momentum=.9)
scaler = StandardScaler()
scaler.fit(train_data['pixel_data'])
train_data['pixel_data'] = scaler.transform(train_data['pixel_data'])
batch_size = 100
train_loader = cifar10_DataLoader(train_data,
batch_size=batch_size,
shuffle=False)
ntrain = train_data['labels'].shape[0]
from clsr.two_layer_network import TwoLayerNetwork
from utils.load_batch import load_batch
from utils.handle_data import data_split
if __name__ == "__main__":
# settings
n_cycle = 3 # will overshot when too much cycles
k = 3
# lambda_ = 0.000142
# lambda_ = 0.005
lambda_ = 0.004454
# ===============================================================
# READ DATA
merged_data = get_all_train_data("cifar-10-batches-py")
train_data, valid_data = data_split(merged_data, n_valid=1000)
test_data = load_batch("cifar-10-batches-py/test_batch")
# ===============================================================
n_train_data = len(train_data['labels'])
n_batch = 100
n_s = int(k * np.floor(n_train_data / n_batch))
n_iters = 2 * n_s * n_cycle
n_epochs = int(n_iters * n_batch / n_train_data)
# ======================================================
params = {
"n_epochs": n_epochs,
"n_batch": n_batch,
"verbose": True,
"lambda_": lambda_,
"record_training": True,
"lrate_scheme": {
"scheme": "cyclic",
