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