def test_model_methods():
a = Input(shape=(3, ), name='input_a')
b = Input(shape=(3, ), name='input_b')
a_2 = Dense(4, name='dense_1')(a)
dp = Dropout(0.5, name='dropout')
b_2 = dp(b)
model = Model([a, b], [a_2, b_2])
optimizer = 'rmsprop'
loss = 'mse'
loss_weights = [1., 0.5]
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
# training/testing doesn't work before compiling.
with pytest.raises(RuntimeError):
model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
model.compile(optimizer,
loss,
metrics=[],
loss_weights=loss_weights,
sample_weight_mode=None)
# test train_on_batch
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out = model.train_on_batch({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np])
out = model.train_on_batch({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
})
# test fit
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
epochs=1,
batch_size=4)
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np],
epochs=1,
batch_size=4)
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
},
epochs=1,
batch_size=4)
# test validation_split
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
epochs=1,
batch_size=4,
validation_split=0.5)
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np],
epochs=1,
batch_size=4,
validation_split=0.5)
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
},
epochs=1,
batch_size=4,
validation_split=0.5)
# test validation data
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
epochs=1,
batch_size=4,
validation_data=([input_a_np,
input_b_np], [output_a_np, output_b_np]))
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np],
epochs=1,
batch_size=4,
validation_split=0.5,
validation_data=({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np]))
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
},
epochs=1,
batch_size=4,
validation_split=0.5,
validation_data=({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
}))
# test_on_batch
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out = model.test_on_batch({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np])
out = model.test_on_batch({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
})
# predict_on_batch
out = model.predict_on_batch([input_a_np, input_b_np])
out = model.predict_on_batch({
'input_a': input_a_np,
'input_b': input_b_np
})
# predict, evaluate
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
out = model.evaluate([input_a_np, input_b_np], [output_a_np, output_b_np],
batch_size=4)
out = model.predict([input_a_np, input_b_np], batch_size=4)
# with sample_weight
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
sample_weight = [None, np.random.random((10, ))]
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
# test accuracy metric
model.compile(optimizer, loss, metrics=['acc'], sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 5
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 5
# this should also work
model.compile(optimizer,
loss,
metrics={'dense_1': 'acc'},
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
# and this as well
model.compile(optimizer,
loss,
metrics={'dense_1': ['acc']},
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
# test starting from non-zero initial epoch
trained_epochs = []
# define tracer callback
def on_epoch_begin(epoch, logs):
trained_epochs.append(epoch)
tracker_cb = LambdaCallback(on_epoch_begin=on_epoch_begin)
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
epochs=5,
batch_size=4,
initial_epoch=2,
callbacks=[tracker_cb])
assert trained_epochs == [2, 3, 4]
# test starting from non-zero initial epoch for generator too
trained_epochs = []
def gen_data(batch_sz):
while True:
yield ([
np.random.random((batch_sz, 3)),
np.random.random((batch_sz, 3))
], [
np.random.random((batch_sz, 4)),
np.random.random((batch_sz, 3))
])
out = model.fit_generator(gen_data(4),
steps_per_epoch=3,
epochs=5,
initial_epoch=2,
callbacks=[tracker_cb])
assert trained_epochs == [2, 3, 4]
# test with a custom metric function
def mse(y_true, y_pred):
return K.mean(K.pow(y_true - y_pred, 2))
model.compile(optimizer, loss, metrics=[mse], sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out_len = 1 + 2 * (1 + 1) # total loss + 2 outputs * (loss + metric)
assert len(out) == out_len
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == out_len
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
batch_size=4,
epochs=1)
out = model.evaluate([input_a_np, input_b_np], [output_a_np, output_b_np],
batch_size=4)
out = model.predict([input_a_np, input_b_np], batch_size=4)
# x is not a list of numpy arrays.
with pytest.raises(ValueError):
out = model.predict([None])
# x does not match _feed_input_names.
with pytest.raises(ValueError):
out = model.predict([input_a_np, None, input_b_np])
with pytest.raises(ValueError):
out = model.predict([None, input_a_np, input_b_np])
# all input/output/weight arrays should have the same number of samples.
with pytest.raises(ValueError):
out = model.train_on_batch([input_a_np, input_b_np[:2]],
[output_a_np, output_b_np],
sample_weight=sample_weight)
with pytest.raises(ValueError):
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np[:2]],
sample_weight=sample_weight)
with pytest.raises(ValueError):
out = model.train_on_batch(
[input_a_np, input_b_np], [output_a_np, output_b_np],
sample_weight=[sample_weight[1], sample_weight[1][:2]])
# `sample_weight` is neither a dict nor a list.
with pytest.raises(TypeError):
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=tuple(sample_weight))
# `validation_data` is neither a tuple nor a triple.
with pytest.raises(ValueError):
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
epochs=1,
batch_size=4,
validation_data=([input_a_np, input_b_np], ))
# `loss` does not match outputs.
with pytest.raises(ValueError):
model.compile(optimizer, loss=['mse', 'mae', 'mape'])
# `loss_weights` does not match output_names.
with pytest.raises(ValueError):
model.compile(optimizer, loss='mse', loss_weights={'lstm': 0.5})
# `loss_weights` does not match outputs.
with pytest.raises(ValueError):
model.compile(optimizer, loss='mse', loss_weights=[0.5])
# `loss_weights` is invalid type.
with pytest.raises(TypeError):
model.compile(optimizer, loss='mse', loss_weights=(0.5, 0.5))
# `sample_weight_mode` does not match output_names.
with pytest.raises(ValueError):
model.compile(optimizer,
loss='mse',
sample_weight_mode={'lstm': 'temporal'})
# `sample_weight_mode` does not match output_names.
with pytest.raises(ValueError):
model.compile(optimizer, loss='mse', sample_weight_mode=['temporal'])
# `sample_weight_mode` matches output_names partially.
with pytest.raises(ValueError):
model.compile(optimizer,
loss='mse',
sample_weight_mode={'dense_1': 'temporal'})
# `loss` does not exist.
with pytest.raises(RuntimeError):
model.compile(optimizer, loss=[])
model.compile(optimizer, loss=['mse', 'mae'])
model.compile(optimizer,
loss='mse',
loss_weights={
'dense_1': 0.2,
'dropout': 0.8
})
model.compile(optimizer, loss='mse', loss_weights=[0.2, 0.8])
# the rank of weight arrays should be 1.
with pytest.raises(ValueError):
out = model.train_on_batch(
[input_a_np, input_b_np], [output_a_np, output_b_np],
sample_weight=[None, np.random.random((10, 20, 30))])
model.compile(optimizer,
loss='mse',
sample_weight_mode={
'dense_1': None,
'dropout': 'temporal'
})
model.compile(optimizer, loss='mse', sample_weight_mode=[None, 'temporal'])
# the rank of output arrays should be at least 3D.
with pytest.raises(ValueError):
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
def test_model_methods():
a = Input(shape=(3,), name='input_a')
b = Input(shape=(3,), name='input_b')
a_2 = Dense(4, name='dense_1')(a)
dp = Dropout(0.5, name='dropout')
b_2 = dp(b)
model = Model([a, b], [a_2, b_2])
optimizer = 'rmsprop'
loss = 'mse'
loss_weights = [1., 0.5]
model.compile(optimizer, loss, metrics=[], loss_weights=loss_weights,
sample_weight_mode=None)
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
# test train_on_batch
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out = model.train_on_batch({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np])
out = model.train_on_batch({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np})
# test fit
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np], nb_epoch=1, batch_size=4)
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np], nb_epoch=1, batch_size=4)
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np},
nb_epoch=1, batch_size=4)
# test validation_split
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np],
nb_epoch=1, batch_size=4, validation_split=0.5)
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np],
nb_epoch=1, batch_size=4, validation_split=0.5)
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np},
nb_epoch=1, batch_size=4, validation_split=0.5)
# test validation data
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np],
nb_epoch=1, batch_size=4,
validation_data=([input_a_np, input_b_np], [output_a_np, output_b_np]))
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np],
nb_epoch=1, batch_size=4, validation_split=0.5,
validation_data=({'input_a': input_a_np, 'input_b': input_b_np}, [output_a_np, output_b_np]))
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np},
nb_epoch=1, batch_size=4, validation_split=0.5,
validation_data=({'input_a': input_a_np, 'input_b': input_b_np}, {'dense_1': output_a_np, 'dropout': output_b_np}))
# test_on_batch
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out = model.test_on_batch({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np])
out = model.test_on_batch({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np})
# predict_on_batch
out = model.predict_on_batch([input_a_np, input_b_np])
out = model.predict_on_batch({'input_a': input_a_np, 'input_b': input_b_np})
# predict, evaluate
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
out = model.evaluate([input_a_np, input_b_np], [output_a_np, output_b_np], batch_size=4)
out = model.predict([input_a_np, input_b_np], batch_size=4)
# with sample_weight
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
sample_weight = [None, np.random.random((10,))]
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
# test accuracy metric
model.compile(optimizer, loss, metrics=['acc'],
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 5
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 5
# this should also work
model.compile(optimizer, loss, metrics={'dense_1': 'acc'},
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
# and this as well
model.compile(optimizer, loss, metrics={'dense_1': ['acc']},
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
# test with a custom metric function
mse = lambda y_true, y_pred: K.mean(K.pow(y_true - y_pred, 2))
model.compile(optimizer, loss, metrics=[mse],
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 5
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 5
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np], batch_size=4, nb_epoch=1)
out = model.evaluate([input_a_np, input_b_np], [output_a_np, output_b_np], batch_size=4)
out = model.predict([input_a_np, input_b_np], batch_size=4)
def test_model_with_input_feed_tensor():
"""We test building a model with a TF variable as input.
We should be able to call fit, evaluate, predict,
by only passing them data for the placeholder inputs
in the model.
"""
import tensorflow as tf
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
a = Input(tensor=tf.Variable(input_a_np, dtype=tf.float32))
b = Input(shape=(3,), name='input_b')
a_2 = Dense(4, name='dense_1')(a)
dp = Dropout(0.5, name='dropout')
b_2 = dp(b)
model = Model([a, b], [a_2, b_2])
model.summary()
optimizer = 'rmsprop'
loss = 'mse'
loss_weights = [1., 0.5]
model.compile(optimizer, loss, metrics=['mean_squared_error'],
loss_weights=loss_weights,
sample_weight_mode=None)
# test train_on_batch
out = model.train_on_batch(input_b_np,
[output_a_np, output_b_np])
out = model.train_on_batch({'input_b': input_b_np},
[output_a_np, output_b_np])
out = model.test_on_batch({'input_b': input_b_np},
[output_a_np, output_b_np])
out = model.predict_on_batch({'input_b': input_b_np})
# test fit
out = model.fit({'input_b': input_b_np},
[output_a_np, output_b_np], epochs=1, batch_size=10)
out = model.fit(input_b_np,
[output_a_np, output_b_np], epochs=1, batch_size=10)
# test evaluate
out = model.evaluate({'input_b': input_b_np},
[output_a_np, output_b_np], batch_size=10)
out = model.evaluate(input_b_np,
[output_a_np, output_b_np], batch_size=10)
# test predict
out = model.predict({'input_b': input_b_np}, batch_size=10)
out = model.predict(input_b_np, batch_size=10)
assert len(out) == 2
# Now test a model with a single input
# i.e. we don't pass any data to fit the model.
a = Input(tensor=tf.Variable(input_a_np, dtype=tf.float32))
a_2 = Dense(4, name='dense_1')(a)
a_2 = Dropout(0.5, name='dropout')(a_2)
model = Model(a, a_2)
model.summary()
optimizer = 'rmsprop'
loss = 'mse'
model.compile(optimizer, loss, metrics=['mean_squared_error'])
# test train_on_batch
out = model.train_on_batch(None,
output_a_np)
out = model.train_on_batch(None,
output_a_np)
out = model.test_on_batch(None,
output_a_np)
out = model.predict_on_batch(None)
out = model.train_on_batch([],
output_a_np)
out = model.train_on_batch({},
output_a_np)
# test fit
out = model.fit(None,
output_a_np, epochs=1, batch_size=10)
out = model.fit(None,
output_a_np, epochs=1, batch_size=10)
# test evaluate
out = model.evaluate(None,
output_a_np, batch_size=10)
out = model.evaluate(None,
output_a_np, batch_size=10)
# test predict
out = model.predict(None, steps=3)
out = model.predict(None, steps=3)
assert out.shape == (10 * 3, 4)
# Same, without learning phase
# i.e. we don't pass any data to fit the model.
a = Input(tensor=tf.Variable(input_a_np, dtype=tf.float32))
a_2 = Dense(4, name='dense_1')(a)
model = Model(a, a_2)
model.summary()
optimizer = 'rmsprop'
loss = 'mse'
model.compile(optimizer, loss, metrics=['mean_squared_error'])
# test train_on_batch
out = model.train_on_batch(None,
output_a_np)
out = model.train_on_batch(None,
output_a_np)
out = model.test_on_batch(None,
output_a_np)
out = model.predict_on_batch(None)
out = model.train_on_batch([],
output_a_np)
out = model.train_on_batch({},
output_a_np)
# test fit
out = model.fit(None,
output_a_np, epochs=1, batch_size=10)
out = model.fit(None,
output_a_np, epochs=1, batch_size=10)
# test evaluate
out = model.evaluate(None,
output_a_np, batch_size=10)
out = model.evaluate(None,
output_a_np, batch_size=10)
# test predict
out = model.predict(None, steps=3)
out = model.predict(None, steps=3)
assert out.shape == (10 * 3, 4)
def test_model_methods():
a = Input(shape=(3,), name='input_a')
b = Input(shape=(3,), name='input_b')
a_2 = Dense(4, name='dense_1')(a)
dp = Dropout(0.5, name='dropout')
b_2 = dp(b)
model = Model([a, b], [a_2, b_2])
optimizer = 'rmsprop'
loss = 'mse'
loss_weights = [1., 0.5]
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
input_a_df = pd.DataFrame(input_a_np)
input_b_df = pd.DataFrame(input_b_np)
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
output_a_df = pd.DataFrame(output_a_np)
output_b_df = pd.DataFrame(output_b_np)
# training/testing doesn't work before compiling.
with pytest.raises(RuntimeError):
model.train_on_batch([input_a_np, input_b_np], [output_a_np, output_b_np])
model.compile(optimizer, loss, metrics=[], loss_weights=loss_weights,
sample_weight_mode=None)
# test train_on_batch
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out = model.train_on_batch({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np])
out = model.train_on_batch({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np})
out = model.train_on_batch([input_a_df, input_b_df],
[output_a_df, output_b_df])
# test fit
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np], epochs=1, batch_size=4)
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np], epochs=1, batch_size=4)
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np},
epochs=1, batch_size=4)
out = model.fit([input_a_df, input_b_df],
[output_a_df, output_b_df], epochs=1, batch_size=4)
# test validation_split
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np],
epochs=1, batch_size=4, validation_split=0.5)
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np],
epochs=1, batch_size=4, validation_split=0.5)
# test validation data
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np],
epochs=1, batch_size=4,
validation_data=([input_a_np, input_b_np], [output_a_np, output_b_np]))
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np],
epochs=1, batch_size=4, validation_split=0.5,
validation_data=({'input_a': input_a_np, 'input_b': input_b_np}, [output_a_np, output_b_np]))
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np},
epochs=1, batch_size=4, validation_split=0.5,
validation_data=(
{'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np}))
# test_on_batch
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out = model.test_on_batch({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np])
out = model.test_on_batch({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np})
out = model.test_on_batch([input_a_df, input_b_df],
[output_a_df, output_b_df])
# predict_on_batch
out = model.predict_on_batch([input_a_np, input_b_np])
out = model.predict_on_batch({'input_a': input_a_np, 'input_b': input_b_np})
out = model.predict_on_batch([input_a_df, input_b_df])
# predict, evaluate
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
out = model.evaluate([input_a_np, input_b_np], [output_a_np, output_b_np], batch_size=4)
out = model.evaluate([input_a_df, input_b_df], [output_a_df, output_b_df], batch_size=4)
out = model.predict([input_a_np, input_b_np], batch_size=4)
out = model.predict([input_a_df, input_b_df], batch_size=4)
# with sample_weight
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
sample_weight = [None, np.random.random((10,))]
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
# test accuracy metric
model.compile(optimizer, loss, metrics=['acc'],
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 5
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 5
# this should also work
model.compile(optimizer, loss, metrics={'dense_1': 'acc'},
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
# and this as well
model.compile(optimizer, loss, metrics={'dense_1': ['acc']},
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
# test starting from non-zero initial epoch
trained_epochs = []
# define tracer callback
def on_epoch_begin(epoch, logs):
trained_epochs.append(epoch)
tracker_cb = LambdaCallback(on_epoch_begin=on_epoch_begin)
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np], epochs=5, batch_size=4,
initial_epoch=2, callbacks=[tracker_cb])
assert trained_epochs == [2, 3, 4]
# test starting from non-zero initial epoch for generator too
trained_epochs = []
def gen_data(batch_sz):
while True:
yield ([np.random.random((batch_sz, 3)), np.random.random((batch_sz, 3))],
[np.random.random((batch_sz, 4)), np.random.random((batch_sz, 3))])
out = model.fit_generator(gen_data(4), steps_per_epoch=3, epochs=5,
initial_epoch=2, callbacks=[tracker_cb])
assert trained_epochs == [2, 3, 4]
# test with a custom metric function
def mse(y_true, y_pred):
return K.mean(K.pow(y_true - y_pred, 2))
model.compile(optimizer, loss, metrics=[mse],
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out_len = 1 + 2 * (1 + 1) # total loss + 2 outputs * (loss + metric)
assert len(out) == out_len
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == out_len
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np], batch_size=4, epochs=1)
out = model.evaluate([input_a_np, input_b_np], [output_a_np, output_b_np], batch_size=4)
out = model.predict([input_a_np, input_b_np], batch_size=4)
# empty batch
with pytest.raises(ValueError):
def gen_data():
while True:
yield (np.asarray([]), np.asarray([]))
out = model.evaluate_generator(gen_data(), steps=1)
# x is not a list of numpy arrays.
with pytest.raises(ValueError):
out = model.predict([None])
# x does not match _feed_input_names.
with pytest.raises(ValueError):
out = model.predict([input_a_np, None, input_b_np])
with pytest.raises(ValueError):
out = model.predict([None, input_a_np, input_b_np])
# all input/output/weight arrays should have the same number of samples.
with pytest.raises(ValueError):
out = model.train_on_batch([input_a_np, input_b_np[:2]],
[output_a_np, output_b_np],
sample_weight=sample_weight)
with pytest.raises(ValueError):
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np[:2]],
sample_weight=sample_weight)
with pytest.raises(ValueError):
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=[sample_weight[1], sample_weight[1][:2]])
# `sample_weight` is neither a dict nor a list.
with pytest.raises(TypeError):
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=tuple(sample_weight))
# `validation_data` is neither a tuple nor a triple.
with pytest.raises(ValueError):
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np],
epochs=1, batch_size=4,
validation_data=([input_a_np, input_b_np],))
# `loss` does not match outputs.
with pytest.raises(ValueError):
model.compile(optimizer, loss=['mse', 'mae', 'mape'])
# `loss_weights` does not match output_names.
with pytest.raises(ValueError):
model.compile(optimizer, loss='mse', loss_weights={'lstm': 0.5})
# `loss_weights` does not match outputs.
with pytest.raises(ValueError):
model.compile(optimizer, loss='mse', loss_weights=[0.5])
# `loss_weights` is invalid type.
with pytest.raises(TypeError):
model.compile(optimizer, loss='mse', loss_weights=(0.5, 0.5))
# `sample_weight_mode` does not match output_names.
with pytest.raises(ValueError):
model.compile(optimizer, loss='mse', sample_weight_mode={'lstm': 'temporal'})
# `sample_weight_mode` does not match output_names.
with pytest.raises(ValueError):
model.compile(optimizer, loss='mse', sample_weight_mode=['temporal'])
# `sample_weight_mode` matches output_names partially.
with pytest.raises(ValueError):
model.compile(optimizer, loss='mse', sample_weight_mode={'dense_1': 'temporal'})
# `loss` does not exist.
with pytest.raises(ValueError):
model.compile(optimizer, loss=[])
model.compile(optimizer, loss=['mse', 'mae'])
model.compile(optimizer, loss='mse', loss_weights={'dense_1': 0.2, 'dropout': 0.8})
model.compile(optimizer, loss='mse', loss_weights=[0.2, 0.8])
# the rank of weight arrays should be 1.
with pytest.raises(ValueError):
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=[None, np.random.random((10, 20, 30))])
model.compile(optimizer, loss='mse', sample_weight_mode={'dense_1': None, 'dropout': 'temporal'})
model.compile(optimizer, loss='mse', sample_weight_mode=[None, 'temporal'])
# the rank of output arrays should be at least 3D.
with pytest.raises(ValueError):
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
model.compile(optimizer, loss, metrics=[], loss_weights=loss_weights,
sample_weight_mode=None)
trained_epochs = []
out = model.fit_generator(generator=RandomSequence(3), steps_per_epoch=12, epochs=5,
initial_epoch=0, validation_data=RandomSequence(4),
validation_steps=12, callbacks=[tracker_cb])
assert trained_epochs == [0, 1, 2, 3, 4]
def test_pandas_dataframe():
input_a = Input(shape=(3,), name='input_a')
input_b = Input(shape=(3,), name='input_b')
x = Dense(4, name='dense_1')(input_a)
y = Dense(3, name='desne_2')(input_b)
model_1 = Model(inputs=input_a, outputs=x)
model_2 = Model(inputs=[input_a, input_b], outputs=[x, y])
optimizer = 'rmsprop'
loss = 'mse'
model_1.compile(optimizer=optimizer, loss=loss)
model_2.compile(optimizer=optimizer, loss=loss)
input_a_df = pd.DataFrame(np.random.random((10, 3)))
input_b_df = pd.DataFrame(np.random.random((10, 3)))
output_a_df = pd.DataFrame(np.random.random((10, 4)))
output_b_df = pd.DataFrame(np.random.random((10, 3)))
model_1.fit(input_a_df,
output_a_df)
model_2.fit([input_a_df, input_b_df],
[output_a_df, output_b_df])
model_1.fit([input_a_df],
[output_a_df])
model_1.fit({'input_a': input_a_df},
output_a_df)
model_2.fit({'input_a': input_a_df, 'input_b': input_b_df},
[output_a_df, output_b_df])
model_1.predict(input_a_df)
model_2.predict([input_a_df, input_b_df])
model_1.predict([input_a_df])
model_1.predict({'input_a': input_a_df})
model_2.predict({'input_a': input_a_df, 'input_b': input_b_df})
model_1.predict_on_batch(input_a_df)
model_2.predict_on_batch([input_a_df, input_b_df])
model_1.predict_on_batch([input_a_df])
model_1.predict_on_batch({'input_a': input_a_df})
model_2.predict_on_batch({'input_a': input_a_df, 'input_b': input_b_df})
model_1.evaluate(input_a_df,
output_a_df)
model_2.evaluate([input_a_df, input_b_df],
[output_a_df, output_b_df])
model_1.evaluate([input_a_df],
[output_a_df])
model_1.evaluate({'input_a': input_a_df},
output_a_df)
model_2.evaluate({'input_a': input_a_df, 'input_b': input_b_df},
[output_a_df, output_b_df])
model_1.train_on_batch(input_a_df,
output_a_df)
model_2.train_on_batch([input_a_df, input_b_df],
[output_a_df, output_b_df])
model_1.train_on_batch([input_a_df],
[output_a_df])
model_1.train_on_batch({'input_a': input_a_df},
output_a_df)
model_2.train_on_batch({'input_a': input_a_df, 'input_b': input_b_df},
[output_a_df, output_b_df])
model_1.test_on_batch(input_a_df,
output_a_df)
model_2.test_on_batch([input_a_df, input_b_df],
[output_a_df, output_b_df])
model_1.test_on_batch([input_a_df],
[output_a_df])
model_1.test_on_batch({'input_a': input_a_df},
output_a_df)
model_2.test_on_batch({'input_a': input_a_df, 'input_b': input_b_df},
[output_a_df, output_b_df])
def test_model_methods():
a = Input(shape=(3, ), name='input_a')
b = Input(shape=(3, ), name='input_b')
a_2 = Dense(4, name='dense_1')(a)
dp = Dropout(0.5, name='dropout')
b_2 = dp(b)
model = Model([a, b], [a_2, b_2])
optimizer = 'rmsprop'
loss = 'mse'
loss_weights = [1., 0.5]
model.compile(optimizer,
loss,
metrics=[],
loss_weights=loss_weights,
sample_weight_mode=None)
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
# test train_on_batch
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out = model.train_on_batch({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np])
out = model.train_on_batch({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
})
# test fit
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
nb_epoch=1,
batch_size=4)
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np],
nb_epoch=1,
batch_size=4)
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
},
nb_epoch=1,
batch_size=4)
# test validation_split
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
nb_epoch=1,
batch_size=4,
validation_split=0.5)
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np],
nb_epoch=1,
batch_size=4,
validation_split=0.5)
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
},
nb_epoch=1,
batch_size=4,
validation_split=0.5)
# test validation data
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
nb_epoch=1,
batch_size=4,
validation_data=([input_a_np,
input_b_np], [output_a_np, output_b_np]))
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np],
nb_epoch=1,
batch_size=4,
validation_split=0.5,
validation_data=({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np]))
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
},
nb_epoch=1,
batch_size=4,
validation_split=0.5,
validation_data=({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
}))
# test_on_batch
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out = model.test_on_batch({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np])
out = model.test_on_batch({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
})
# predict_on_batch
out = model.predict_on_batch([input_a_np, input_b_np])
out = model.predict_on_batch({
'input_a': input_a_np,
'input_b': input_b_np
})
# predict, evaluate
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
out = model.evaluate([input_a_np, input_b_np], [output_a_np, output_b_np],
batch_size=4)
out = model.predict([input_a_np, input_b_np], batch_size=4)
# with sample_weight
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
sample_weight = [None, np.random.random((10, ))]
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
# test accuracy metric
model.compile(optimizer, loss, metrics=['acc'], sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 5
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 5
# this should also work
model.compile(optimizer,
loss,
metrics={'dense_1': 'acc'},
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
# and this as well
model.compile(optimizer,
loss,
metrics={'dense_1': ['acc']},
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
# test starting from non-zero initial epoch
trained_epochs = []
def on_epoch_begin(epoch, logs):
trained_epochs.append(epoch)
tracker_cb = LambdaCallback(on_epoch_begin=on_epoch_begin)
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
nb_epoch=5,
batch_size=4,
initial_epoch=2,
callbacks=[tracker_cb])
assert trained_epochs == [2, 3, 4]
# test starting from non-zero initial epoch for generator too
trained_epochs = []
def gen_data(batch_sz):
while True:
yield ([
np.random.random((batch_sz, 3)),
np.random.random((batch_sz, 3))
], [
np.random.random((batch_sz, 4)),
np.random.random((batch_sz, 3))
])
out = model.fit_generator(gen_data(4),
samples_per_epoch=10,
nb_epoch=5,
initial_epoch=2,
callbacks=[tracker_cb])
assert trained_epochs == [2, 3, 4]
# test with a custom metric function
mse = lambda y_true, y_pred: K.mean(K.pow(y_true - y_pred, 2))
def mse_powers(y_true, y_pred):
m = mse(y_true, y_pred)
return {'mse_squared': K.pow(m, 2), 'mse_cubed': K.pow(m, 3)}
model.compile(optimizer,
loss,
metrics=[mse, mse_powers],
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out_len = 1 + 2 * 4 # total loss, per layer: loss + 3 metrics
assert len(out) == out_len
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == out_len
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
batch_size=4,
nb_epoch=1)
out = model.evaluate([input_a_np, input_b_np], [output_a_np, output_b_np],
batch_size=4)
out = model.predict([input_a_np, input_b_np], batch_size=4)
class RLPlayer:
"""
Implements a player that uses neural networks to play chess.
Attributes:
"""
def __init__(self, config = None):
"""
Class constructor for minimax player.
"""
self.board = None
self.my_color = None
self.model = None
if config == None:
self.config_model = neural_network_config.ModelConfig()
self.config = neural_network_config.Config()
self.node_lock = defaultdict(Lock)
self.game_tree = {}
# Set up multiprocessing for speed
self.feed_input, self.return_policy_value = self.create_pipes()
# Build a model
self.build_model()
losses = ['categorical_crossentropy', 'mean_squared_error'] # avoid overfit for supervised
self.model.compile(optimizer=Adam(), loss=losses, loss_weights=self.config.trainer.loss_weights)
# Dictionary to facilitate converting from network outputs to move
self.move_code = {i: chess.Move.from_uci(move)
for move, i in zip(neural_network_config.create_uci_labels(),
range(len(neural_network_config.create_uci_labels())))}
self.move_lookup = {chess.Move.from_uci(move): i
for move, i in zip(neural_network_config.create_uci_labels(),
range(len(neural_network_config.create_uci_labels())))}
# Start a thread to listen on the pipe and make predictions
self.prediction_worker = Thread(target=self._predict_batch_worker, name = "prediction_worker")
self.prediction_worker.daemon = True
self.prediction_worker.start()
def create_pipes(self):
self.feed_input, self.return_policy_value = [], []
for thread in range(30):
me, you = Pipe()
self.feed_input.append(me)
self.return_policy_value.append(you)
return self.feed_input, self.return_policy_value
def get_move(self):
# Perform Monte-Carlo Tree Search (updating internal variables)
self.MCTS()
# Choose the most visited node (highest exponentiated visited)
state = state_key(self.board)
candidate_moves = self.game_tree[state]['action']
# Temperature controls exploration depending on stage of game
board_input, move_counts = self.save_move(candidate_moves)
if self.board.fullmove_number < 45:
if self.board.fullmove_number < 30:
temperature = 0.95 ** self.board.fullmove_number
else:
temperature = 0.1
exp_move_counts = np.power(move_counts, 1./temperature)
exp_move_counts /= np.sum(exp_move_counts)
else:
exp_move_counts = np.zeros_like(move_counts)
exp_move_counts[np.argmax(move_counts)] = 1
move = np.random.choice([move for move in candidate_moves], p = exp_move_counts)
self.board.push(move)
# Return data (useful only for self-play generation)
normalized_move_counts = move_counts / np.sum(move_counts)
return board_input, normalized_move_counts
def build_model(self):
"""
Builds the full Keras model and stores it in self.model.
"""
mc = self.config_model
in_x = x = Input((18, 8, 8))
# (batch, channels, height, width)
x = Conv2D(filters=mc.cnn_filter_num, kernel_size=mc.cnn_first_filter_size, padding="same",
data_format="channels_first", use_bias=False, kernel_regularizer=l2(mc.l2_reg),
name="input_conv-"+str(mc.cnn_first_filter_size)+"-"+str(mc.cnn_filter_num))(x)
x = BatchNormalization(axis=1, name="input_batchnorm")(x)
x = Activation("relu", name="input_relu")(x)
for i in range(mc.res_layer_num):
x = self._build_residual_block(x, i + 1)
res_out = x
# for policy output
x = Conv2D(filters=2, kernel_size=1, data_format="channels_first", use_bias=False, kernel_regularizer=l2(mc.l2_reg),
name="policy_conv-1-2")(res_out)
x = BatchNormalization(axis=1, name="policy_batchnorm")(x)
x = Activation("relu", name="policy_relu")(x)
x = Flatten(name="policy_flatten")(x)
# no output for 'pass'
policy_out = Dense(self.config.n_labels, kernel_regularizer=l2(mc.l2_reg), activation="softmax", name="policy_out")(x)
# for value output
x = Conv2D(filters=4, kernel_size=1, data_format="channels_first", use_bias=False, kernel_regularizer=l2(mc.l2_reg),
name="value_conv-1-4")(res_out)
x = BatchNormalization(axis=1, name="value_batchnorm")(x)
x = Activation("relu",name="value_relu")(x)
x = Flatten(name="value_flatten")(x)
x = Dense(mc.value_fc_size, kernel_regularizer=l2(mc.l2_reg), activation="relu", name="value_dense")(x)
value_out = Dense(1, kernel_regularizer=l2(mc.l2_reg), activation="tanh", name="value_out")(x)
self.model = Model(in_x, [policy_out, value_out], name="chess_model")
def _build_residual_block(self, x, index):
mc = self.config_model
in_x = x
res_name = "res"+str(index)
x = Conv2D(filters=mc.cnn_filter_num, kernel_size=mc.cnn_filter_size, padding="same",
data_format="channels_first", use_bias=False, kernel_regularizer=l2(mc.l2_reg),
name=res_name+"_conv1-"+str(mc.cnn_filter_size)+"-"+str(mc.cnn_filter_num))(x)
x = BatchNormalization(axis=1, name=res_name+"_batchnorm1")(x)
x = Activation("relu",name=res_name+"_relu1")(x)
x = Conv2D(filters=mc.cnn_filter_num, kernel_size=mc.cnn_filter_size, padding="same",
data_format="channels_first", use_bias=False, kernel_regularizer=l2(mc.l2_reg),
name=res_name+"_conv2-"+str(mc.cnn_filter_size)+"-"+str(mc.cnn_filter_num))(x)
x = BatchNormalization(axis=1, name="res"+str(index)+"_batchnorm2")(x)
x = Add(name=res_name+"_add")([in_x, x])
x = Activation("relu", name=res_name+"_relu2")(x)
return x
def visualize_model(self):
"""
Print out model summary (contains layer names, shape of input,
number of parameters, and connection to)
"""
self.model.summary()
def MCTS(self):
"""
Using 30 workers (max_workers=self.play_config.search_threads)
self.play_config.simulation_num_per_move = 800
"""
futures = []
with ThreadPoolExecutor(max_workers = 30) as executor:
for _ in range(800):
# self.select_move(board=self.board.copy(),is_root_node=True)
future = executor.submit(self.select_move,board=self.board.copy(),is_root_node=True)
# if future.exception():
# raise ValueError
# The board is copied so I don't need to pop the move
# vals = [f.result() for f in futures]
def select_move(self, board, is_root_node=False):
"""
They use virtual_loss
"""
# print (self.node_lock)
state = state_key(board)
with self.node_lock[state]:
if state not in self.game_tree:
# print(state)
policy, value = self.forward_pass(board)
# print(policy, value)
# if state not in self.game_tree:
# print ("I'm evaluating leaf", board.move_stack)
#
self.game_tree[state] = {}
self.game_tree[state]['policy'] = policy
self.game_tree[state]['action'] = defaultdict(NodeStatistics)
self.game_tree[state]['total_visits'] = 1
# print (self.game_tree)
# # I must have visited once before to call best_q_move method
return value
action = self.best_q_move(board, is_root_node)
# print (action)
board.push(action)
# Simulate enemy_move
enemy_value = self.select_move(board)
value = -enemy_value
actions = self.game_tree[state]['action']
with self.node_lock[state]:
self.game_tree[state]['total_visits'] += 1
actions[action].n += 1
actions[action].w += value
actions[action].q = actions[action].w / actions[action].n
return value
def best_q_move(self, board, is_root_node):
"""
c_puct = 1.5
"""
# print ("Hi")
state = state_key(board)
policy = self.game_tree[state]['policy']
actions = self.game_tree[state]['action']
unnormalized_prior = [policy[self.move_lookup[move]] for move in board.legal_moves]
# print (unnormalized_prior)
prior = unnormalized_prior / sum(unnormalized_prior)
sqrt_total_visits = np.sqrt(self.game_tree[state]['total_visits'])
c_puct = 1.5
dirichlet_alpha = 0.3
noise_eps = 0.25
best_q = -np.inf
best_move = None
num_legal_moves = len(list(board.legal_moves))
if is_root_node:
dirichlet_noise = np.random.dirichlet([dirichlet_alpha] * num_legal_moves)
for index, move in enumerate(board.legal_moves):
candidate_q = (actions[move].q +
c_puct * prior[index] * sqrt_total_visits / (1 + actions[move].n))
if is_root_node: #add noise for exploration
candidate_q = ((1 - noise_eps) * candidate_q +
noise_eps * dirichlet_noise[index])
if (best_q < candidate_q):
best_q = candidate_q
best_move = move
return best_move
def forward_pass(self, board):
input_planes = self.board_to_input(board, board.turn)
# print (input_planes)
input_pipe = self.feed_input.pop()
input_pipe.send(input_planes)
policy, value = input_pipe.recv()
self.feed_input.append(input_pipe)
return policy, value
def _predict_batch_worker(self):
"""
Thread worker which listens on each pipe in self.pipes for an observation, and then outputs
the predictions for the policy and value networks when the observations come in. Repeats.
## CITE
"""
while True:
ready = connection.wait(self.return_policy_value,timeout=0.001)
if not ready:
continue
data, result_pipes = [], []
for pipe in ready:
while pipe.poll():
data.append(pipe.recv())
result_pipes.append(pipe)
data = np.asarray(data, dtype=np.float32)
# print (data.shape)
policy_array, value_array = self.model.predict_on_batch(data)
# print (policy_array, value_array)
for pipe, policy, value in zip(result_pipes, policy_array, value_array):
pipe.send((policy, float(value)))
def board_to_input(self, board, my_color = None):
"""
FIX YOUR COLOR PROBLEM: ASSUME THAT THE NEURAL NETWORK RECEIVES THE INPUT FROM WHITE'S PERSPECTIVE
Input: 18 planes of size (8,8) representing the entire board
Boolean values: first 6 planes represent my pawn, knight, bishop, rook, queen, king
Next 6 planes represent opponent's pieces (in the same order)
Next 4 planes represent my king queen castling and opponents king queen castling
Next plane represents half move clock (50 move without pawn advance or piece capture is a draw)
Next plane represents the en passant square (if available)
"""
if my_color == None:
my_color = self.my_color
pieces_planes = np.zeros(shape=(12, 8, 8), dtype=np.float32)
board_colors = [not my_color, my_color]
en_passant = np.zeros((8, 8), dtype=np.float32)
# print (board_colors)
if my_color == 0:
for my_board, color in enumerate(board_colors):
for piece in range(1, 7):
my_piece_position = board.pieces(piece, color)
rank, file = np.array([[(int(i / 8)) for i in list(my_piece_position) ],
[(7-(i % 8)) for i in list(my_piece_position) ]])
pieces_planes[(piece - 1) + (my_board + 1) % 2 * 6, rank, file] = 1
if board.ep_square != None:
en_passant[int(board.ep_square / 8), 7 - (board.ep_square % 8)] = 1
else:
# print ("Yo my color is", my_color)
for my_board, color in enumerate(board_colors):
for piece in range(1, 7):
my_piece_position = board.pieces(piece, color)
rank, file = np.array([[(7 - int(i / 8)) for i in list(my_piece_position) ],
[(i % 8) for i in list(my_piece_position) ]])
pieces_planes[(piece - 1) + (my_board + 1) % 2 * 6, rank, file] = 1
if board.ep_square != None:
en_passant[7 - int(board.ep_square / 8), (board.ep_square % 8)] = 1
# print("Hi")
auxiliary_planes = np.array([np.full((8, 8), board.has_kingside_castling_rights(my_color), dtype=np.float32),
np.full((8, 8), board.has_queenside_castling_rights(my_color), dtype=np.float32),
np.full((8, 8), board.has_kingside_castling_rights(not self.my_color), dtype=np.float32),
np.full((8, 8), board.has_queenside_castling_rights(not my_color), dtype=np.float32),
np.full((8, 8), board.halfmove_clock, dtype=np.float32),
en_passant])
# print (np.vstack((pieces_planes, auxiliary_planes)))
return (np.vstack((pieces_planes, auxiliary_planes)))
def save_move(self, candidate_moves):
"""
Used by the self-play generator to generate move-policy data
"""
board_input = self.board_to_input(self.board.copy())
move_counts = np.array([candidate_moves[move].n for move in candidate_moves])
return board_input, move_counts
def test_model_with_input_feed_tensor():
"""We test building a model with a TF variable as input.
We should be able to call fit, evaluate, predict,
by only passing them data for the placeholder inputs
in the model.
"""
import tensorflow as tf
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
a = Input(tensor=tf.Variable(input_a_np, dtype=tf.float32))
b = Input(shape=(3, ), name='input_b')
a_2 = Dense(4, name='dense_1')(a)
dp = Dropout(0.5, name='dropout')
b_2 = dp(b)
model = Model([a, b], [a_2, b_2])
model.summary()
optimizer = 'rmsprop'
loss = 'mse'
loss_weights = [1., 0.5]
model.compile(optimizer,
loss,
metrics=['mean_squared_error'],
loss_weights=loss_weights,
sample_weight_mode=None)
# test train_on_batch
out = model.train_on_batch(input_b_np, [output_a_np, output_b_np])
out = model.train_on_batch({'input_b': input_b_np},
[output_a_np, output_b_np])
out = model.test_on_batch({'input_b': input_b_np},
[output_a_np, output_b_np])
out = model.predict_on_batch({'input_b': input_b_np})
# test fit
out = model.fit({'input_b': input_b_np}, [output_a_np, output_b_np],
epochs=1,
batch_size=10)
out = model.fit(input_b_np, [output_a_np, output_b_np],
epochs=1,
batch_size=10)
# test evaluate
out = model.evaluate({'input_b': input_b_np}, [output_a_np, output_b_np],
batch_size=10)
out = model.evaluate(input_b_np, [output_a_np, output_b_np], batch_size=10)
# test predict
out = model.predict({'input_b': input_b_np}, batch_size=10)
out = model.predict(input_b_np, batch_size=10)
assert len(out) == 2
# Now test a model with a single input
# i.e. we don't pass any data to fit the model.
a = Input(tensor=tf.Variable(input_a_np, dtype=tf.float32))
a_2 = Dense(4, name='dense_1')(a)
a_2 = Dropout(0.5, name='dropout')(a_2)
model = Model(a, a_2)
model.summary()
optimizer = 'rmsprop'
loss = 'mse'
model.compile(optimizer, loss, metrics=['mean_squared_error'])
# test train_on_batch
out = model.train_on_batch(None, output_a_np)
out = model.train_on_batch(None, output_a_np)
out = model.test_on_batch(None, output_a_np)
out = model.predict_on_batch(None)
out = model.train_on_batch([], output_a_np)
out = model.train_on_batch({}, output_a_np)
# test fit
out = model.fit(None, output_a_np, epochs=1, batch_size=10)
out = model.fit(None, output_a_np, epochs=1, batch_size=10)
# test evaluate
out = model.evaluate(None, output_a_np, batch_size=10)
out = model.evaluate(None, output_a_np, batch_size=10)
# test predict
out = model.predict(None, steps=3)
out = model.predict(None, steps=3)
assert out.shape == (10 * 3, 4)
# Same, without learning phase
# i.e. we don't pass any data to fit the model.
a = Input(tensor=tf.Variable(input_a_np, dtype=tf.float32))
a_2 = Dense(4, name='dense_1')(a)
model = Model(a, a_2)
model.summary()
optimizer = 'rmsprop'
loss = 'mse'
model.compile(optimizer, loss, metrics=['mean_squared_error'])
# test train_on_batch
out = model.train_on_batch(None, output_a_np)
out = model.train_on_batch(None, output_a_np)
out = model.test_on_batch(None, output_a_np)
out = model.predict_on_batch(None)
out = model.train_on_batch([], output_a_np)
out = model.train_on_batch({}, output_a_np)
# test fit
out = model.fit(None, output_a_np, epochs=1, batch_size=10)
out = model.fit(None, output_a_np, epochs=1, batch_size=10)
# test evaluate
out = model.evaluate(None, output_a_np, batch_size=10)
out = model.evaluate(None, output_a_np, batch_size=10)
# test predict
out = model.predict(None, steps=3)
out = model.predict(None, steps=3)
assert out.shape == (10 * 3, 4)
class ResiCNN: # My JackNet with residual block
cnn_filter_num = 64
cnn_kernel_size = 3
def __init__(self, channels=3):
self.model = None
self.optimizer = None
self.channels = channels
def bulid(self): # build model
image_in = Input((None, None, self.channels))
conv = Conv2D(filters=self.cnn_filter_num,
kernel_size=self.cnn_kernel_size,
strides=(1, 1),
padding='same',
data_format='channels_last')(image_in)
conv = Activation('relu')(conv)
x = conv
for layers in range(8):
x = self._build_residual_block(x)
conv_out = Conv2D(filters=self.channels,
kernel_size=self.cnn_kernel_size,
strides=(1, 1),
padding='same',
data_format='channels_last')(x)
output = Add()([image_in, conv_out])
self.model = Model(image_in, output, name='model')
def _build_residual_block(self, x): # build residual block
x_in = x
x = Conv2D(filters=self.cnn_filter_num,
kernel_size=self.cnn_kernel_size,
strides=(1, 1),
padding='same',
data_format='channels_last')(x)
x = BatchNormalization(axis=-1)(x)
x = Activation('relu')(x)
x = Conv2D(filters=self.cnn_filter_num,
kernel_size=self.cnn_kernel_size,
strides=(1, 1),
padding='same',
data_format='channels_last')(x)
x = BatchNormalization(axis=-1)(x)
x = Add()([x_in, x])
x = Activation("relu")(x)
return x
def predict(self, x): # denoise on input x
if x.ndim == 3:
x = x.reshape(1, x.shape[0], x.shape[1], self.channels)
return self.model.predict_on_batch(x)
def load(self, config_path, model_path): # load model
print('restore model...')
if os.path.exists(config_path) and os.path.exists(model_path):
with open(config_path, 'r') as fp:
self.model = Model.from_config(json.load(fp))
self.model.load_weights(model_path)
return True
return False
def save(self, config_path, model_path): # save model
with open(config_path, 'w') as fp:
json.dump(self.model.get_config(), fp)
self.model.save_weights(model_path)
def compile(self): # choose adam optimizer and set learning rate
self.optimizer = Adam(lr=1e-2)
self.model.compile(optimizer=self.optimizer, loss=self.loss)
def train_generator(self,
data,
epochs=1,
steps_per_epochs=None,
callbacks=None):
self.model.fit_generator(iter(data),
epochs=epochs,
steps_per_epoch=steps_per_epochs,
callbacks=callbacks)
def train(self, data, epochs=1, callbacks=None):
self.model.fit(x=data[0],
y=data[1],
epochs=epochs,
batch_size=8,
callbacks=callbacks)
@staticmethod
def loss(y_true, y_pred): # loss function, mean square error
return 0.5 * K.sum(K.square(y_pred - y_true), axis=-1)
class PolicyValueNet():
"""policy-value network """
def __init__(self, board_width, board_height, model_file=None):
self.board_width = board_width
self.board_height = board_height
self.l2_const = 1e-4 # coef of l2 penalty
if model_file:
# net_params = pickle.load(open(model_file, 'rb'))
# self.model.set_weights(net_params)
self.model = load_model(model_file)
else:
# self.create_policy_value_net()
self.create_policy_value_resnet()
self._loss_train_op()
def create_policy_value_resnet(self):
def _conv_bn_relu(filters=128, kernel_size=(3, 3)):
def f(input):
conv = Conv2D(kernel_size=kernel_size,
filters=filters,
padding="same",
data_format="channels_first",
kernel_regularizer=l2(self.l2_const))(input)
norm = BatchNormalization(axis=1)(conv)
return Activation("relu")(norm)
return f
def _conv_bn(filters=128, kernel_size=(3, 3)):
def f(input):
conv = Conv2D(kernel_size=kernel_size,
filters=filters,
padding="same",
data_format="channels_first",
kernel_regularizer=l2(self.l2_const))(input)
norm = BatchNormalization(axis=1)(conv)
return norm
return f
def _basic_block(nb_filters):
def f(input):
conv1 = _conv_bn_relu(nb_filters, (3, 3))(input)
conv2 = _conv_bn(nb_filters, (3, 3))(conv1)
shortcut = keras.layers.add([conv1, conv2])
return Activation("relu")(shortcut)
return f
in_x = network = Input((4, self.board_width, self.board_height))
network = _basic_block(64)(network)
network = _basic_block(128)(network)
'''
layer1 = Conv2D(filters=64, kernel_size=(3, 3), padding="same", data_format="channels_first",
activation="relu", kernel_regularizer=l2(self.l2_const))(network)
layer2 = Conv2D(filters=64, kernel_size=(3, 3), padding="same", data_format="channels_first",
activation="relu", kernel_regularizer=l2(self.l2_const))(layer1)
network = Conv2D(filters=128, kernel_size=(3, 3), padding="same", data_format="channels_first",
activation="relu", kernel_regularizer=l2(self.l2_const))(network)
'''
# action policy layers
policy_net = Conv2D(filters=4,
kernel_size=(1, 1),
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
policy_net = Flatten()(policy_net)
self.policy_net = Dense(self.board_width * self.board_height,
activation="softmax",
kernel_regularizer=l2(
self.l2_const))(policy_net)
# state value layers
value_net = Conv2D(filters=2,
kernel_size=(1, 1),
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
value_net = Flatten()(value_net)
value_net = Dense(64, kernel_regularizer=l2(self.l2_const))(value_net)
self.value_net = Dense(1,
activation="tanh",
kernel_regularizer=l2(self.l2_const))(value_net)
self.model = Model(in_x, [self.policy_net, self.value_net])
def policy_value(state_input):
state_input_union = np.array(state_input)
results = self.model.predict_on_batch(state_input_union)
return results
self.policy_value = policy_value
def create_policy_value_net(self):
"""create the policy value network """
in_x = network = Input((4, self.board_width, self.board_height))
# conv layers
'''
network = Conv2D(filters=32, kernel_size=(3, 3), padding="same", data_format="channels_first", activation="relu", kernel_regularizer=l2(self.l2_const))(network)
network = Conv2D(filters=64, kernel_size=(3, 3), padding="same", data_format="channels_first", activation="relu", kernel_regularizer=l2(self.l2_const))(network)
network = Conv2D(filters=128, kernel_size=(3, 3), padding="same", data_format="channels_first", activation="relu", kernel_regularizer=l2(self.l2_const))(network)
'''
layer1 = Conv2D(filters=64,
kernel_size=(3, 3),
padding="same",
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
layer2 = Conv2D(filters=64,
kernel_size=(3, 3),
padding="same",
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(layer1)
network = Conv2D(filters=128,
kernel_size=(3, 3),
padding="same",
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
# action policy layers
policy_net = Conv2D(filters=4,
kernel_size=(1, 1),
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
policy_net = Flatten()(policy_net)
self.policy_net = Dense(self.board_width * self.board_height,
activation="softmax",
kernel_regularizer=l2(
self.l2_const))(policy_net)
# state value layers
value_net = Conv2D(filters=2,
kernel_size=(1, 1),
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
value_net = Flatten()(value_net)
value_net = Dense(64, kernel_regularizer=l2(self.l2_const))(value_net)
self.value_net = Dense(1,
activation="tanh",
kernel_regularizer=l2(self.l2_const))(value_net)
self.model = Model(in_x, [self.policy_net, self.value_net])
'''
def policy_value(state_input):
state_input_union = np.array(state_input)
results = self.model.predict_on_batch(state_input_union)
return results
self.policy_value = policy_value
'''
def policy_value_fn(self, board):
"""
input: board
output: a list of (action, probability) tuples for each available action and the score of the board state
"""
legal_positions = board.availables
current_state = board.current_state()
act_probs, value = self.policy_value(
current_state.reshape(-1, 4, self.board_width, self.board_height))
act_probs = zip(legal_positions, act_probs.flatten()[legal_positions])
return act_probs, value[0][0]
def _loss_train_op(self):
"""
Three loss terms：
loss = (z - v)^2 + pi^T * log(p) + c||theta||^2
"""
# get the train op
opt = Adam()
losses = ['categorical_crossentropy', 'mean_squared_error']
self.model.compile(optimizer=opt, loss=losses)
def self_entropy(probs):
return -np.mean(np.sum(probs * np.log(probs + 1e-10), axis=1))
def train_step(state_input, mcts_probs, winner, learning_rate):
state_input_union = np.array(state_input)
mcts_probs_union = np.array(mcts_probs)
winner_union = np.array(winner)
loss = self.model.evaluate(state_input_union,
[mcts_probs_union, winner_union],
batch_size=len(state_input),
verbose=0)
action_probs, _ = self.model.predict_on_batch(state_input_union)
entropy = self_entropy(action_probs)
K.set_value(self.model.optimizer.lr, learning_rate)
self.model.fit(state_input_union, [mcts_probs_union, winner_union],
batch_size=len(state_input),
verbose=0)
return loss[0], entropy
self.train_step = train_step
def get_policy_param(self):
net_params = self.model.get_weights()
return net_params
def save_model(self, model_file):
""" save model params to file """
# net_params = self.get_policy_param()
# pickle.dump(net_params, open(model_file, 'wb'), protocol=2)
# self.model.save_weights(model_file)
self.model.save(model_file)
@staticmethod
def _shortcut(self, input, residual):
stride_width = input._keras_shape[2] / residual._keras_shape[2]
stride_height = input._keras_shape[3] / residual._keras_shape[3]
equal_channels = residual._keras_shape[1] == input._keras_shape[1]
shortcut = input
if stride_width > 1 or stride_height > 1 or not equal_channels:
shortcut = Conv2D(nb_filter=residual._keras_shape[1],
nb_row=1,
nb_col=1,
subsample=(stride_width, stride_height),
init="he_normal",
border_mode="valid")(input)
return merge([shortcut, residual], mode="sum")
@staticmethod
def _residual_block(self,
block_function,
nb_filters,
repetations,
is_first_layer=False):
def f(input):
for i in range(repetations):
init_subsample = (1, 1)
if i == 0 and not is_first_layer:
init_subsample = (2, 2)
input = block_function(nb_filters=nb_filters,
init_subsample=init_subsample)(input)
return input
return f
def resnet(self):
from keras.layers.convolutional import MaxPooling2D, AveragePooling2D
input = Input(shape=(3, 224, 224))
conv1 = self._conv_bn_relu(nb_filter=64,
nb_row=7,
nb_col=7,
subsample=(2, 2))(input)
pool1 = MaxPooling2D(pool_size=(3, 3),
strides=(2, 2),
border_mode="same")(conv1)
# Build residual blocks..
block_fn = self._basic_block
block1 = self._residual_block(block_fn,
nb_filters=64,
repetations=3,
is_first_layer=True)(pool1)
block2 = self._residual_block(block_fn, nb_filters=128,
repetations=4)(block1)
block3 = self._residual_block(block_fn, nb_filters=256,
repetations=6)(block2)
block4 = self._residual_block(block_fn, nb_filters=512,
repetations=3)(block3)
# Classifier block
pool2 = AveragePooling2D(pool_size=(7, 7),
strides=(1, 1),
border_mode="same")(block4)
flatten1 = Flatten()(pool2)
dense = Dense(output_dim=1000, init="he_normal",
activation="softmax")(flatten1)
model = Model(input=input, output=dense)
return model
class PolicyValueNet(object):
""" AlphaGoZero-like Policy Value Net. """
def __init__(self, size, saved_weights=None):
""" Initialize Attributes. """
self.size = size # board edge size
self.l2_const = 1e-4 # coef of l2 penalty
self.build_network() # build neural network
if saved_weights:
self.model.set_weights(pickle.load(open(saved_weights, 'rb')))
def build_network(self):
""" Build the Policy Value Neural Net using Keras. """
inputs = Input(shape=(4, self.size, self.size))
# 3 common conv layers
c_conv1 = Conv2D(filters=32,
kernel_size=(3, 3),
padding="same",
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(inputs)
c_conv2 = Conv2D(filters=64,
kernel_size=(3, 3),
padding="same",
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(c_conv1)
c_conv3 = Conv2D(filters=128,
kernel_size=(3, 3),
padding="same",
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(c_conv2)
# policy head
p_conv = Conv2D(filters=4,
kernel_size=(1, 1),
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(c_conv3)
p_flat = Flatten()(p_conv)
self.policy_net = Dense(self.size * self.size,
activation="softmax",
kernel_regularizer=l2(self.l2_const))(p_flat)
# value head
v_conv = Conv2D(filters=2,
kernel_size=(1, 1),
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(c_conv3)
v_flat = Flatten()(v_conv)
v_dense = Dense(64, kernel_regularizer=l2(self.l2_const))(v_flat)
self.value_net = Dense(1,
activation="tanh",
kernel_regularizer=l2(self.l2_const))(v_dense)
# connect and build the model
self.model = Model(inputs, [self.policy_net, self.value_net])
losses = ['categorical_crossentropy', 'mean_squared_error']
self.model.compile(optimizer=Adam(), loss=losses)
def get_state(self, go):
""" Convert the go board data to a state of 4 boards.
The 4 boards are: the agent's pieces, the opponent's pieces,
difference from previous board, move first or not.
Params: go: a GO object.
Returns: a (4, 5, 5) numpy array.
"""
piece_type = 1 if go.X_move else 2
cur_board = np.array(go.board)
state = np.zeros((4, self.size, self.size))
if go.previous_board:
pre_board = np.array(go.previous_board)
state[0] = (cur_board == piece_type).astype(float)
state[1] = (cur_board == 3 - piece_type).astype(float)
state[2] = (cur_board != pre_board).astype(float)
if piece_type == 1:
state[3][:, :] = 1.0
return state[:, ::-1, :]
def policy(self, go):
""" Policy function for current go board.
Params: go: a go object.
Returns: (move, prob) tuples and corresponding values.
"""
piece_type = 1 if go.X_move else 2
candidates = []
for i in range(go.size**2):
row, col = i // go.size, i % go.size
if go.valid_place_check(row, col, piece_type):
candidates.append(i)
cur_state = self.get_state(go)
# expand dimension to predict
move_probs, value = self.model.predict_on_batch(
np.array(cur_state.reshape(-1, 4, self.size, self.size)))
move_probs = zip(candidates, move_probs.flatten()[candidates])
return move_probs, value[0][0]
def get_entropy(self, probs):
""" Return entropy according to move probabilities. """
return -np.mean(np.sum(probs * np.log(probs + 1e-10), axis=1))
def train_core(self, states, mcts_probs, winners, lr):
""" Training core function, performs one step of training.
Params:
states: list or numpy array, training data.
mcts_probs: list or numpy array, training labels.
winners: list or numpy array, training labels.
lr: float, learning rate.
Returns: tuple of floats, loss and entropy
"""
states = np.array(states)
mcts_probs = np.array(mcts_probs)
winners = np.array(winners)
loss = self.model.evaluate(states, [mcts_probs, winners],
batch_size=states.shape[0],
verbose=0)
move_probs, _ = self.model.predict_on_batch(states)
entropy = self.get_entropy(move_probs)
K.set_value(self.model.optimizer.lr, lr)
self.model.fit(states, [mcts_probs, winners],
batch_size=states.shape[0],
verbose=0)
return loss[0], entropy
def get_weights(self):
""" Return model weights. """
return self.model.get_weights()
def save_weights(self, data_path='best_model.model'):
""" Save model weights. """
pickle.dump(self.get_weights(), open(data_path, 'wb'), protocol=2)
class PolicyValueNet():
"""policy-value network """
def __init__(self, board_width, board_height, model_file=None):
self.board_width = board_width
self.board_height = board_height
self.l2_const = 1e-4 # coef of l2 penalty
self.create_policy_value_net()
self._loss_train_op()
if model_file:
net_params = pickle.load(open(model_file, 'rb'))
self.model.set_weights(net_params)
def create_policy_value_net(self):
"""create the policy value network """
in_x = network = Input((4, self.board_width, self.board_height))
# conv layers
network = Conv2D(filters=32, kernel_size=(3, 3), padding="same", data_format="channels_first", activation="relu", kernel_regularizer=l2(self.l2_const))(network)
network = Conv2D(filters=64, kernel_size=(3, 3), padding="same", data_format="channels_first", activation="relu", kernel_regularizer=l2(self.l2_const))(network)
network = Conv2D(filters=128, kernel_size=(3, 3), padding="same", data_format="channels_first", activation="relu", kernel_regularizer=l2(self.l2_const))(network)
# action policy layers
policy_net = Conv2D(filters=4, kernel_size=(1, 1), data_format="channels_first", activation="relu", kernel_regularizer=l2(self.l2_const))(network)
policy_net = Flatten()(policy_net)
self.policy_net = Dense(self.board_width*self.board_height, activation="softmax", kernel_regularizer=l2(self.l2_const))(policy_net)
# state value layers
value_net = Conv2D(filters=2, kernel_size=(1, 1), data_format="channels_first", activation="relu", kernel_regularizer=l2(self.l2_const))(network)
value_net = Flatten()(value_net)
value_net = Dense(64, kernel_regularizer=l2(self.l2_const))(value_net)
self.value_net = Dense(1, activation="tanh", kernel_regularizer=l2(self.l2_const))(value_net)
self.model = Model(in_x, [self.policy_net, self.value_net])
def policy_value(state_input):
state_input_union = np.array(state_input)
results = self.model.predict_on_batch(state_input_union)
return results
self.policy_value = policy_value
def policy_value_fn(self, board):
"""
input: board
output: a list of (action, probability) tuples for each available action and the score of the board state
"""
legal_positions = board.availables
current_state = board.current_state()
act_probs, value = self.policy_value(current_state.reshape(-1, 4, self.board_width, self.board_height))
act_probs = zip(legal_positions, act_probs.flatten()[legal_positions])
return act_probs, value[0][0]
def _loss_train_op(self):
"""
Three loss terms：
loss = (z - v)^2 + pi^T * log(p) + c||theta||^2
"""
# get the train op
opt = Adam()
losses = ['categorical_crossentropy', 'mean_squared_error']
self.model.compile(optimizer=opt, loss=losses)
def self_entropy(probs):
return -np.mean(np.sum(probs * np.log(probs + 1e-10), axis=1))
def train_step(state_input, mcts_probs, winner, learning_rate):
state_input_union = np.array(state_input)
mcts_probs_union = np.array(mcts_probs)
winner_union = np.array(winner)
loss = self.model.evaluate(state_input_union, [mcts_probs_union, winner_union], batch_size=len(state_input), verbose=0)
action_probs, _ = self.model.predict_on_batch(state_input_union)
entropy = self_entropy(action_probs)
K.set_value(self.model.optimizer.lr, learning_rate)
self.model.fit(state_input_union, [mcts_probs_union, winner_union], batch_size=len(state_input), verbose=0)
return loss[0], entropy
self.train_step = train_step
def get_policy_param(self):
net_params = self.model.get_weights()
return net_params
def save_model(self, model_file):
""" save model params to file """
net_params = self.get_policy_param()
pickle.dump(net_params, open(model_file, 'wb'), protocol=2)
class PolicyValueNet():
"""policy-value network """
def __init__(self, model_file=None):
self.l2_const = 1e-4 # coef of l2 penaltyd
self.create_policy_value_net()
self._loss_train_op()
if model_file:
net_params = pickle.load(open(model_file, 'rb'))
self.model.set_weights(net_params)
plot_model(self.model, to_file='model.png')
def create_policy_value_net(self):
"""create the policy value network """
in_x = network = Input((13,))
# conv layers
network = Dense(64, activation='relu', kernel_regularizer=l2(self.l2_const))(network)
network = Dense(64, activation='relu', kernel_regularizer=l2(self.l2_const))(network)
network = Dense(32, activation='relu', kernel_regularizer=l2(self.l2_const))(network)
network = Dense(32, activation='relu', kernel_regularizer=l2(self.l2_const))(network)
self.policy_net = Dense(6, activation='softmax', kernel_regularizer=l2(self.l2_const))(network)
# state value layers
self.value_net = Dense(1, activation='tanh', kernel_regularizer=l2(self.l2_const))(network)
self.model = Model(in_x, [self.policy_net, self.value_net])
def policy_value(state_input):
state_input_union = np.array(state_input)
results = self.model.predict_on_batch(state_input_union)
return results
self.policy_value = policy_value
def policy_value_fn(self, board):
"""
input: board
output: a list of (action, probability) tuples for each available action and the score of the board state
"""
#legal_positions = board.availables
#print(board.current_state())
current_state = board.current_state()
act_probs, value = self.policy_value( np.expand_dims(current_state ,0))
#print(act_probs[0])
#act_probs = zip(legal_positions, act_probs[0][legal_positions])
actret = [(i, act_probs[0][i]) for i in range(6)]
#print(board.current_state(), actret)
return actret, value[0]
def _loss_train_op(self):
"""
Three loss terms：
loss = (z - v)^2 + pi^T * log(p) + c||theta||^2
"""
# get the train op
opt = Adam()
losses = ['categorical_crossentropy', 'mean_squared_error']
self.model.compile(optimizer=opt, loss=losses)
def self_entropy(probs):
return -np.mean(np.sum(probs * np.log(probs + 1e-10), axis=1))
def train_step(state_input, mcts_probs, winner, learning_rate):
state_input_union = np.array(state_input)
mcts_probs_union = np.array(mcts_probs)
winner_union = np.array(winner)
#print(mcts_probs_union)
loss = self.model.evaluate(state_input_union, [mcts_probs_union, winner_union], batch_size=len(state_input), verbose=0)
action_probs, _ = self.model.predict_on_batch(state_input_union)
entropy = self_entropy(action_probs)
K.set_value(self.model.optimizer.lr, learning_rate)
self.model.fit(state_input_union, [mcts_probs_union, winner_union], batch_size=len(state_input), verbose=0)
return loss[0], entropy
self.train_step = train_step
def get_policy_param(self):
net_params = self.model.get_weights()
return net_params
def save_model(self, model_file):
""" save model params to file """
net_params = self.get_policy_param()
pickle.dump(net_params, open(model_file, 'wb'), protocol=2)
def test_model_methods():
a = Input(shape=(3, ), name='input_a')
b = Input(shape=(3, ), name='input_b')
a_2 = Dense(4, name='dense_1')(a)
dp = Dropout(0.5, name='dropout')
b_2 = dp(b)
model = Model([a, b], [a_2, b_2])
optimizer = 'rmsprop'
loss = 'mse'
loss_weights = [1., 0.5]
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
# training/testing doesn't work before compiling.
with pytest.raises(RuntimeError):
model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
model.compile(optimizer,
loss,
metrics=[],
loss_weights=loss_weights,
sample_weight_mode=None)
# test train_on_batch
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out = model.train_on_batch({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np])
out = model.train_on_batch({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
})
# test fit
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
epochs=1,
batch_size=4)
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np],
epochs=1,
batch_size=4)
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
},
epochs=1,
batch_size=4)
# test validation_split
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
epochs=1,
batch_size=4,
validation_split=0.5)
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np],
epochs=1,
batch_size=4,
validation_split=0.5)
# test validation data
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
epochs=1,
batch_size=4,
validation_data=([input_a_np,
input_b_np], [output_a_np, output_b_np]))
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np],
epochs=1,
batch_size=4,
validation_split=0.5,
validation_data=({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np]))
out = model.fit({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
},
epochs=1,
batch_size=4,
validation_split=0.5,
validation_data=({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
}))
# test_on_batch
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out = model.test_on_batch({
'input_a': input_a_np,
'input_b': input_b_np
}, [output_a_np, output_b_np])
out = model.test_on_batch({
'input_a': input_a_np,
'input_b': input_b_np
}, {
'dense_1': output_a_np,
'dropout': output_b_np
})
# predict_on_batch
out = model.predict_on_batch([input_a_np, input_b_np])
out = model.predict_on_batch({
'input_a': input_a_np,
'input_b': input_b_np
})
# predict, evaluate
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
out = model.evaluate([input_a_np, input_b_np], [output_a_np, output_b_np],
batch_size=4)
out = model.predict([input_a_np, input_b_np], batch_size=4)
# with sample_weight
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
sample_weight = [None, np.random.random((10, ))]
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
# test accuracy metric
model.compile(optimizer, loss, metrics=['acc'], sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 5
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 5
# this should also work
model.compile(optimizer,
loss,
metrics={'dense_1': 'acc'},
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
# and this as well
model.compile(optimizer,
loss,
metrics={'dense_1': ['acc']},
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
# test starting from non-zero initial epoch
trained_epochs = []
trained_batches = []
# define tracer callback
def on_epoch_begin(epoch, logs):
trained_epochs.append(epoch)
def on_batch_begin(batch, logs):
trained_batches.append(batch)
tracker_cb = LambdaCallback(on_epoch_begin=on_epoch_begin,
on_batch_begin=on_batch_begin)
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
epochs=5,
batch_size=4,
initial_epoch=2,
callbacks=[tracker_cb])
assert trained_epochs == [2, 3, 4]
# test starting from non-zero initial epoch for generator too
trained_epochs = []
def gen_data(batch_sz):
while True:
yield ([
np.random.random((batch_sz, 3)),
np.random.random((batch_sz, 3))
], [
np.random.random((batch_sz, 4)),
np.random.random((batch_sz, 3))
])
out = model.fit_generator(gen_data(4),
steps_per_epoch=3,
epochs=5,
initial_epoch=2,
callbacks=[tracker_cb])
assert trained_epochs == [2, 3, 4]
# test with a custom metric function
def mse(y_true, y_pred):
return K.mean(K.pow(y_true - y_pred, 2))
model.compile(optimizer, loss, metrics=[mse], sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out_len = 1 + 2 * (1 + 1) # total loss + 2 outputs * (loss + metric)
assert len(out) == out_len
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == out_len
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
batch_size=4,
epochs=1)
out = model.evaluate([input_a_np, input_b_np], [output_a_np, output_b_np],
batch_size=4)
out = model.predict([input_a_np, input_b_np], batch_size=4)
# empty batch
with pytest.raises(ValueError):
def gen_data():
while True:
yield (np.asarray([]), np.asarray([]))
out = model.evaluate_generator(gen_data(), steps=1)
# x is not a list of numpy arrays.
with pytest.raises(ValueError):
out = model.predict([None])
# x does not match _feed_input_names.
with pytest.raises(ValueError):
out = model.predict([input_a_np, None, input_b_np])
with pytest.raises(ValueError):
out = model.predict([None, input_a_np, input_b_np])
# all input/output/weight arrays should have the same number of samples.
with pytest.raises(ValueError):
out = model.train_on_batch([input_a_np, input_b_np[:2]],
[output_a_np, output_b_np],
sample_weight=sample_weight)
with pytest.raises(ValueError):
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np[:2]],
sample_weight=sample_weight)
with pytest.raises(ValueError):
out = model.train_on_batch(
[input_a_np, input_b_np], [output_a_np, output_b_np],
sample_weight=[sample_weight[1], sample_weight[1][:2]])
# `sample_weight` is neither a dict nor a list.
with pytest.raises(TypeError):
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=tuple(sample_weight))
# `validation_data` is neither a tuple nor a triple.
with pytest.raises(ValueError):
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np],
epochs=1,
batch_size=4,
validation_data=([input_a_np, input_b_np], ))
# `loss` does not match outputs.
with pytest.raises(ValueError):
model.compile(optimizer, loss=['mse', 'mae', 'mape'])
# `loss_weights` does not match output_names.
with pytest.raises(ValueError):
model.compile(optimizer, loss='mse', loss_weights={'lstm': 0.5})
# `loss_weights` does not match outputs.
with pytest.raises(ValueError):
model.compile(optimizer, loss='mse', loss_weights=[0.5])
# `loss_weights` is invalid type.
with pytest.raises(TypeError):
model.compile(optimizer, loss='mse', loss_weights=(0.5, 0.5))
# `sample_weight_mode` does not match output_names.
with pytest.raises(ValueError):
model.compile(optimizer,
loss='mse',
sample_weight_mode={'lstm': 'temporal'})
# `sample_weight_mode` does not match output_names.
with pytest.raises(ValueError):
model.compile(optimizer, loss='mse', sample_weight_mode=['temporal'])
# `sample_weight_mode` matches output_names partially.
with pytest.raises(ValueError):
model.compile(optimizer,
loss='mse',
sample_weight_mode={'dense_1': 'temporal'})
# `loss` does not exist.
with pytest.raises(ValueError):
model.compile(optimizer, loss=[])
model.compile(optimizer, loss=['mse', 'mae'])
model.compile(optimizer,
loss='mse',
loss_weights={
'dense_1': 0.2,
'dropout': 0.8
})
model.compile(optimizer, loss='mse', loss_weights=[0.2, 0.8])
# the rank of weight arrays should be 1.
with pytest.raises(ValueError):
out = model.train_on_batch(
[input_a_np, input_b_np], [output_a_np, output_b_np],
sample_weight=[None, np.random.random((10, 20, 30))])
model.compile(optimizer,
loss='mse',
sample_weight_mode={
'dense_1': None,
'dropout': 'temporal'
})
model.compile(optimizer, loss='mse', sample_weight_mode=[None, 'temporal'])
# the rank of output arrays should be at least 3D.
with pytest.raises(ValueError):
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
model.compile(optimizer,
loss,
metrics=[],
loss_weights=loss_weights,
sample_weight_mode=None)
trained_epochs = []
trained_batches = []
out = model.fit_generator(generator=RandomSequence(3),
steps_per_epoch=3,
epochs=5,
initial_epoch=0,
validation_data=RandomSequence(4),
validation_steps=3,
callbacks=[tracker_cb])
assert trained_epochs == [0, 1, 2, 3, 4]
assert trained_batches == list(range(3)) * 5
# steps_per_epoch will be equal to len of sequence if it's unspecified
trained_epochs = []
trained_batches = []
out = model.fit_generator(generator=RandomSequence(3),
epochs=5,
initial_epoch=0,
validation_data=RandomSequence(4),
callbacks=[tracker_cb])
assert trained_epochs == [0, 1, 2, 3, 4]
assert trained_batches == list(range(12)) * 5
# fit_generator will throw an exception if steps is unspecified for regular generator
with pytest.raises(ValueError):
def gen_data():
while True:
yield (np.asarray([]), np.asarray([]))
out = model.fit_generator(generator=gen_data(),
epochs=5,
initial_epoch=0,
validation_data=gen_data(),
callbacks=[tracker_cb])
# predict_generator output shape behavior should be consistent
def expected_shape(batch_size, n_batches):
return (batch_size * n_batches, 4), (batch_size * n_batches, 3)
# Multiple outputs and one step.
batch_size = 5
sequence_length = 1
shape_0, shape_1 = expected_shape(batch_size, sequence_length)
out = model.predict_generator(
RandomSequence(batch_size, sequence_length=sequence_length))
assert np.shape(out[0]) == shape_0 and np.shape(out[1]) == shape_1
# Multiple outputs and multiple steps.
batch_size = 5
sequence_length = 2
shape_0, shape_1 = expected_shape(batch_size, sequence_length)
out = model.predict_generator(
RandomSequence(batch_size, sequence_length=sequence_length))
assert np.shape(out[0]) == shape_0 and np.shape(out[1]) == shape_1
# Create a model with a single output.
single_output_model = Model([a, b], a_2)
single_output_model.compile(optimizer,
loss,
metrics=[],
sample_weight_mode=None)
# Single output and one step.
batch_size = 5
sequence_length = 1
shape_0, _ = expected_shape(batch_size, sequence_length)
out = single_output_model.predict_generator(
RandomSequence(batch_size, sequence_length=sequence_length))
assert np.shape(out) == shape_0
# Single output and multiple steps.
batch_size = 5
sequence_length = 2
shape_0, _ = expected_shape(batch_size, sequence_length)
out = single_output_model.predict_generator(
RandomSequence(batch_size, sequence_length=sequence_length))
assert np.shape(out) == shape_0
class Network:
def __init__(self, conf):
# All hyperparameters used in the model
self._board_size = conf['board_size'] # the size of the playing board
self._lr = conf['learning_rate'] # learning rate of SGD (2e-3)
self._momentum = conf['momentum'] # nesterov momentum (1e-1)
self._l2_coef = conf['l2'] # coefficient of L2 penalty (1e-4)
self._mini_batch_size = conf['mini_batch_size'] # the size of batch when training the network
self._fit_epochs = conf['fit_epochs'] # the number of iteration
# Define Network
self._build_network()
# The location of the file which stores the parameters of the network
self._net_para_file = conf['net_para_file']
self._fit_history_file = conf['fit_history_file']
# Whether we use previous model or not
self._use_previous_model = conf['use_previous_model']
if self._use_previous_model:
if os.path.exists(self._net_para_file):
self._model.load_weights(self._net_para_file)
else:
print('> error: [use_previous_model] = True, ' + self._net_para_file + ' not found')
@log
def _build_network(self):
# Input_Layer
init_x = Input((3, self._board_size, self._board_size)) # the input is a tensor with the shape 3*(15*15)
x = init_x
# First Convolutional Layer with 32 filters
x = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), padding='same',
data_format='channels_first', kernel_regularizer=l2(self._l2_coef))(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# Two Residual Blocks
x = self._residual_block(x)
x = self._residual_block(x)
x = self._residual_block(x)
# Policy Head for generating prior probability vector for each action
policy = Conv2D(filters=2, kernel_size=(1, 1), strides=(1, 1), padding='same',
data_format='channels_first', kernel_regularizer=l2(self._l2_coef))(x)
policy = BatchNormalization()(policy)
policy = Activation('relu')(policy)
policy = Flatten()(policy)
policy = Dense(self._board_size*self._board_size, kernel_regularizer=l2(self._l2_coef))(policy)
self._policy = Activation('softmax')(policy)
# Value Head for generating value of each action
value = Conv2D(filters=1, kernel_size=(1, 1), strides=(1, 1), padding='same',
data_format="channels_first", kernel_regularizer=l2(self._l2_coef))(x)
value = BatchNormalization()(value)
value = Activation('relu')(value)
value = Flatten()(value)
value = Dense(32, kernel_regularizer=l2(self._l2_coef))(value)
value = Activation('relu')(value)
value = Dense(1, kernel_regularizer=l2(self._l2_coef))(value)
self._value = Activation('tanh')(value)
# Define Network
self._model = Model(inputs=init_x, outputs=[self._policy, self._value])
# Define the Loss Function
opt = SGD(lr=self._lr, momentum=self._momentum, nesterov=True) # stochastic gradient descend with momentum
losses_type = ['categorical_crossentropy', 'mean_squared_error'] # cross-entrophy and MSE are weighted equally
self._model.compile(optimizer=opt, loss=losses_type)
def _residual_block(self, x):
x_shortcut = x
x = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), padding='same',
data_format="channels_first", kernel_regularizer=l2(self._l2_coef))(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(filters=32, kernel_size=(3, 3), strides=(1, 1), padding='same',
data_format="channels_first", kernel_regularizer=l2(self._l2_coef))(x)
x = BatchNormalization()(x)
x = add([x, x_shortcut]) # Skip Connection
x = Activation('relu')(x)
return x
def predict(self, board, color, last_move):
if sum(sum(board)) == 0 and color == WHITE:
print('error: network.predict')
if sum(sum(board)) == 1 and color == BLACK:
print('error: network.predict')
tensor = board2tensor(board, color, last_move)
policy, value_tensor = self._model.predict_on_batch(tensor)
value = value_tensor[0][0]
return policy, value
def train(self, board_list, color_list, last_move_list, pi_list, z_list):
size = len(color_list)
for i in range(size):
if sum(sum(board_list[i])) == 0 and color_list[i] == WHITE:
print('error: network.train')
if sum(sum(board_list[i])) == 1 and color_list[i] == BLACK:
print('error: network.train')
# Data Augmentation through symmetric and self-rotation transformation
board_aug = []
color_aug = []
last_move_aug = []
pi_aug = []
z_aug = []
for i in range(len(board_list)):
new_board, new_color, new_last_move, new_pi, new_z = \
data_augmentation(board_list[i], color_list[i], last_move_list[i], pi_list[i], z_list[i])
board_aug.extend(new_board)
color_aug.extend(new_color)
last_move_aug.extend(new_last_move)
pi_aug.extend(new_pi)
z_aug.extend(new_z)
board_list.extend(board_aug)
color_list.extend(color_aug)
last_move_list.extend(last_move_aug)
pi_list.extend(pi_aug)
z_list.extend(z_aug)
# Regularize Data
board_list = np.array([board2tensor(board_list[i], color_list[i], last_move_list[i], reshape_flag=False)
for i in range(len(board_list))])
pi_list = np.array(pi_list)
z_list = np.array(z_list)
# Training
hist = self._model.fit(board_list, [pi_list, z_list], epochs=self._fit_epochs, batch_size=self._mini_batch_size, verbose=1)
hist_path = self._fit_history_file + '_' + str(self._fit_epochs) + '_' + str(self._mini_batch_size) + '.txt'
with open(hist_path, 'a') as f:
f.write(str(hist.history))
return hist.history['loss'][0] # only sample loss of first epoch
def get_para(self):
net_para = self._model.get_weights()
return net_para
def save_model(self):
""" save model para to file """
self._model.save_weights(self._net_para_file)
def load_model(self):
if os.path.exists(self._net_para_file):
self._model.load_weights(self._net_para_file)
else:
print('> error: ' + self._net_para_file + ' not found')
def test_pandas_dataframe():
input_a = Input(shape=(3, ), name='input_a')
input_b = Input(shape=(3, ), name='input_b')
x = Dense(4, name='dense_1')(input_a)
y = Dense(3, name='desne_2')(input_b)
model_1 = Model(inputs=input_a, outputs=x)
model_2 = Model(inputs=[input_a, input_b], outputs=[x, y])
optimizer = 'rmsprop'
loss = 'mse'
model_1.compile(optimizer=optimizer, loss=loss)
model_2.compile(optimizer=optimizer, loss=loss)
input_a_df = pd.DataFrame(np.random.random((10, 3)))
input_b_df = pd.DataFrame(np.random.random((10, 3)))
output_a_df = pd.DataFrame(np.random.random((10, 4)))
output_b_df = pd.DataFrame(np.random.random((10, 3)))
model_1.fit(input_a_df, output_a_df)
model_2.fit([input_a_df, input_b_df], [output_a_df, output_b_df])
model_1.fit([input_a_df], [output_a_df])
model_1.fit({'input_a': input_a_df}, output_a_df)
model_2.fit({
'input_a': input_a_df,
'input_b': input_b_df
}, [output_a_df, output_b_df])
model_1.predict(input_a_df)
model_2.predict([input_a_df, input_b_df])
model_1.predict([input_a_df])
model_1.predict({'input_a': input_a_df})
model_2.predict({'input_a': input_a_df, 'input_b': input_b_df})
model_1.predict_on_batch(input_a_df)
model_2.predict_on_batch([input_a_df, input_b_df])
model_1.predict_on_batch([input_a_df])
model_1.predict_on_batch({'input_a': input_a_df})
model_2.predict_on_batch({'input_a': input_a_df, 'input_b': input_b_df})
model_1.evaluate(input_a_df, output_a_df)
model_2.evaluate([input_a_df, input_b_df], [output_a_df, output_b_df])
model_1.evaluate([input_a_df], [output_a_df])
model_1.evaluate({'input_a': input_a_df}, output_a_df)
model_2.evaluate({
'input_a': input_a_df,
'input_b': input_b_df
}, [output_a_df, output_b_df])
model_1.train_on_batch(input_a_df, output_a_df)
model_2.train_on_batch([input_a_df, input_b_df],
[output_a_df, output_b_df])
model_1.train_on_batch([input_a_df], [output_a_df])
model_1.train_on_batch({'input_a': input_a_df}, output_a_df)
model_2.train_on_batch({
'input_a': input_a_df,
'input_b': input_b_df
}, [output_a_df, output_b_df])
model_1.test_on_batch(input_a_df, output_a_df)
model_2.test_on_batch([input_a_df, input_b_df], [output_a_df, output_b_df])
model_1.test_on_batch([input_a_df], [output_a_df])
model_1.test_on_batch({'input_a': input_a_df}, output_a_df)
model_2.test_on_batch({
'input_a': input_a_df,
'input_b': input_b_df
}, [output_a_df, output_b_df])
class Network():
def __init__(self, conf):
# Some Hyperparameters
self._board_size = conf['board_size'] # the size of the playing board
self._lr = conf['learning_rate'] # learning rate of SGD (2e-3)
self._momentum = conf['momentum'] # nesterov momentum (1e-1)
self._l2_coef = conf['l2'] # coefficient of L2 penalty (1e-4)
# Define Network
self._build_network()
# File Location
self._net_para_file = conf['net_para_file']
# If we use previous model or not
self._use_previous_model = conf['use_previous_model']
if self._use_previous_model:
net_para = self._model.load_weights(self._net_para_file)
self._model.set_weights(net_para)
def _build_network(self):
# Input_Layer
init_x = Input((3, self._board_size, self._board_size))
x = init_x
# Convolutional Layer
x = Conv2D(filters=32,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
data_format='channels_first',
kernel_regularizer=l2(self._l2_coef))(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
# Residual Layer
x = self._residual_block(x)
x = self._residual_block(x)
x = self._residual_block(x)
# Policy Head
policy = Conv2D(filters=2,
kernel_size=(1, 1),
strides=(1, 1),
padding='same',
data_format='channels_first',
kernel_regularizer=l2(self._l2_coef))(x)
policy = BatchNormalization()(policy)
policy = Activation('relu')(policy)
policy = Flatten()(policy)
policy = Dense(self._board_size * self._board_size,
kernel_regularizer=l2(self._l2_coef))(policy)
self._policy = Activation('softmax')(policy)
# Value Head
value = Conv2D(filters=1,
kernel_size=(1, 1),
strides=(1, 1),
padding='same',
data_format="channels_first",
kernel_regularizer=l2(self._l2_coef))(x)
value = BatchNormalization()(value)
value = Activation('relu')(value)
value = Flatten()(value)
value = Dense(32, kernel_regularizer=l2(self._l2_coef))(value)
value = Activation('relu')(value)
value = Dense(1, kernel_regularizer=l2(self._l2_coef))(value)
self._value = Activation('tanh')(value)
# Define Network
self._model = Model(inputs=init_x, outputs=[self._policy, self._value])
# Define the Loss Function
opt = SGD(lr=self._lr, momentum=self._momentum, nesterov=True)
losses_type = ['categorical_crossentropy', 'mean_squared_error']
self._model.compile(optimizer=opt, loss=losses_type)
def _residual_block(self, x):
x_shortcut = x
x = Conv2D(filters=32,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
data_format="channels_first",
kernel_regularizer=l2(self._l2_coef))(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(filters=32,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
data_format="channels_first",
kernel_regularizer=l2(self._l2_coef))(x)
x = BatchNormalization()(x)
x = add([x, x_shortcut]) # Skip Connection
x = Activation('relu')(x)
return x
def predict(self, board, color, random_flip=False):
if random_flip:
b_t, method_index = input_transform(board)
tensor_t = board2tensor(b_t, color, reshape_flag=True)
prob_tensor_t, value_tensor = self._model.predict_on_batch(
tensor_t)
policy = output_decode(prob_tensor_t, method_index, board.shape[0])
value = value_tensor[0][0]
return policy, value
else:
tensor = board2tensor(board, color)
policy, value_tensor = self._model.predict_on_batch(tensor)
value = value_tensor[0][0]
return policy, value
def train(self, board_list, color_list, pi_list, z_list):
# Reguliza Data
tensor_list = np.array([
board2tensor(board_list[i], color_list[i], reshape_flag=False)
for i in range(len(board_list))
])
pi_list = np.array(pi_list)
z_list = np.array(z_list)
# Training
self._model.fit(tensor_list, [pi_list, z_list],
epochs=20,
batch_size=len(color_list),
verbose=1)
# Calculate Loss Explicitly
loss = self._model.evaluate(tensor_list, [pi_list, z_list],
batch_size=len(board_list),
verbose=0)
loss = loss[0]
return loss
def get_para(self):
net_para = self._model.get_weights()
return net_para
def save_model(self):
""" save model para to file """
self._model.save_weights(self._net_para_file)
def load_model(self):
self._model.load_weights(self._net_para_file)
def test_model_with_external_loss():
# None loss, only regularization loss.
a = Input(shape=(3, ), name='input_a')
a_2 = Dense(4,
name='dense_1',
kernel_regularizer='l1',
bias_regularizer='l2')(a)
dp = Dropout(0.5, name='dropout')
a_3 = dp(a_2)
model = Model(a, [a_2, a_3])
optimizer = 'rmsprop'
loss = None
model.compile(optimizer, loss, metrics=['mae'])
input_a_np = np.random.random((10, 3))
# test train_on_batch
out = model.train_on_batch(input_a_np, None)
out = model.test_on_batch(input_a_np, None)
# fit
out = model.fit(input_a_np, None)
# evaluate
out = model.evaluate(input_a_np, None)
# No dropout, external loss.
a = Input(shape=(3, ), name='input_a')
a_2 = Dense(4, name='dense_1')(a)
a_3 = Dense(4, name='dense_2')(a)
model = Model(a, [a_2, a_3])
model.add_loss(K.mean(a_3 + a_2))
optimizer = 'rmsprop'
loss = None
model.compile(optimizer, loss, metrics=['mae'])
# test train_on_batch
out = model.train_on_batch(input_a_np, None)
out = model.test_on_batch(input_a_np, None)
# fit
out = model.fit(input_a_np, None)
# evaluate
out = model.evaluate(input_a_np, None)
# Test fit with no external data at all.
if K.backend() == 'tensorflow':
import tensorflow as tf
a = Input(tensor=tf.Variable(input_a_np, dtype=tf.float32))
a_2 = Dense(4, name='dense_1')(a)
a_2 = Dropout(0.5, name='dropout')(a_2)
model = Model(a, a_2)
model.add_loss(K.mean(a_2))
model.compile(optimizer='rmsprop',
loss=None,
metrics=['mean_squared_error'])
# test train_on_batch
out = model.train_on_batch(None, None)
out = model.test_on_batch(None, None)
out = model.predict_on_batch(None)
# test fit
with pytest.raises(ValueError):
out = model.fit(None, None, epochs=1, batch_size=10)
out = model.fit(None, None, epochs=1, steps_per_epoch=1)
# test fit with validation data
with pytest.raises(ValueError):
out = model.fit(None,
None,
epochs=1,
steps_per_epoch=None,
validation_steps=2)
out = model.fit(None,
None,
epochs=1,
steps_per_epoch=2,
validation_steps=2)
# test evaluate
with pytest.raises(ValueError):
out = model.evaluate(None, None, batch_size=10)
out = model.evaluate(None, None, steps=3)
# test predict
with pytest.raises(ValueError):
out = model.predict(None, batch_size=10)
out = model.predict(None, steps=3)
assert out.shape == (10 * 3, 4)
# Test multi-output model without external data.
a = Input(tensor=tf.Variable(input_a_np, dtype=tf.float32))
a_1 = Dense(4, name='dense_1')(a)
a_2 = Dropout(0.5, name='dropout')(a_1)
model = Model(a, [a_1, a_2])
model.add_loss(K.mean(a_2))
model.compile(optimizer='rmsprop',
loss=None,
metrics=['mean_squared_error'])
# test train_on_batch
out = model.train_on_batch(None, None)
out = model.test_on_batch(None, None)
out = model.predict_on_batch(None)
# test fit
with pytest.raises(ValueError):
out = model.fit(None, None, epochs=1, batch_size=10)
out = model.fit(None, None, epochs=1, steps_per_epoch=1)
# test fit with validation data
with pytest.raises(ValueError):
out = model.fit(None,
None,
epochs=1,
steps_per_epoch=None,
validation_steps=2)
out = model.fit(None,
None,
epochs=1,
steps_per_epoch=2,
validation_steps=2)
# test evaluate
with pytest.raises(ValueError):
out = model.evaluate(None, None, batch_size=10)
out = model.evaluate(None, None, steps=3)
# test predict
with pytest.raises(ValueError):
out = model.predict(None, batch_size=10)
out = model.predict(None, steps=3)
assert len(out) == 2
assert out[0].shape == (10 * 3, 4)
assert out[1].shape == (10 * 3, 4)
class PolicyValueNet():
"""策略价值网络"""
def __init__(self, board_width, board_height, model_file=None):
self.board_width = board_width
self.board_height = board_height
self.l2_const = 1e-4 # coef of l2 penalty
self.create_policy_value_net()
self._loss_train_op()
if model_file:
if platform.python_version().split('.')[0] == '3': #python3
net_params = pickle.load(open(model_file, 'rb'), encoding='iso-8859-1')
else:
net_params = pickle.load(open(model_file, 'rb'))
self.model.set_weights(net_params)
def create_policy_value_net(self):
"""创建policy-value网络"""
# 输入层
in_x = network = Input((4, self.board_width, self.board_height))
# conv layers
network = Conv2D(filters=32, kernel_size=(3, 3), padding="same", data_format="channels_first", activation="relu", kernel_regularizer=l2(self.l2_const))(network)
network = Conv2D(filters=64, kernel_size=(3, 3), padding="same", data_format="channels_first", activation="relu", kernel_regularizer=l2(self.l2_const))(network)
network = Conv2D(filters=128, kernel_size=(3, 3), padding="same", data_format="channels_first", activation="relu", kernel_regularizer=l2(self.l2_const))(network)
# 走子策略 action policy layers
policy_net = Conv2D(filters=4, kernel_size=(1, 1), data_format="channels_first", activation="relu", kernel_regularizer=l2(self.l2_const))(network)
policy_net = Flatten()(policy_net)
self.policy_net = Dense(self.board_width * self.board_height, activation="softmax", kernel_regularizer=l2(self.l2_const))(policy_net)
# 盘面价值 state value layers
value_net = Conv2D(filters=2, kernel_size=(1, 1), data_format="channels_first", activation="relu", kernel_regularizer=l2(self.l2_const))(network)
value_net = Flatten()(value_net)
value_net = Dense(64, kernel_regularizer=l2(self.l2_const))(value_net)
self.value_net = Dense(1, activation="tanh", kernel_regularizer=l2(self.l2_const))(value_net)
# 创建网络模型
self.model = Model(in_x, [self.policy_net, self.value_net])
# 返回走子策略和价值概率
def policy_value(state_input):
state_input_union = np.array(state_input)
results = self.model.predict_on_batch(state_input_union)
return results
self.policy_value = policy_value
def policy_value_fn(self, board):
"""使用模型预测棋盘所有可落子位置价值概率"""
# 棋盘所有可落子位置
legal_positions = board.availables
# 当前玩家角度的棋盘方格状态
current_state = board.current_state()
# 使用模型预测走子策略和价值概率
act_probs, value = self.policy_value(current_state.reshape(-1, 4, self.board_width, self.board_height))
act_probs = zip(legal_positions, act_probs.flatten()[legal_positions])
# 返回[(action, 概率)] 以及当前玩家的后续走子value
return act_probs, value[0][0]
def _loss_train_op(self):
"""初始化损失
3个损失函数因子
loss = (z - v)^2 + pi^T * log(p) + c||theta||^2
loss = value损失函数 + policy损失函数 + 惩罚项
"""
# 定义优化器和损失函数
opt = Adam()
losses = ['categorical_crossentropy', 'mean_squared_error']
self.model.compile(optimizer=opt, loss=losses)
def self_entropy(probs):
return -np.mean(np.sum(probs * np.log(probs + 1e-10), axis=1))
def train_step(state_input, mcts_probs, winner, learning_rate):
"""输出训练过程中的结果"""
state_input_union = np.array(state_input)
mcts_probs_union = np.array(mcts_probs)
winner_union = np.array(winner)
# 评估
loss = self.model.evaluate(state_input_union, [mcts_probs_union, winner_union], batch_size=len(state_input), verbose=0)
# 预测
action_probs, _ = self.model.predict_on_batch(state_input_union)
entropy = self_entropy(action_probs)
K.set_value(self.model.optimizer.lr, learning_rate)
self.model.fit(state_input_union, [mcts_probs_union, winner_union], batch_size=len(state_input), verbose=0)
return loss[0], entropy
self.train_step = train_step
def get_policy_param(self):
"""获得模型参数"""
net_params = self.model.get_weights()
return net_params
def save_model(self, model_file):
"""保存模型参数到文件"""
net_params = self.get_policy_param()
pickle.dump(net_params, open(model_file, 'wb'), protocol=2)
class PolicyValueNet():
"""策略价值网络"""
#def __init__(self, board_width, board_height, model_file=None):
def __init__(self, policy_infer_size, model_file=None):
#self.board_width = board_width
#self.board_height = board_height
self.policy_infer_size = policy_infer_size
self.l2_const = 1e-4 # coef of l2 penalty
self.create_policy_value_net()
self._loss_train_op()
self.load_model_done = True
if model_file and os.path.exists(model_file):
self.load_model_done = False
self.load_model(model_file)
def load_model(self, model_file):
"""重新加载模型(仅用于selfplay时load new model)"""
try:
#net_params = pickle.load(open(model_file, 'rb'), encoding='bytes') #iso-8859-1')
net_params = utils.pickle_load(model_file)
self.model.set_weights(net_params)
self.load_model_done = True
except:
logging.error("load_model fail! {}\t{}".format(
model_file, utils.get_trace()))
self.load_model_done = False
if os.path.exists(
model_file
) and self.load_model_done is False: #鏂囦欢瀛樺湪鍗村鍦ㄥけ璐ユ椂缁堟杩愯
exit(-1)
return self.load_model_done
def create_policy_value_net(self):
"""创建policy-value网络"""
# 输入层
#in_x = network = Input((4, self.board_width, self.board_height))
in_x = network = Input((4, 1, self.policy_infer_size))
# conv layers
network = Conv2D(filters=32,
kernel_size=(3, 3),
padding="same",
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
network = Conv2D(filters=64,
kernel_size=(3, 3),
padding="same",
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
network = Conv2D(filters=128,
kernel_size=(3, 3),
padding="same",
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
# 走子策略 action policy layers
policy_net = Conv2D(filters=4,
kernel_size=(1, 1),
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
policy_net = Flatten()(policy_net)
# infer self.board_width * self.board_height action_probs
#self.policy_net = Dense(self.board_width * self.board_height, activation="softmax", kernel_regularizer=l2(self.l2_const))(policy_net)
self.policy_net = Dense(self.policy_infer_size,
activation="softmax",
kernel_regularizer=l2(
self.l2_const))(policy_net)
# 盘面价值 state value layers
value_net = Conv2D(filters=2,
kernel_size=(1, 1),
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
value_net = Flatten()(value_net)
value_net = Dense(64, kernel_regularizer=l2(self.l2_const))(value_net)
# infer one current state score
self.value_net = Dense(1,
activation="tanh",
kernel_regularizer=l2(self.l2_const))(value_net)
# 创建网络模型
self.model = Model(in_x, [self.policy_net, self.value_net])
# 返回走子策略和价值概率
def policy_value(state_input):
state_input_union = np.array(state_input)
#print(state_input_union)
results = self.model.predict_on_batch(state_input_union)
return results
self.policy_value = policy_value
def policy_value_fn(self, board):
"""使用模型预测棋盘所有actionid的价值概率"""
# 棋盘所有可移动action_ids
legal_positions = board.availables
#print(legal_positions)
# 当前玩家角度的actions过程
current_actions = board.current_actions()
#print(current_actions)
# 使用模型预测走子策略和价值概率
#print(self.policy_infer_size)
#act_probs, value = self.policy_value(current_actions.reshape(-1, 4, self.board_width, self.board_height))
act_probs, value = self.policy_value(
current_actions.reshape(-1, 4, 1, self.policy_infer_size))
act_probs = zip(legal_positions, act_probs.flatten()[legal_positions])
# 返回[(action, 概率)] 以及当前玩家的后续走子value
return act_probs, value[0][0]
def _loss_train_op(self):
"""初始化损失
3个损失函数因子
loss = (z - v)^2 + pi^T * log(p) + c||theta||^2
loss = value损失函数 + policy损失函数 + 惩罚项
"""
# 定义优化器和损失函数
opt = Adam()
losses = ['categorical_crossentropy', 'mean_squared_error']
self.model.compile(optimizer=opt, loss=losses)
def self_entropy(probs):
return -np.mean(np.sum(probs * np.log(probs + 1e-10), axis=1))
def train_step(state_input, mcts_probs, winner, learning_rate):
"""输出训练过程中的结果"""
state_input_union = np.array(state_input)
mcts_probs_union = np.array(mcts_probs)
winner_union = np.array(winner)
# 评估
loss = self.model.evaluate(state_input_union,
[mcts_probs_union, winner_union],
batch_size=len(state_input),
verbose=0)
# 预测
action_probs, _ = self.model.predict_on_batch(state_input_union)
entropy = self_entropy(action_probs)
K.set_value(self.model.optimizer.lr, learning_rate)
self.model.fit(state_input_union, [mcts_probs_union, winner_union],
batch_size=len(state_input),
verbose=0)
return loss[0], entropy
self.train_step = train_step
def get_policy_param(self):
"""获得模型参数"""
net_params = self.model.get_weights()
return net_params
def save_model(self, model_file):
"""保存模型参数到文件"""
net_params = self.get_policy_param()
#pickle.dump(net_params, open(model_file, 'wb'), protocol=4)
utils.pickle_dump(net_params, model_file)
def test_model_methods():
a = Input(shape=(3,), name='input_a')
b = Input(shape=(3,), name='input_b')
a_2 = Dense(4, name='dense_1')(a)
dp = Dropout(0.5, name='dropout')
b_2 = dp(b)
model = Model([a, b], [a_2, b_2])
optimizer = 'rmsprop'
loss = 'mse'
loss_weights = [1., 0.5]
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
# training/testing doesn't work before compiling.
with pytest.raises(RuntimeError):
model.train_on_batch([input_a_np, input_b_np], [output_a_np, output_b_np])
model.compile(optimizer, loss, metrics=[], loss_weights=loss_weights,
sample_weight_mode=None)
# test train_on_batch
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out = model.train_on_batch({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np])
out = model.train_on_batch({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np})
# test fit
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np], epochs=1, batch_size=4)
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np], epochs=1, batch_size=4)
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np},
epochs=1, batch_size=4)
# test validation_split
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np],
epochs=1, batch_size=4, validation_split=0.5)
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np],
epochs=1, batch_size=4, validation_split=0.5)
# test validation data
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np],
epochs=1, batch_size=4,
validation_data=([input_a_np, input_b_np], [output_a_np, output_b_np]))
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np],
epochs=1, batch_size=4, validation_split=0.5,
validation_data=({'input_a': input_a_np, 'input_b': input_b_np}, [output_a_np, output_b_np]))
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np},
epochs=1, batch_size=4, validation_split=0.5,
validation_data=(
{'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np}))
# test_on_batch
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out = model.test_on_batch({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np])
out = model.test_on_batch({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np})
# predict_on_batch
out = model.predict_on_batch([input_a_np, input_b_np])
out = model.predict_on_batch({'input_a': input_a_np, 'input_b': input_b_np})
# predict, evaluate
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
out = model.evaluate([input_a_np, input_b_np], [output_a_np, output_b_np], batch_size=4)
out = model.predict([input_a_np, input_b_np], batch_size=4)
# with sample_weight
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
sample_weight = [None, np.random.random((10,))]
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
# test accuracy metric
model.compile(optimizer, loss, metrics=['acc'],
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 5
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 5
# this should also work
model.compile(optimizer, loss, metrics={'dense_1': 'acc'},
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
# and this as well
model.compile(optimizer, loss, metrics={'dense_1': ['acc']},
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
# test starting from non-zero initial epoch
trained_epochs = []
trained_batches = []
# define tracer callback
def on_epoch_begin(epoch, logs):
trained_epochs.append(epoch)
def on_batch_begin(batch, logs):
trained_batches.append(batch)
tracker_cb = LambdaCallback(on_epoch_begin=on_epoch_begin,
on_batch_begin=on_batch_begin)
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np], epochs=5, batch_size=4,
initial_epoch=2, callbacks=[tracker_cb])
assert trained_epochs == [2, 3, 4]
# test starting from non-zero initial epoch for generator too
trained_epochs = []
def gen_data(batch_sz):
while True:
yield ([np.random.random((batch_sz, 3)), np.random.random((batch_sz, 3))],
[np.random.random((batch_sz, 4)), np.random.random((batch_sz, 3))])
out = model.fit_generator(gen_data(4), steps_per_epoch=3, epochs=5,
initial_epoch=2, callbacks=[tracker_cb])
assert trained_epochs == [2, 3, 4]
# test with a custom metric function
def mse(y_true, y_pred):
return K.mean(K.pow(y_true - y_pred, 2))
model.compile(optimizer, loss, metrics=[mse],
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out_len = 1 + 2 * (1 + 1) # total loss + 2 outputs * (loss + metric)
assert len(out) == out_len
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == out_len
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np], batch_size=4, epochs=1)
out = model.evaluate([input_a_np, input_b_np], [output_a_np, output_b_np], batch_size=4)
out = model.predict([input_a_np, input_b_np], batch_size=4)
# enable verbose for evaluate_generator
out = model.evaluate_generator(gen_data(4), steps=3, verbose=1)
# empty batch
with pytest.raises(ValueError):
def gen_data():
while True:
yield (np.asarray([]), np.asarray([]))
out = model.evaluate_generator(gen_data(), steps=1)
# x is not a list of numpy arrays.
with pytest.raises(ValueError):
out = model.predict([None])
# x does not match _feed_input_names.
with pytest.raises(ValueError):
out = model.predict([input_a_np, None, input_b_np])
with pytest.raises(ValueError):
out = model.predict([None, input_a_np, input_b_np])
# all input/output/weight arrays should have the same number of samples.
with pytest.raises(ValueError):
out = model.train_on_batch([input_a_np, input_b_np[:2]],
[output_a_np, output_b_np],
sample_weight=sample_weight)
with pytest.raises(ValueError):
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np[:2]],
sample_weight=sample_weight)
with pytest.raises(ValueError):
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=[sample_weight[1], sample_weight[1][:2]])
# `sample_weight` is neither a dict nor a list.
with pytest.raises(TypeError):
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=tuple(sample_weight))
# `validation_data` is neither a tuple nor a triple.
with pytest.raises(ValueError):
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np],
epochs=1, batch_size=4,
validation_data=([input_a_np, input_b_np],))
# `loss` does not match outputs.
with pytest.raises(ValueError):
model.compile(optimizer, loss=['mse', 'mae', 'mape'])
# `loss_weights` does not match output_names.
with pytest.raises(ValueError):
model.compile(optimizer, loss='mse', loss_weights={'lstm': 0.5})
# `loss_weights` does not match outputs.
with pytest.raises(ValueError):
model.compile(optimizer, loss='mse', loss_weights=[0.5])
# `loss_weights` is invalid type.
with pytest.raises(TypeError):
model.compile(optimizer, loss='mse', loss_weights=(0.5, 0.5))
# `sample_weight_mode` does not match output_names.
with pytest.raises(ValueError):
model.compile(optimizer, loss='mse', sample_weight_mode={'lstm': 'temporal'})
# `sample_weight_mode` does not match output_names.
with pytest.raises(ValueError):
model.compile(optimizer, loss='mse', sample_weight_mode=['temporal'])
# `sample_weight_mode` matches output_names partially.
with pytest.raises(ValueError):
model.compile(optimizer, loss='mse', sample_weight_mode={'dense_1': 'temporal'})
# `loss` does not exist.
with pytest.raises(ValueError):
model.compile(optimizer, loss=[])
model.compile(optimizer, loss=['mse', 'mae'])
model.compile(optimizer, loss='mse', loss_weights={'dense_1': 0.2, 'dropout': 0.8})
model.compile(optimizer, loss='mse', loss_weights=[0.2, 0.8])
# the rank of weight arrays should be 1.
with pytest.raises(ValueError):
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=[None, np.random.random((10, 20, 30))])
model.compile(optimizer, loss='mse', sample_weight_mode={'dense_1': None, 'dropout': 'temporal'})
model.compile(optimizer, loss='mse', sample_weight_mode=[None, 'temporal'])
# the rank of output arrays should be at least 3D.
with pytest.raises(ValueError):
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
model.compile(optimizer, loss, metrics=[], loss_weights=loss_weights,
sample_weight_mode=None)
trained_epochs = []
trained_batches = []
out = model.fit_generator(generator=RandomSequence(3), steps_per_epoch=3, epochs=5,
initial_epoch=0, validation_data=RandomSequence(4),
validation_steps=3, callbacks=[tracker_cb])
assert trained_epochs == [0, 1, 2, 3, 4]
assert trained_batches == list(range(3)) * 5
# steps_per_epoch will be equal to len of sequence if it's unspecified
trained_epochs = []
trained_batches = []
out = model.fit_generator(generator=RandomSequence(3), epochs=5,
initial_epoch=0, validation_data=RandomSequence(4),
callbacks=[tracker_cb])
assert trained_epochs == [0, 1, 2, 3, 4]
assert trained_batches == list(range(12)) * 5
# fit_generator will throw an exception if steps is unspecified for regular generator
with pytest.raises(ValueError):
def gen_data():
while True:
yield (np.asarray([]), np.asarray([]))
out = model.fit_generator(generator=gen_data(), epochs=5,
initial_epoch=0, validation_data=gen_data(),
callbacks=[tracker_cb])
# Check if generator is only accessed an expected number of times
gen_counters = [0, 0]
def gen_data(i):
while True:
gen_counters[i] += 1
yield ([np.random.random((1, 3)), np.random.random((1, 3))],
[np.random.random((1, 4)), np.random.random((1, 3))])
out = model.fit_generator(generator=gen_data(0), epochs=3,
steps_per_epoch=2,
validation_data=gen_data(1),
validation_steps=1,
max_queue_size=2,
workers=2)
# Need range check here as filling of the queue depends on sleep in the enqueuers
assert 6 <= gen_counters[0] <= 8
# 12 = (epoch * workers * validation steps * max_queue_size)
assert 3 <= gen_counters[1] <= 12
gen_counters = [0]
out = model.fit_generator(generator=RandomSequence(3), epochs=3,
validation_data=gen_data(0),
validation_steps=1,
max_queue_size=2,
workers=2)
# 12 = (epoch * workers * validation steps * max_queue_size)
# Need range check here as filling of the queue depends on sleep in the enqueuers
assert 3 <= gen_counters[0] <= 12
# predict_generator output shape behavior should be consistent
def expected_shape(batch_size, n_batches):
return (batch_size * n_batches, 4), (batch_size * n_batches, 3)
# Multiple outputs and one step.
batch_size = 5
sequence_length = 1
shape_0, shape_1 = expected_shape(batch_size, sequence_length)
out = model.predict_generator(RandomSequence(batch_size,
sequence_length=sequence_length))
assert np.shape(out[0]) == shape_0 and np.shape(out[1]) == shape_1
# Multiple outputs and multiple steps.
batch_size = 5
sequence_length = 2
shape_0, shape_1 = expected_shape(batch_size, sequence_length)
out = model.predict_generator(RandomSequence(batch_size,
sequence_length=sequence_length))
assert np.shape(out[0]) == shape_0 and np.shape(out[1]) == shape_1
# Create a model with a single output.
single_output_model = Model([a, b], a_2)
single_output_model.compile(optimizer, loss, metrics=[], sample_weight_mode=None)
# Single output and one step.
batch_size = 5
sequence_length = 1
shape_0, _ = expected_shape(batch_size, sequence_length)
out = single_output_model.predict_generator(RandomSequence(batch_size,
sequence_length=sequence_length))
assert np.shape(out) == shape_0
# Single output and multiple steps.
batch_size = 5
sequence_length = 2
shape_0, _ = expected_shape(batch_size, sequence_length)
out = single_output_model.predict_generator(RandomSequence(batch_size,
sequence_length=sequence_length))
assert np.shape(out) == shape_0
class PolicyValueNet():
"""policy-value network """
def __init__(self, board_width, board_height, model_file=None):
self.board_width = board_width
self.board_height = board_height
self.l2_const = 1e-4 # coef of l2 penalty
self.create_policy_value_net()
if model_file:
print("[Notice] load model from file")
self.model = load_model(model_file)
else:
print("[Notice] create model")
self.create_policy_value_net()
self._loss_train_op()
def create_policy_value_net(self):
"""create the policy value network """
in_x = network = Input((4, self.board_width, self.board_height))
# conv layers
network = Conv2D(filters=32,
kernel_size=(3, 3),
padding="same",
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
network = Conv2D(filters=64,
kernel_size=(3, 3),
padding="same",
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
network = Conv2D(filters=128,
kernel_size=(3, 3),
padding="same",
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
# action policy layers
policy_net = Conv2D(filters=4,
kernel_size=(1, 1),
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
policy_net = Flatten()(policy_net)
self.policy_net = Dense(self.board_width * self.board_height,
activation="softmax",
kernel_regularizer=l2(
self.l2_const))(policy_net)
# state value layers
value_net = Conv2D(filters=2,
kernel_size=(1, 1),
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
value_net = Flatten()(value_net)
value_net = Dense(64, kernel_regularizer=l2(self.l2_const))(value_net)
self.value_net = Dense(1,
activation="tanh",
kernel_regularizer=l2(self.l2_const))(value_net)
self.model = Model(in_x, [self.policy_net, self.value_net])
def policy_value(state_input):
state_input_union = np.array(state_input)
results = self.model.predict_on_batch(state_input_union)
return results
self.policy_value = policy_value
def policy_value_fn(self, board):
"""
input: board
output: a list of (action, probability) tuples for each available action and the score of the board state
"""
legal_positions = board.availables
current_state = board.current_state()
act_probs, value = self.policy_value(
current_state.reshape(-1, 4, self.board_width, self.board_height))
act_probs = zip(legal_positions, act_probs.flatten()[legal_positions])
return act_probs, value[0][0]
def _loss_train_op(self):
"""
Three loss terms：
loss = (z - v)^2 + pi^T * log(p) + c||theta||^2
"""
# get the train op
opt = Adam()
losses = ['categorical_crossentropy', 'mean_squared_error']
self.model.compile(optimizer=opt, loss=losses)
def self_entropy(probs):
return -np.mean(np.sum(probs * np.log(probs + 1e-10), axis=1))
def train_step(state_input, mcts_probs, winner, learning_rate):
state_input_union = np.array(state_input)
mcts_probs_union = np.array(mcts_probs)
winner_union = np.array(winner)
loss = self.model.evaluate(state_input_union,
[mcts_probs_union, winner_union],
batch_size=len(state_input),
verbose=0)
action_probs, _ = self.model.predict_on_batch(state_input_union)
entropy = self_entropy(action_probs)
K.set_value(self.model.optimizer.lr, learning_rate)
self.model.fit(state_input_union, [mcts_probs_union, winner_union],
batch_size=len(state_input),
verbose=0)
return loss[0], entropy
self.train_step = train_step
def get_policy_param(self):
net_params = self.model.get_weights()
return net_params
def save_model(self, model_file):
""" save model to file """
print("save model file")
self.model.save(model_file)
class PolicyNet():
"""policy network """
def __init__(self,
board_width,
board_height,
model_file=None,
pretrained_file=None):
self.board_width = board_width
self.board_height = board_height
self.l2_const = 1e-4 # coef of l2 penalty
self.build_net()
self._loss_train_op(0.001)
if model_file:
self.model.load_weights(model_file)
if pretrained_file:
self.model.load_weights(pretrained_file, by_name=True)
def build_net(self):
"""create the policy value network """
in_x = network = Input((2, self.board_width, self.board_height))
# conv layers
network = Conv2D(filters=32,
kernel_size=(3, 3),
padding="same",
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
network = Conv2D(filters=64,
kernel_size=(3, 3),
padding="same",
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
network = Conv2D(filters=128,
kernel_size=(3, 3),
padding="same",
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
# action policy layers
policy_net = Conv2D(filters=4,
kernel_size=(1, 1),
data_format="channels_first",
activation="relu",
kernel_regularizer=l2(self.l2_const))(network)
policy_net = Flatten()(policy_net)
self.policy_net = Dense(self.board_width * self.board_height,
activation="softmax",
kernel_regularizer=l2(
self.l2_const))(policy_net)
self.model = Model(in_x, self.policy_net)
def policy_value(state_input):
state_input_union = np.array(state_input)
results = self.model.predict_on_batch(state_input_union)
return results
self.policy_value = policy_value
def policy_fn(self, board):
"""
input: board
output: a list of (action, probability) tuples for each available action and the score of the board state
"""
legal_positions = board.availables
current_state = board.current_state()
act_probs = self.policy_value(
current_state.reshape(
(-1, 2, self.board_width, self.board_height)))
act_probs = list(
zip(legal_positions,
act_probs.flatten()[legal_positions]))
return act_probs
def _loss_train_op(self, initial_learning_rate):
"""
Three loss terms：
loss = (z - v)^2 + pi^T * log(p) + c||theta||^2
"""
# get the train op
# opt = Adam()
self.session = K.get_session()
global_step = tf.Variable(0, trainable=False)
lr = tf.train.exponential_decay(initial_learning_rate, global_step,
10000, 0.95, True)
opt = tf.train.AdamOptimizer(learning_rate=lr)
one_hot_move_ph = tf.placeholder(
tf.float32, (None, self.board_width * self.board_height), "moves")
reward_ph = tf.placeholder(tf.float32, (None, ), "rewards")
def self_entropy(probs):
return -np.mean(np.sum(probs * np.log(probs + 1e-10), axis=1))
def loss_op():
objective = tf.log(tf.nn.softmax(self.model.output[0],
axis=-1)) * one_hot_move_ph
objective = tf.reduce_sum(objective, axis=-1, keepdims=False)
objective = objective * reward_ph
return -1 * objective
self.loss_op = loss_op()
self.minimize_op = opt.minimize(self.loss_op, global_step=global_step)
def train_step(states, reward, moves):
np_state_input = np.array(states)
np_reward = np.array(reward)
np_moves = np.eye(self.board_height *
self.board_width)[np.array(moves)]
# K.set_value(self.model.optimizer.lr, learning_rate)
# loss = self.model.train_on_batch(np_state_input, [np_winner])
feed_dict = {
self.model.input: np_state_input,
one_hot_move_ph: np_moves,
reward_ph: np_reward
}
_, loss, new_probs = self.session.run(
[self.minimize_op, self.loss_op, self.model.output], feed_dict)
entropy = self_entropy(new_probs)
return loss, entropy
self.train_step = train_step
def get_policy_param(self):
net_params = self.model.get_weights()
return net_params
def save_model(self, model_path):
""" save model params to file """
# net_params = self.get_policy_param()
# pickle.dump(net_params, open(model_file, 'wb'), protocol=2)
self.model.save_weights(model_path)
def load_model(self, model_path):
self.model.load_weights(model_path)
def test_model_with_external_loss():
# None loss, only regularization loss.
a = Input(shape=(3,), name='input_a')
a_2 = Dense(4, name='dense_1',
kernel_regularizer='l1',
bias_regularizer='l2')(a)
dp = Dropout(0.5, name='dropout')
a_3 = dp(a_2)
model = Model(a, [a_2, a_3])
optimizer = 'rmsprop'
loss = None
model.compile(optimizer, loss, metrics=['mae'])
input_a_np = np.random.random((10, 3))
# test train_on_batch
out = model.train_on_batch(input_a_np, None)
out = model.test_on_batch(input_a_np, None)
# fit
out = model.fit(input_a_np, None)
# evaluate
out = model.evaluate(input_a_np, None)
# No dropout, external loss.
a = Input(shape=(3,), name='input_a')
a_2 = Dense(4, name='dense_1')(a)
a_3 = Dense(4, name='dense_2')(a)
model = Model(a, [a_2, a_3])
model.add_loss(K.mean(a_3 + a_2))
optimizer = 'rmsprop'
loss = None
model.compile(optimizer, loss, metrics=['mae'])
# test train_on_batch
out = model.train_on_batch(input_a_np, None)
out = model.test_on_batch(input_a_np, None)
# fit
out = model.fit(input_a_np, None)
# evaluate
out = model.evaluate(input_a_np, None)
# Test fit with no external data at all.
if K.backend() == 'tensorflow':
import tensorflow as tf
a = Input(tensor=tf.Variable(input_a_np, dtype=tf.float32))
a_2 = Dense(4, name='dense_1')(a)
a_2 = Dropout(0.5, name='dropout')(a_2)
model = Model(a, a_2)
model.add_loss(K.mean(a_2))
model.compile(optimizer='rmsprop',
loss=None,
metrics=['mean_squared_error'])
# test train_on_batch
out = model.train_on_batch(None, None)
out = model.test_on_batch(None, None)
out = model.predict_on_batch(None)
# test fit
with pytest.raises(ValueError):
out = model.fit(None, None, epochs=1, batch_size=10)
out = model.fit(None, None, epochs=1, steps_per_epoch=1)
# test fit with validation data
with pytest.raises(ValueError):
out = model.fit(None, None,
epochs=1,
steps_per_epoch=None,
validation_steps=2)
out = model.fit(None, None,
epochs=1,
steps_per_epoch=2,
validation_steps=2)
# test evaluate
with pytest.raises(ValueError):
out = model.evaluate(None, None, batch_size=10)
out = model.evaluate(None, None, steps=3)
# test predict
with pytest.raises(ValueError):
out = model.predict(None, batch_size=10)
out = model.predict(None, steps=3)
assert out.shape == (10 * 3, 4)
# Test multi-output model without external data.
a = Input(tensor=tf.Variable(input_a_np, dtype=tf.float32))
a_1 = Dense(4, name='dense_1')(a)
a_2 = Dropout(0.5, name='dropout')(a_1)
model = Model(a, [a_1, a_2])
model.add_loss(K.mean(a_2))
model.compile(optimizer='rmsprop',
loss=None,
metrics=['mean_squared_error'])
# test train_on_batch
out = model.train_on_batch(None, None)
out = model.test_on_batch(None, None)
out = model.predict_on_batch(None)
# test fit
with pytest.raises(ValueError):
out = model.fit(None, None, epochs=1, batch_size=10)
out = model.fit(None, None, epochs=1, steps_per_epoch=1)
# test fit with validation data
with pytest.raises(ValueError):
out = model.fit(None, None,
epochs=1,
steps_per_epoch=None,
validation_steps=2)
out = model.fit(None, None,
epochs=1,
steps_per_epoch=2,
validation_steps=2)
# test evaluate
with pytest.raises(ValueError):
out = model.evaluate(None, None, batch_size=10)
out = model.evaluate(None, None, steps=3)
# test predict
with pytest.raises(ValueError):
out = model.predict(None, batch_size=10)
out = model.predict(None, steps=3)
assert len(out) == 2
assert out[0].shape == (10 * 3, 4)
assert out[1].shape == (10 * 3, 4)
r + '/' + file for r, d, files in os.walk(target_data_dir)
for file in files
]
num_samples = len(sample_files)
model = load_model(emot_model)
model.summary()
model = Model(inputs=model.input, outputs=model.get_layer(layer_name).output)
features_dict = {}
features = None
for sample_file in sample_files:
sample_file_base = os.path.basename(sample_file)
img = load_img(sample_file, target_size=(224, 224))
x = img_to_array(img)
x = x.reshape((1, ) + x.shape)
features = model.predict_on_batch(x)
features_dict[sample_file_base] = features[0]
num_features = len(features)
with open(
"val_emot_" + layer_name + "_" + str(num_features) + "_features" +
'.pkl', 'wb') as f:
pickle.dump(features_dict, f, pickle.HIGHEST_PROTOCOL)
def test_model_methods():
a = Input(shape=(3,), name='input_a')
b = Input(shape=(3,), name='input_b')
a_2 = Dense(4, name='dense_1')(a)
dp = Dropout(0.5, name='dropout')
b_2 = dp(b)
model = Model([a, b], [a_2, b_2])
optimizer = 'rmsprop'
loss = 'mse'
loss_weights = [1., 0.5]
model.compile(optimizer, loss, metrics=[], loss_weights=loss_weights,
sample_weight_mode=None)
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
# test train_on_batch
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out = model.train_on_batch({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np])
out = model.train_on_batch({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np})
# test fit
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np], nb_epoch=1, batch_size=4)
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np], nb_epoch=1, batch_size=4)
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np},
nb_epoch=1, batch_size=4)
# test validation_split
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np],
nb_epoch=1, batch_size=4, validation_split=0.5)
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np],
nb_epoch=1, batch_size=4, validation_split=0.5)
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np},
nb_epoch=1, batch_size=4, validation_split=0.5)
# test validation data
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np],
nb_epoch=1, batch_size=4,
validation_data=([input_a_np, input_b_np], [output_a_np, output_b_np]))
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np],
nb_epoch=1, batch_size=4, validation_split=0.5,
validation_data=({'input_a': input_a_np, 'input_b': input_b_np}, [output_a_np, output_b_np]))
out = model.fit({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np},
nb_epoch=1, batch_size=4, validation_split=0.5,
validation_data=({'input_a': input_a_np, 'input_b': input_b_np}, {'dense_1': output_a_np, 'dropout': output_b_np}))
# test_on_batch
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out = model.test_on_batch({'input_a': input_a_np, 'input_b': input_b_np},
[output_a_np, output_b_np])
out = model.test_on_batch({'input_a': input_a_np, 'input_b': input_b_np},
{'dense_1': output_a_np, 'dropout': output_b_np})
# predict_on_batch
out = model.predict_on_batch([input_a_np, input_b_np])
out = model.predict_on_batch({'input_a': input_a_np, 'input_b': input_b_np})
# predict, evaluate
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
out = model.evaluate([input_a_np, input_b_np], [output_a_np, output_b_np], batch_size=4)
out = model.predict([input_a_np, input_b_np], batch_size=4)
# with sample_weight
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
sample_weight = [None, np.random.random((10,))]
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np],
sample_weight=sample_weight)
# test accuracy metric
model.compile(optimizer, loss, metrics=['acc'],
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 5
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 5
# this should also work
model.compile(optimizer, loss, metrics={'dense_1': 'acc'},
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
# and this as well
model.compile(optimizer, loss, metrics={'dense_1': ['acc']},
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == 4
# test starting from non-zero initial epoch
trained_epochs = []
def on_epoch_begin(epoch, logs):
trained_epochs.append(epoch)
tracker_cb = LambdaCallback(on_epoch_begin=on_epoch_begin)
out = model.fit([input_a_np, input_b_np],
[output_a_np, output_b_np], nb_epoch=5, batch_size=4,
initial_epoch=2, callbacks=[tracker_cb])
assert trained_epochs == [2, 3, 4]
# test starting from non-zero initial epoch for generator too
trained_epochs = []
def gen_data(batch_sz):
while True:
yield ([np.random.random((batch_sz, 3)), np.random.random((batch_sz, 3))],
[np.random.random((batch_sz, 4)), np.random.random((batch_sz, 3))])
out = model.fit_generator(gen_data(4), samples_per_epoch=10, nb_epoch=5,
initial_epoch=2, callbacks=[tracker_cb])
assert trained_epochs == [2, 3, 4]
# test with a custom metric function
mse = lambda y_true, y_pred: K.mean(K.pow(y_true - y_pred, 2))
def mse_powers(y_true, y_pred):
m = mse(y_true, y_pred)
return {
'mse_squared': K.pow(m, 2),
'mse_cubed': K.pow(m, 3)
}
model.compile(optimizer, loss, metrics=[mse, mse_powers],
sample_weight_mode=None)
out = model.train_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
out_len = 1 + 2 * 4 # total loss, per layer: loss + 3 metrics
assert len(out) == out_len
out = model.test_on_batch([input_a_np, input_b_np],
[output_a_np, output_b_np])
assert len(out) == out_len
input_a_np = np.random.random((10, 3))
input_b_np = np.random.random((10, 3))
output_a_np = np.random.random((10, 4))
output_b_np = np.random.random((10, 3))
out = model.fit([input_a_np, input_b_np], [output_a_np, output_b_np], batch_size=4, nb_epoch=1)
out = model.evaluate([input_a_np, input_b_np], [output_a_np, output_b_np], batch_size=4)
out = model.predict([input_a_np, input_b_np], batch_size=4)
def test_pd_df(): # testing dataframes via pandas
inputA = Input(shape=(3, ), name='inputA')
inputB = Input(shape=(3, ), name='inputB')
x = Dense(4, name='dense_1')(inputA)
y = Dense(3, name='desne_2')(inputB)
model1 = Model(inputs=inputA, outputs=x)
model2 = Model(inputs=[inputA, inputB], outputs=[x, y])
optimizer = 'rmsprop'
loss = 'mse'
model1.compile(optimizer=optimizer, loss=loss)
model2.compile(optimizer=optimizer, loss=loss)
inputA_df = pd.DataFrame(np.random.random((10, 3)))
inputB_df = pd.DataFrame(np.random.random((10, 3)))
outputA_df = pd.DataFrame(np.random.random((10, 4)))
outputB_df = pd.DataFrame(np.random.random((10, 3)))
model1.fit(inputA_df, outputA_df)
model2.fit([inputA_df, inputB_df], [outputA_df, outputB_df])
model1.fit([inputA_df], [outputA_df])
model1.fit({'inputA': inputA_df}, outputA_df)
model2.fit({
'inputA': inputA_df,
'inputB': inputB_df
}, [outputA_df, outputB_df])
model1.predict(inputA_df)
model2.predict([inputA_df, inputB_df])
model1.predict([inputA_df])
model1.predict({'inputA': inputA_df})
model2.predict({'inputA': inputA_df, 'inputB': inputB_df})
model1.predict_on_batch(inputA_df)
model2.predict_on_batch([inputA_df, inputB_df])
model1.predict_on_batch([inputA_df])
model1.predict_on_batch({'inputA': inputA_df})
model2.predict_on_batch({'inputA': inputA_df, 'inputB': inputB_df})
model1.evaluate(inputA_df, outputA_df)
model2.evaluate([inputA_df, inputB_df], [outputA_df, outputB_df])
model1.evaluate([inputA_df], [outputA_df])
model1.evaluate({'inputA': inputA_df}, outputA_df)
model2.evaluate({
'inputA': inputA_df,
'inputB': inputB_df
}, [outputA_df, outputB_df])
model1.train_on_batch(inputA_df, outputA_df)
model2.train_on_batch([inputA_df, inputB_df], [outputA_df, outputB_df])
model1.train_on_batch([inputA_df], [outputA_df])
model1.train_on_batch({'inputA': inputA_df}, outputA_df)
model2.train_on_batch({
'inputA': inputA_df,
'inputB': inputB_df
}, [outputA_df, outputB_df])
model1.test_on_batch(inputA_df, outputA_df)
model2.test_on_batch([inputA_df, inputB_df], [outputA_df, outputB_df])
model1.test_on_batch([inputA_df], [outputA_df])
model1.test_on_batch({'inputA': inputA_df}, outputA_df)
model2.test_on_batch({
'inputA': inputA_df,
'inputB': inputB_df
}, [outputA_df, outputB_df])
