def get_training_model(Ws_s, bs_s, dropout=False, lambd=10.0, kappa=1.0):
# Build a dual network, one for the real move, one for a fake random move
# Train on a negative log likelihood of classifying the right move
xc_s, xc_p = load.get_model(Ws_s, bs_s, dropout=dropout)
xr_s, xr_p = load.get_model(Ws_s, bs_s, dropout=dropout)
xp_s, xp_p = load.get_model(Ws_s, bs_s, dropout=dropout)
#loss = -T.log(sigmoid(xc_p + xp_p)).mean() # negative log likelihood
#loss += -T.log(sigmoid(-xp_p - xr_p)).mean() # negative log likelihood
cr_diff = xc_p - xr_p
loss_a = -T.log(sigmoid(cr_diff)).mean()
cp_diff = kappa * (xc_p + xp_p)
loss_b = -T.log(sigmoid( cp_diff)).mean()
loss_c = -T.log(sigmoid(-cp_diff)).mean()
# Add regularization terms
reg = 0
for x in Ws_s + bs_s:
reg += lambd * (x ** 2).mean()
loss = loss_a + loss_b + loss_c
return xc_s, xr_s, xp_s, loss, reg, loss_a, loss_b, loss_c
def get_training_model(Ws_s, bs_s, dropout=False, lambd=10.0, kappa=1.0):
# Build a dual network, one for the real move, one for a fake random move
# Train on a negative log likelihood of classifying the right move
xc_s, xc_p = load.get_model(Ws_s, bs_s, dropout=dropout)
xr_s, xr_p = load.get_model(Ws_s, bs_s, dropout=dropout)
xp_s, xp_p = load.get_model(Ws_s, bs_s, dropout=dropout)
#loss = -T.log(sigmoid(xc_p + xp_p)).mean() # negative log likelihood
#loss += -T.log(sigmoid(-xp_p - xr_p)).mean() # negative log likelihood
cr_diff = xc_p - xr_p
loss_a = -T.log(sigmoid(cr_diff)).mean()
cp_diff = kappa * (xc_p + xp_p)
loss_b = -T.log(sigmoid(cp_diff)).mean()
loss_c = -T.log(sigmoid(-cp_diff)).mean()
# Add regularization terms
reg = 0
## for x in Ws_s + bs_s:
## reg += lambd * (x ** 2).mean()
reg = sum(lambd * (x**2).mean() for x in Ws_s + bs_s)
loss = loss_a + loss_b + loss_c
return xc_s, xr_s, xp_s, loss, reg, loss_a, loss_b, loss_c
def get_update(Ws_s, bs_s):
x, fx = load.get_model(Ws_s, bs_s)
# Ground truth (who won)
y = T.vector('y')
# Compute loss (just log likelihood of a sigmoid fit)
y_pred = sigmoid(fx)
loss = -(y * T.log(y_pred) + (1 - y) * T.log(1 - y_pred)).mean()
# Metrics on the number of correctly predicted ones
frac_correct = ((fx > 0) * y + (fx < 0) * (1 - y)).mean()
# Updates
learning_rate_s = T.scalar(dtype=theano.config.floatX)
momentum_s = T.scalar(dtype=theano.config.floatX)
updates = train.nesterov_updates(loss, Ws_s + bs_s, learning_rate_s,
momentum_s)
f_update = theano.function(
inputs=[x, y, learning_rate_s, momentum_s],
outputs=[loss, frac_correct],
updates=updates,
)
return f_update
def get_update(Ws_s, bs_s):
x, fx = load.get_model(Ws_s, bs_s)
# Ground truth (who won)
y = T.vector('y')
#Changed from Sigmoid to reLU for faster time (ain't nobody got time for that)
y_pred = reLU(fx)
loss = -(y * T.log(y_pred) + (1 - y) * T.log(1 - y_pred)).mean()
# Metrics on the number of correctly predicted ones
frac_correct = ((fx > 0) * y + (fx < 0) * (1 - y)).mean()
# Updates
learning_rate_s = T.scalar(dtype=theano.config.floatX)
momentum_s = T.scalar(dtype=theano.config.floatX)
updates = train.nesterov_updates(loss, Ws_s + bs_s, learning_rate_s,
momentum_s)
f_update = theano.function(
inputs=[x, y, learning_rate_s, momentum_s],
outputs=[loss, frac_correct],
updates=updates,
)
return f_update
def get_model_from_pickle(fn):
f = open(fn, 'rb')
Ws, bs = pickle.load(f, encoding='latin1')
Ws_s, bs_s = load.get_parameters(Ws=Ws, bs=bs)
x, p = load.get_model(Ws_s, bs_s)
predict = theano.function(inputs=[x], outputs=p)
return predict
def getModel(fn):
#gets the model from the pickle file and turns it into a function
f = open(fn, 'rb')
Ws, bs = pickle.load(f)
Ws_s, bs_s = load.get_parameters(Ws=Ws, bs=bs)
x, p = load.get_model(Ws_s, bs_s)
predict = theano.function(inputs=[x], outputs=p)
return predict
def get_model_from_pickle(fn):
f = open(fn)
Ws, bs = pickle.load(f)
Ws_s, bs_s = load.get_parameters(Ws=Ws, bs=bs)
x, p = load.get_model(Ws_s, bs_s)
predict = theano.function(
inputs=[x],
outputs=p)
return predict
def get_model_from_pickle(fn):
"""
Loads and returns model from pickled file which stores weights and biases.
:param fn: filename
:return: the theano function object representing the model.
"""
f = open(fn, 'rb')
# load weights Ws and biases bs.
# Ws is a list of 3 nd arrays.
# 1st nd-array: 768 x 2048 (weights for input to first hidden layer)
# 2nd nd-array: 2048 x 2048
# 3rd nd-array: 2048-dimensional vector to provide single output value.
Ws, bs = pickle.load(f, encoding='bytes')
Ws_s, bs_s = load.get_parameters(Ws=Ws, bs=bs)
x, p = load.get_model(Ws_s, bs_s)
# predict is a function object, computing outputs from inputs (based on
# the function defined in load.py's get_model function.
predict = theano.function(inputs=[x], outputs=p)
return predict
def get_predict(Ws_s, bs_s):
x, p = load.get_model(Ws_s, bs_s)
predict = theano.function(inputs=[x], outputs=p)
return predict
def register_admin(app_label, model_name, admin_cls):
from mocrud.admin import admin
m_model = get_model(app_label, model_name)
m_model.Admin = admin_cls
def register_op(app_label, model_name, op_cls):
from mocrud.admin import admin
m_model = get_model(app_label, model_name)
m_ops = copy.deepcopy(m_model.Admin.ops)
m_ops.append(op_cls)
m_model.Admin.ops = m_ops
def register_admin(app_label, model_name, admin_cls):
from mocrud.admin import admin
m_model = get_model(app_label, model_name)
m_model.Admin = admin_cls
def register_op(app_label, model_name, op_cls):
from mocrud.admin import admin
m_model = get_model(app_label, model_name)
m_ops = copy.deepcopy(m_model.Admin.ops)
m_ops.append(op_cls)
m_model.Admin.ops = m_ops
