def __init__(self):
self.layers = [
layers.FC(28 * 28, 2048),
layers.ReLu(),
layers.FC(2048, 10)
]
self.outputs = []
def __init__(self,
dimhid=100,
dimout=10,
weight_init_std=0.01,
imgsize=28):
strid = 1
pad = 0
fitsize = 3
cout = 30
cin = 1
self.layers = OrderedDict()
self.layers['conv'] = layers.conv(cin,
cout,
fitsize,
strid=strid,
pading=pad)
self.layers['relu1'] = layers.Relu()
self.layers['Pool1'] = layers.Pooling(pool_h=2, pool_w=2, stride=2)
con_out_size = (imgsize - fitsize + 2 * pad) / strid + 1
dimin = int(cout * (con_out_size / 2) * (con_out_size / 2))
self.layers['fc1'] = layers.FC(dimin, dimhid)
self.layers['relu2'] = layers.Relu()
self.layers['fc2'] = layers.FC(dimhid, dimout)
self.softmax = layers.SoftmaxWithLoss()
weight_decay = config['weight_decay']
net = []
regularizers = []
inputs = np.random.randn(config['batch_size'], 1, 28, 28)
net += [layers.Convolution(inputs, 16, 5, "conv1")]
regularizers += [
layers.L2Regularizer(net[-1].weights, weight_decay, 'conv1_l2reg')
]
net += [layers.MaxPooling(net[-1], "pool1")]
net += [layers.ReLU(net[-1], "relu1")]
net += [layers.Convolution(net[-1], 32, 5, "conv2")]
regularizers += [
layers.L2Regularizer(net[-1].weights, weight_decay, 'conv2_l2reg')
]
net += [layers.MaxPooling(net[-1], "pool2")]
net += [layers.ReLU(net[-1], "relu2")]
## 7x7
net += [layers.Flatten(net[-1], "flatten3")]
net += [layers.FC(net[-1], 512, "fc3")]
regularizers += [
layers.L2Regularizer(net[-1].weights, weight_decay, 'fc3_l2reg')
]
net += [layers.ReLU(net[-1], "relu3")]
net += [layers.FC(net[-1], 10, "logits")]
data_loss = layers.SoftmaxCrossEntropyWithLogits()
loss = layers.RegularizedLoss(data_loss, regularizers)
nn.train(train_x, train_y, valid_x, valid_y, net, loss, config)
nn.evaluate("Test", test_x, test_y, net, loss, config)
grad_out = np.random.randn(5, 4, 4, 4)
pool = layers.MaxPooling(x, "pool", 2, 2)
print("Check grad wrt input")
check_grad_inputs(pool, x, grad_out)
print("\nReLU")
x = np.random.randn(4, 3, 5, 5)
grad_out = np.random.randn(4, 3, 5, 5)
relu = layers.ReLU(x, "relu")
print("Check grad wrt input")
check_grad_inputs(relu, x, grad_out)
print("\nFC")
x = np.random.randn(20, 40)
grad_out = np.random.randn(20, 30)
fc = layers.FC(x, 30, "fc")
print("Check grad wrt input")
check_grad_inputs(fc, x, grad_out)
print("Check grad wrt params")
check_grad_params(fc, x, fc.weights, fc.bias, grad_out)
print("\nSoftmaxCrossEntropyWithLogits")
x = np.random.randn(50, 20)
y = np.zeros([50, 20])
y[:, 0] = 1
loss = layers.SoftmaxCrossEntropyWithLogits()
grad_x_num = eval_numerical_gradient(lambda x: loss.forward(x, y), x, 1)
out = loss.forward(x, y)
grad_x = loss.backward_inputs(x, y)
print("Relative error = ", rel_error(grad_x_num, grad_x))
print("Error norm = ", np.linalg.norm(grad_x_num - grad_x))
def __init__(self, dimin, dimhid, dimout, weight_init_std=0.01):
self.layers = OrderedDict()
self.layers['fc1'] = layers.FC(dimin, dimhid)
self.layers['relu'] = layers.Relu()
self.layers['fc2'] = layers.FC(dimhid, dimout)
self.softmax = layers.SoftmaxWithLoss()
output = data_group["output"]
for input_data in data_group["input"]:
x_data = []
for input_value in input_data:
x_data.append(input_value[0])
x_data.append(input_value[1])
train_x.append(x_data)
train_y.append(output)
train_x = np.array(train_x)
train_y = np.array(train_y)
net = []
inputs = np.random.randn(config['batch_size'], len(train_x))
net += [layers.FC(inputs, 50, "fc1")]
net += [layers.Sigmoid(net[-1], "sg1")]
net += [layers.FC(net[-1], 10, "fc2")]
net += [layers.Sigmoid(net[-1], "sg2")]
net += [layers.FC(net[-1], 5, "fc3")]
loss = layers.MeanSquareError()
nn.train(train_x, train_y, net, loss, config)
while True:
pointsFilename = input("Enter file name:")
with open(pointsFilename) as f:
points = json.load(f)
points = np.array(points).reshape(1, 100)
nn.evaluate(net, np.array(points))
