def generate_triplet_adaptive(dataset, bpr_optimizer): """ generate negative instance using adaptive sampling sample from a pre-defined exponential distribution """ t_i = random.choice(dataset.Abstract_Graph.nodes()) neg_list = list(set(dataset.paper_abstract) - \ set(dataset.Abstract_Graph.neighbors(t_i)) - set([t_i])) # given a_i, sample its neighbor based on its weight value # idea of edge sampling neig_list = dataset.Abstract_Graph.neighbors(t_i) weight_list = [dataset.Abstract_Graph[t_i][nbr]['weight'] for nbr in neig_list] norm_weight_list = [float(w) / sum(weight_list) for w in weight_list] t_j = np.random.choice(neig_list, 1, p=norm_weight_list)[0] # sample negative instance based on pre-defined exponential distribution t_t = 0 if len(neg_list) > 0: norm_soft = softmax([bpr_optimizer.predict_score(t_i, ne, "dabstract") for ne in neg_list]) t_t = np.random.choice(neg_list, 1, p=norm_soft)[0] else: t_t = np.random.choice(neig_list) yield t_i, t_j, t_t
def softmax_forward_block(a_prev, w, b): h = np.dot(w, a_prev) + b a = softmax(h) cache = {'a_prev': a_prev, 'w': w, 'b': b} return a, cache
def run_op(self, argmap): import original import augmented # Original data just returns the actual samples origdata = utility.PickleData(original, 'sample').load() # Augmented saves a bunch more stuff. _, augmdata, tknprbs, loggies = utility.PickleData( augmented, 'sample').load() utility.assert_zero(origdata - augmdata) print( "Success, checked data of size {} against original sample".format( origdata.shape)) for bi in range(augmdata.shape[0]): for pi in range(1, augmdata.shape[1]): logits = loggies[bi, :, pi] token = augmdata[bi, pi] probs = utility.softmax(logits) aprb = probs[token] bprb = tknprbs[bi, pi] utility.assert_small(aprb - bprb, epsilon=1e-4) print( "Checked correspondence between logit values and token probabilities" )
def feed_forward(self, X, y): ''' Implementation of the Feedforward ''' # Fonction d'activation g = lambda x: ut.tanh(x) Z = [None] * len(self.layer_sizes) input_layer = X for i in range(len(self.hidden_layer_sizes) + 1): # Multiplying input_layer by weights for this layer Z[i + 1] = np.dot(self.weights[i], input_layer) + self.bias[i] # Activation Function if (i == len(self.hidden_layer_sizes)): # Just for output layer softmax() # For calculating the loss self.A[i] = ut.softmax(Z[i + 1]) # Derivative of softmax, returns a matrix self.df[i] = ut.softmax_gradient(Z[i + 1]) else: # for the other layers tanh() self.A[i], self.df[i] = g(Z[i + 1]) # Current output_layer will be next input_layer input_layer = self.A[i] error = ut.cross_entropy_loss(self.A[-1], y) return error, self.A[-1]
def generate_triplet_adaptive(dataset, bpr_optimizer): """ generate negative instance using adaptive sampling sample from a pre-defined exponential distribution """ d_i = random.choice(dataset.paper_list) neg_list = list(set(dataset.coauthor_list) - \ set(dataset.paper_authorlist_dict[d_i])) while True: if dataset.paper_authorlist_dict[d_i] != []: a_j = random.choice(dataset.paper_authorlist_dict[d_i]) # sample negative instance based on pre-defined exponential distribution norm_soft = softmax([ bpr_optimizer.predict_score(d_i, ne, "pd") for ne in neg_list ]) a_t = np.random.choice(neg_list, 1, p=norm_soft)[0] yield d_i, a_j, a_t break else: d_i = random.choice(dataset.paper_list) neg_list = list(set(dataset.coauthor_list) - \ set(dataset.paper_authorlist_dict[d_i]))
def compute_cost(X, Y, w, b, lambd, regularized): m = Y.shape[-1] Z = np.dot(w, X) + b A = softmax(Z) cost = -np.sum(Y * np.log(A)) / m if regularized == 1: cost += lambd * np.linalg.norm(w, 1) / m # L1 Regularization elif regularized == 2: cost += lambd * np.linalg.norm(w) / m # L2 Regularization return cost
def fine_tune(self): # print self.input.shape # print self.W.shape output = numpy.dot(self.input, self.W.T) + self.b hidden_possible = softmax(output) d_y = self.label - hidden_possible print ' loss : ' + str(numpy.sum(d_y ** 2)) self.W += self.lr * numpy.dot(d_y.T, self.input) / self.data_size # self.W += (self.learning_rate * numpy.dot(d_y.T, self.input) - self.learning_rate * 0.1 * self.W) / 10000 self.b += self.lr * numpy.mean(d_y, axis=0)
def predict(self, X, Y): m = X.shape[-1] w = self.parameters['w'] b = self.parameters['b'] Z = np.dot(w, X) + b A = softmax(Z) self.Y_p = np.argmax(A, axis=0) Y_label = np.argmax(Y, axis=0) correct = (self.Y_p == Y_label) self.accuracy = np.sum(correct) / m return self.accuracy
def softmax_propagate(X, Y, w, b, lambd, regularized): m = Y.shape[-1] Z = np.dot(w, X) + b A = softmax(Z) cost = compute_cost(X, Y, w, b, lambd, regularized) dw = np.dot((A - Y), X.T) / m + 2 * lambd * w / m db = np.sum((A - Y), axis=1, keepdims=True) / m if regularized == 2: dw += 2 * lambd * w / m elif regularized == 1: dw += lambd * np.sign(w) / m grad = {'dw': dw, 'db': db} return grad, cost
def inverse_predict(self): print 'Logistic Regression : self.W' print self.W print numpy.max(self.W) print numpy.min(self.W) print numpy.mean(self.W) print '~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~' inverse_input = numpy.dot((1,0,0,0,0,0,0,0,0,0), self.W) # print inverse_input.shape # print inverse_input inverse_input_possible = softmax(inverse_input) inverse_input_sample = numpy_rng.binomial(n=1, p=inverse_input_possible) print inverse_input_sample f = open('inverse_log.txt', 'w') cPickle.dump(inverse_input_sample, f) f.close() return inverse_input_sample
def get_emotion(self, face_gray): # Preprocess input image for emotion detection image_data = utility.resize_and_pad(face_gray, self.size_w, self.size_h, 0) image_data = np.array(image_data, dtype=np.float32) image_data = np.resize(image_data, self.input_shape) # Detect emotion result = self.session.run(None, {self.inputs[0].name: image_data}) # Postprocess output data and draw emotion label scores = result[0][0] for i in range(len(scores)): scores[i] = max(scores[i], 1e-9) # convert negative value to be 1e-9 scores = utility.softmax(scores) class_index = np.argmax(scores) confidence = scores[class_index] color = self.colors[class_index] emotion = self.labels[class_index] return emotion, confidence, color
def generate_triplet_adaptive(dataset, bpr_optimizer): """ generate negative instance using adaptive sampling sample from a pre-defined exponential distribution """ a_i = random.choice(dataset.C_Graph.nodes()) neg_list = list(set(dataset.coauthor_list) - \ set(dataset.C_Graph.neighbors(a_i)) - set([a_i])) # given a_i, sample its neighbor based on its weight value # idea of edge sampling neig_list = dataset.C_Graph.neighbors(a_i) weight_list = [dataset.C_Graph[a_i][nbr]['weight'] for nbr in neig_list] norm_weight_list = [float(w) / sum(weight_list) for w in weight_list] a_j = np.random.choice(neig_list, 1, p=norm_weight_list)[0] # sample negative instance based on pre-defined exponential distribution norm_soft = softmax([bpr_optimizer.predict_score(a_i, ne, "pp") for ne in neg_list]) a_t = np.random.choice(neg_list, 1, p = norm_soft)[0] yield a_i, a_j, a_t
def predict(self, input_board): logits = self.model.predict( np.expand_dims(input_board, axis=0).astype('float64')) p = utility.softmax( logits) # Apply softmax on the logits after prediction return p.squeeze() # Remove the extra batch dimension
def forward(self, X): #Falta agregar la funcion de activacion Z1 = np.tanh( X.dot(self.W1) + self.b1 ) Z2 = np.tanh( Z1.dot(self.W2) + self.b2 ) Z3 = np.tanh( Z2.dot(self.W3) + self.b3 ) return softmax( Z3.dot(self.W4) + self.b4), Z3, Z2, Z1
def predict(self, input): output = numpy.dot(input, self.W.T) + self.b hidden_possible = softmax(output) return hidden_possible