def main():
with DefaultScopeDevice(CPUDevice()):
pw1 = Parameter("w1", [8, 2], I.XavierUniform())
pb1 = Parameter("b1", [8], I.Constant(0))
pw2 = Parameter("w2", [1, 8], I.XavierUniform())
pb2 = Parameter("b2", [], I.Constant(0))
trainer = T.SGD(0.1)
trainer.add_parameter(pw1)
trainer.add_parameter(pb1)
trainer.add_parameter(pw2)
trainer.add_parameter(pb2)
input_data = np.array(
[
[1, 1], # Sample 1
[1, -1], # Sample 2
[-1, 1], # Sample 3
[-1, -1], # Sample 4
],
dtype=np.float32)
output_data = np.array(
[
1, # Label 1
-1, # Label 2
-1, # Label 3
1, # Label 4
],
dtype=np.float32)
for i in range(100):
g = Graph()
with DefaultScopeGraph(g):
# Builds a computation graph.
#x = F.input(shape=Shape([2], 4), data=input_data)
x = F.input(data=input_data)
w1 = F.input(param=pw1)
b1 = F.input(param=pb1)
w2 = F.input(param=pw2)
b2 = F.input(param=pb2)
h = F.tanh(F.matmul(w1, x) + b1)
y = F.matmul(w2, h) + b2
# Calculates values.
y_val = g.forward(y).to_list()
print("epoch ", i, ":")
for j in range(4):
print(" [", j, "]: ", y_val[j])
#t = F.input(shape=Shape([], 4), data=output_data)
t = F.input(data=output_data)
diff = t - y
loss = F.batch.mean(diff * diff)
loss_val = g.forward(loss).to_list()[0]
print(" loss: ", loss_val)
trainer.reset_gradients()
g.backward(loss)
trainer.update()
def main():
# Loads data
train_inputs = load_images("data/train-images-idx3-ubyte",
NUM_TRAIN_SAMPLES)
train_labels = load_labels("data/train-labels-idx1-ubyte",
NUM_TRAIN_SAMPLES)
test_inputs = load_images("data/t10k-images-idx3-ubyte", NUM_TEST_SAMPLES)
test_labels = load_labels("data/t10k-labels-idx1-ubyte", NUM_TEST_SAMPLES)
# Uses GPU.
#dev = CUDADevice(0)
with DefaultScopeDevice(CPUDevice()):
# Parameters for the multilayer perceptron.
pw1 = Parameter("w1", [NUM_HIDDEN_UNITS, NUM_INPUT_UNITS],
XavierUniform())
pb1 = Parameter("b1", [NUM_HIDDEN_UNITS], Constant(0))
pw2 = Parameter("w2", [NUM_OUTPUT_UNITS, NUM_HIDDEN_UNITS],
XavierUniform())
pb2 = Parameter("b2", [NUM_OUTPUT_UNITS], Constant(0))
# Parameters for batch normalization.
#Parameter pbeta("beta", {NUM_HIDDEN_UNITS}, Constant(0));
#Parameter pgamma("gamma", {NUM_HIDDEN_UNITS}, Constant(1));
# Trainer
trainer = SGD(.5)
trainer.add_parameter(pw1)
trainer.add_parameter(pb1)
trainer.add_parameter(pw2)
trainer.add_parameter(pb2)
#trainer.add_parameter(&pbeta);
#trainer.add_parameter(&pgamma);
# Helper lambda to construct the predictor network.
def make_graph(inputs, train):
# Stores input values.
x = F.input(data=inputs)
# Calculates the hidden layer.
w1 = F.input(param=pw1)
b1 = F.input(param=pb1)
h = F.relu(F.matmul(w1, x) + b1)
# Batch normalization
#Node beta = F::input(pbeta);
#Node gamma = F::input(pgamma);
#h = F::batch::normalize(h) * gamma + beta;
# Dropout
h = F.dropout(h, .5, train)
# Calculates the output layer.
w2 = F.input(param=pw2)
b2 = F.input(param=pb2)
return F.matmul(w2, h) + b2
ids = list(range(NUM_TRAIN_SAMPLES))
for epoch in range(MAX_EPOCH):
# Shuffles sample IDs.
random.shuffle(ids)
# Training loop
for batch in range(NUM_TRAIN_BATCHES):
print("\rTraining... %d / %d" % (batch + 1, NUM_TRAIN_BATCHES),
end="")
inputs = train_inputs[ids[batch * BATCH_SIZE:(batch + 1) *
BATCH_SIZE]]
labels = train_labels[ids[batch * BATCH_SIZE:(batch + 1) *
BATCH_SIZE]]
trainer.reset_gradients()
# Constructs the graph.
g = Graph()
with DefaultScopeGraph(g):
y = make_graph(inputs, True)
loss = F.softmax_cross_entropy(y, labels, 0)
avg_loss = F.batch.mean(loss)
# Dump computation graph at the first time.
#if (epoch == 0 && batch == 0) g.dump();
# Forward, backward, and updates parameters.
g.forward(avg_loss)
g.backward(avg_loss)
trainer.update()
print()
match = 0
# Test loop
for batch in range(NUM_TEST_BATCHES):
print("\rTesting... %d / %d" % (batch + 1, NUM_TEST_BATCHES),
end="")
# Makes a test minibatch.
inputs = test_inputs[batch * BATCH_SIZE:(batch + 1) *
BATCH_SIZE]
# Constructs the graph.
with Graph() as g:
y = make_graph(inputs, False)
# Gets outputs, argmax, and compares them with the label.
y_val = g.forward(y).to_list()
for i in range(BATCH_SIZE):
maxval = -1e10
argmax = -1
for j in range(NUM_OUTPUT_UNITS):
v = y_val[j + i * NUM_OUTPUT_UNITS]
if (v > maxval):
maxval = v
argmax = j
if argmax == test_labels[i + batch * BATCH_SIZE]:
match += 1
accuracy = 100.0 * match / NUM_TEST_SAMPLES
print("\nepoch %d: accuracy: %.2f%%\n" % (epoch, accuracy))
