Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\\n assert not one_hot_label.requires_grad\\n pi = one_hot_label.to(torch.float)\\n\\n assert not torch.any(torch.isinf(score_map))\\n assert not torch.any(torch.isnan(score_map))\\n\\n log_qi = torch.log(self.clamp_softmax(score_map))\\n\\n assert not torch.any(torch.isnan(log_qi))\\n\\n log_fg_qi = log_qi[:, 1:, :, :]\\n fg_pi = pi[:, 1:, :, :]\\n fg_count = torch.sum(fg_pi, dim=(1, 2, 3)) + self.eps\\n\\n log_bg_qi = log_qi[:, 0:1, :, :]\\n bg_pi = pi[:, 0:1, :, :]\\n bg_count = torch.sum(bg_pi, dim=(1, 2, 3)) + self.eps\\n\\n fg_loss_ = torch.sum(fg_pi * log_fg_qi, dim=(1, 2, 3))\\n fg_loss = -1 * torch.mean(fg_loss_ / fg_count) # mean reduce on batch\\n\\n bg_loss_ = torch.sum(bg_pi * log_bg_qi, dim=(1, 2, 3))\\n bg_loss = -1 * torch.mean(bg_loss_ / bg_count) # mean reduce on batch\\n\\n total_loss = bg_loss + fg_loss\\n assert not torch.any(torch.isnan(total_loss)), \\\\\\n \\\"fg_loss: {} fg_count: {} bg_loss: {} bg_count: {}\\\".format(fg_loss, fg_count, bg_loss, bg_count)\\n\\n return total_loss, bg_loss, fg_loss\",\n \"def loss(self, X, y=None):\\n\\n # In dev testing, the loss fnc stops at \\\"scores\\\" , unfollowed by \\\"softmax\\\" probability prediction.\\n # In real testing, \\\"self.predict()\\\" needs to be implemented in Solver() class.\\n \\n if y is None:\\n for bn_param in self.bn_params:\\n bn_param[\\\"mode\\\"] = \\\"test\\\"\\n\\n\\n W1, b1 = self.params['W1'], self.params['b1']\\n gamma1, beta1 = self.params[\\\"sbnGamma1\\\"], self.params[\\\"sbnBeta1\\\"]\\n bn_param1 = self.bn_params[0]\\n\\n W2, b2 = self.params['W2'], self.params['b2']\\n gamma2, beta2 = self.params[\\\"sbnGamma2\\\"], self.params[\\\"sbnBeta2\\\"]\\n bn_param2 = self.bn_params[1]\\n\\n W3, b3 = self.params['W3'], self.params['b3']\\n gamma3, beta3 = self.params[\\\"bnGamma3\\\"], self.params[\\\"bnBeta3\\\"]\\n bn_param3 = self.bn_params[2]\\n\\n W4, b4 = self.params['W4'], self.params['b4']\\n \\n # pass conv_param to the forward pass for the convolutional layer\\n conv_param = self.conv_param\\n\\n # pass pool_param to the forward pass for the max-pooling layer\\n pool_param = self.maxpool_params\\n\\n ############################################################################\\n # TODO: Implement the forward pass for the three-layer convolutional net, #\\n # computing the class scores for X and storing them in the scores #\\n # variable. #\\n ############################################################################\\n \\n scores = None \\n cache = {}\\n # def conv_sbn_relu_forward(x, w, b, gamma, beta, conv_param, bn_param): return out, cache;\\n out, cache[\\\"layer1\\\"] = layer_utils.conv_sbn_relu_forward(X, W1, b1, gamma1, beta1, conv_param, bn_param1) \\n out, cache[\\\"layer2\\\"] = layer_utils.conv_sbn_relu_forward(out, W2, b2, gamma2, beta2, conv_param, bn_param2)\\n\\n # def max_pool_forward_fast(x, pool_param): return out, cache;\\n out, cache[\\\"maxpool\\\"] = fast_layers.max_pool_forward_fast(out, pool_param)\\n\\n # def affine_bn_relu_forward(x, w, b, gamma, beta, bn_param): return out, cache;\\n \\n out, cache[\\\"layer3\\\"] = layer_utils.affine_bn_relu_forward(out, W3, b3, gamma3, beta3, bn_param3)\\n\\n # def affine_forward(x, w, b): return out, cache;\\n scores, cache[\\\"layer4\\\"] = layers.affine_forward(out, W4, b4)\\n\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n if y is None:\\n return scores\\n \\n ############################################################################\\n # TODO: Implement the backward pass for the three-layer convolutional net, #\\n # storing the loss and gradients in the loss and grads variables. Compute #\\n # data loss using softmax, and make sure that grads[k] holds the gradients #\\n # for self.params[k]. Don't forget to add L2 regularization! #\\n ############################################################################\\n \\n loss, grads = 0, {}\\n\\n # def softmax_loss(x, y): return loss, dscore;\\n loss, dscores = layers.softmax_loss(scores, y)\\n loss += 0.5 * self.reg * (np.sum(W1 * W1) + np.sum(W2 * W2) + np.sum(W3 * W3) + np.sum(W4 * W4))\\n\\n # def affine_backward(dout, cache): return dx, dw, db;\\n dout, dW4, db4 = layers.affine_backward(dscores, cache[\\\"layer4\\\"]) \\n\\n # def affine_bn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\\n dout, dW3, db3, dgamma3, dbeta3 = layer_utils.affine_bn_relu_backward(dout, cache[\\\"layer3\\\"])\\n\\n # print cache[\\\"layer3\\\"]\\n\\n # def max_pool_backward_fast(dout, cache): return max_pool_backward_im2col(dout, real_cache);\\n # def max_pool_backward_im2col(dout, cache): return dx;\\n dout = fast_layers.max_pool_backward_fast(dout, cache[\\\"maxpool\\\"])\\n\\n # def conv_sbn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\\n dout, dW2, db2, dgamma2, dbeta2 = layer_utils.conv_sbn_relu_backward(dout, cache[\\\"layer2\\\"])\\n _, dW1, db1, dgamma1, dbeta1 = layer_utils.conv_sbn_relu_backward(dout, cache[\\\"layer1\\\"])\\n\\n # reg\\n grads['W4'], grads['b4'] = dW4 + self.reg * W4, db4\\n \\n grads['W3'], grads['b3'] = dW3 + self.reg * W3, db3\\n grads[\\\"bnGamma3\\\"], grads[\\\"bnBeta3\\\"] = dgamma3, dbeta3\\n\\n grads['W2'], grads['b2'] = dW2 + self.reg * W2, db2\\n grads[\\\"sbnGamma2\\\"], grads[\\\"sbnBeta2\\\"] = dgamma2, dbeta2\\n\\n grads['W1'], grads['b1'] = dW1 + self.reg * W1, db1\\n grads[\\\"sbnGamma1\\\"], grads[\\\"sbnBeta1\\\"] = dgamma1, dbeta1\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n return loss, grads\",\n \"def softmax_loss(x, y):\\n ############################################################################\\n # TODO: You can use the previous softmax loss function here. # \\n # Hint: Be careful on overflow problem #\\n ############################################################################\\n ############################################################################\\n # START OF YOUR CODE #\\n ############################################################################\\n N = len(x)\\n # We want to get the real y\\n log_C = -np.max(x,axis=1,keepdims = True)\\n # Get numerator\\n e_all = np.exp(x+log_C)\\n # Get the final prob\\n prob = e_all/e_all.sum(axis=1,keepdims=True)\\n # Find final loss\\n loss = np.sum(-np.log(prob)[np.arange(N),y])/N\\n # Get dx\\n dx = prob\\n dx[np.arange(N),y] -= 1\\n dx /= N\\n \\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n return loss, dx\",\n \"def loss(self, X, y=None, justLoss=False):\\n # N = X.shape[0]\\n # mode = 'test' if y is None else 'train'\\n scores = None\\n\\n W1, b1 = self.params['W1'], self.params['b1']\\n # W2, b2 = self.params['W2'], self.params['b2']\\n W3, b3 = self.params['W3'], self.params['b3']\\n\\n\\n conv_param = {'stride': 1, 'pad': 0}\\n pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\\n\\n\\n #######################################################################\\n # TODO: Implement the forward pass for the convolutional neural net, #\\n # computing the class scores for X and storing them in the scores #\\n # variable. #\\n #######################################################################\\n\\n conv1, conv_cache = conv_forward(X, W1, b1, conv_param)\\n relu1, relu_cache1 = relu_forward(conv1)\\n\\n # conv2, conv_cache2 = conv_forward(relu1, W2, b2, conv_param)\\n # relu2, relu_cache2 = relu_forward(conv2)\\n\\n scores, maxpool_cache = max_pool_forward(relu1, pool_param)\\n scores, forward_cache = fc_forward(scores, W3, b3)\\n \\n\\n\\n if y is None:\\n return scores\\n\\n loss, grads = 0, {}\\n #######################################################################\\n # TODO: Implement the backward pass for the convolutional neural net, #\\n # storing the loss and gradients in the loss and grads variables. #\\n # Compute data loss using softmax, and make sure that grads[k] holds #\\n # the gradients for self.params[k]. #\\n loss, dscores = softmax_loss(scores, y)\\n\\n if justLoss:\\n return loss\\n # print(loss)\\n\\n\\n dx_3, grads['W3'], grads['b3'] = fc_backward(dscores, forward_cache)\\n dx_3 = max_pool_backward(dx_3, maxpool_cache)\\n\\n # dx_2 = relu_backward(dx_3, relu_cache2)\\n # dx_2, grads['W2'], grads['b2'] = conv_backward(dx_3, conv_cache2)\\n\\n dx = relu_backward(dx_3, relu_cache1)\\n dx, grads['W1'], grads['b1'] = conv_backward(dx, conv_cache)\\n \\n \\n\\n return loss, grads\",\n \"def softmax_loss_naive(W, X, y, reg):\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n num_train=X.shape[0]\\n num_class=W.shape[1]\\n num_feature=X.shape[1]\\n #############################################################################\\n # TODO: Compute the softmax loss and its gradient using explicit loops. #\\n # Store the loss in loss and the gradient in dW. If you are not careful #\\n # here, it is easy to run into numeric instability. Don't forget the #\\n # regularization! #\\n #############################################################################\\n for i in range(num_train):\\n #W*Xi C*1\\n x=np.exp(np.dot(W.T,X[i,:]))\\n denominator=np.sum(x)\\n numerator=x[y[i]]\\n loss-=np.log(numerator/denominator)\\n #numerator and denominator\\n #for j in range(num_class):\\n normalize_score=x/denominator\\n nm=np.reshape(normalize_score, (num_class, 1))\\n \\n #CxD\\n dscore=nm.dot(np.reshape(X[i,:],(1,num_feature)))\\n #print(dscore.shape)\\n\\n dscore[y[i],:]-=X[i,:]\\n dW+=dscore.T\\n\\n loss/=num_train\\n dW = dW/num_train + reg*W\\n #\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n\\n return loss, dW\",\n \"def softmax_loss_vectorized(W, X, y, reg):\\n\\n #############################################################################\\n # TODO: Compute the softmax.ipynb loss and its gradient using no explicit loops. #\\n # Store the loss in loss and the gradient in dW. If you are not careful #\\n # here, it is easy to run into numeric instability. Don't forget the #\\n # regularization! #\\n #############################################################################\\n\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n train_images = X.shape[0]\\n # Store all the scores in a matrix\\n all_scores = np.dot(X,W)\\n #First, calculate the normalizing constant for numeric stability\\n constant = np.max(all_scores,axis=1)\\n normalized_scores = np.transpose(np.subtract(np.transpose(all_scores),constant))\\n\\n #Then, calculate softmax for the correct scores\\n exp_scores = np.exp(all_scores)\\n # First, keep track of the sum of values per row\\n exp_sum = np.sum(exp_scores,axis=1)\\n\\n # Finally, calculate the softmax score for every entry\\n softmax_scores = np.transpose(exp_scores)/exp_sum # useful when computing gradient\\n softmax_scores = np.transpose(softmax_scores)\\n # And then, compute the loss\\n loss_score = softmax_scores[range(train_images),y]\\n loss_score = -1 * np.log(loss_score) #taking the logarithm\\n loss += np.sum(loss_score)\\n\\n #Normalize and regularize the loss\\n loss /= train_images\\n loss += 0.5*reg*np.sum(W*W)\\n\\n #Finally, calculate a vectorized gradient\\n\\n # Calculate the derivative at the correct label\\n softmax_scores[range(train_images),y] -= 1\\n # Then, make a matrix containing all the gradient values\\n gradient_values = np.dot(np.transpose(X),softmax_scores)\\n gradient_values = gradient_values\\n\\n #FINALLY, update the gradient\\n dW+= gradient_values\\n #And normalize and regularize it\\n dW /= train_images\\n dW += reg*W\\n\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n\\n return loss, dW\",\n \"def softmax_loss_naive(W, X, y, reg):\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n num_train = X.shape[0]\\n num_class = W.shape[1]\\n #scores = np.zeros(num_train,num_class)\\n scores = X.dot(W)\\n #############################################################################\\n # TODO: Compute the softmax loss and its gradient using explicit loops. #\\n # Store the loss in loss and the gradient in dW. If you are not careful #\\n # here, it is easy to run into numeric instability. Don't forget the #\\n # regularization! #\\n #############################################################################\\n for i in range(num_train):\\n # compute Li\\n fmax= np.max(scores[i])\\n scores[i] -= fmax\\n correct_class_score = scores[i,y[i]]\\n M = np.exp(correct_class_score)/np.sum(np.exp(scores[i]))\\n loss += -np.log(M)\\n for j in range(num_class):\\n N = np.exp(scores[i,j])/np.sum(np.exp(scores[i]))\\n if j ==y[i]:\\n dW[:,y[i]]+= (M-1)*X[i].T\\n else:\\n dW[:,j] += N*X[i].T \\n loss /= num_train\\n loss += reg*np.sum(W*W)\\n dW /= num_train \\n dW += 2*reg*W \\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n\\n return loss, dW\",\n \"def softmax_loss(x, y):\\n def softmax(x):\\n exps = np.exp(x)\\n return exps / np.sum(exps, axis=1)[:,None]\\n\\n N = y.shape[0]\\n p = softmax(x)\\n log_likelihood = -np.log(p[range(N),y])\\n loss = np.sum(log_likelihood) / N\\n\\n dx = p.copy()\\n dx[range(N),y] -= 1\\n dx = dx/N\\n\\n return loss, dx\",\n \"def naive_softmax_loss_and_gradient(\\n center_word_vec,\\n outside_word_idx,\\n outside_vectors,\\n dataset\\n):\\n\\n ### YOUR CODE HERE\\n \\n center_word_vec = center_word_vec.reshape((center_word_vec.shape[0], 1))\\n center_dot_outside = np.dot(outside_vectors, center_word_vec)\\n prob = softmax(center_dot_outside.reshape(-1)).reshape(-1, 1) \\n loss = -np.log(prob[outside_word_idx])\\n \\n prob_complement = prob.copy()\\n prob_complement[outside_word_idx] -= 1.0\\n \\n grad_center_vec = np.dot(outside_vectors.T, prob_complement).flatten()\\n \\n grad_outside_vecs = np.dot(prob_complement, center_word_vec.T)\\n\\n ### END YOUR CODE\\n\\n return loss, grad_center_vec, grad_outside_vecs\",\n \"def compute_loss(self):\\n self.prototypes = self.compute_prototypes()\\n self.test_logits = self.compute_logits()\\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.episode.test_labels, logits=self.test_logits)\\n cross_entropy_loss = tf.reduce_mean(loss)\\n regularization = tf.reduce_sum(\\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\\n loss = cross_entropy_loss + self.weight_decay * regularization\\n return loss\",\n \"def svm_loss(scores, y):\\r\\n\\r\\n N = scores.shape[0]\\r\\n\\r\\n # Compute svm data loss\\r\\n correct_class_scores = scores[range(N), y]\\r\\n margins = np.maximum(0.0, scores - correct_class_scores[:, None] + 1.0)\\r\\n margins[range(N), y] = 0.0\\r\\n loss = np.sum(margins) / N\\r\\n\\r\\n # Compute gradient off loss function w.r.t. scores\\r\\n num_pos = np.sum(margins > 0, axis=1)\\r\\n dscores = np.zeros(scores.shape)\\r\\n dscores[margins > 0] = 1\\r\\n dscores[range(N), y] -= num_pos\\r\\n dscores /= N\\r\\n\\r\\n return loss, dscores\",\n \"def lossFun(self, inputs, targets, hprev):\\n xs, hs, ys, ps = {}, {}, {}, {}\\n hs[-1] = np.copy(hprev)\\n loss = 0\\n # forward pass\\n for t in range(len(inputs)):\\n xs[t] = np.zeros((self._txt_reader.vocab_size,1)) # One-hot, encode in 1-of-k representation\\n xs[t][inputs[t]] = 1\\n hs[t] = np.tanh(np.dot(self._Wxh, xs[t]) + np.dot(self._Whh, hs[t-1]) + self._bh) # compute chidden state\\n ys[t] = np.dot(self._Why, hs[t]) + self._by # logits \\n ys[t] -= ys[t].max() # for numerical stability\\n ps[t] = np.exp(ys[t]) / np.sum(np.exp(ys[t])) # probabilities for next chars\\n\\n loss += -np.log(ps[t][targets[t],0]) # softmax (cross-entropy loss)\\n\\n # backward pass: compute gradients going backwards\\n dWxh, dWhh, dWhy = np.zeros_like(self._Wxh), np.zeros_like(self._Whh), np.zeros_like(self._Why)\\n dbh, dby = np.zeros_like(self._bh), np.zeros_like(self._by)\\n\\n dhnext = np.zeros_like(hs[0])\\n for t in reversed(range(len(inputs))):\\n dy = np.copy(ps[t])\\n dy[targets[t]] -= 1 # backprop into y. see http://cs231n.github.io/neural-networks-case-study/#grad if confused here\\n dWhy += np.dot(dy, hs[t].T)\\n dby += dy\\n dh = np.dot(self._Why.T, dy) + dhnext # backprop into h\\n dhraw = (1 - hs[t] * hs[t]) * dh # backprop through tanh nonlinearity\\n dbh += dhraw\\n dWxh += np.dot(dhraw, xs[t].T)\\n dWhh += np.dot(dhraw, hs[t-1].T)\\n dhnext = np.dot(self._Whh.T, dhraw)\\n\\n for dparam in [dWxh, dWhh, dWhy, dbh, dby]:\\n np.clip(dparam, -5, 5, out=dparam) # clip to mitigate exploding gradients\\n return loss, dWxh, dWhh, dWhy, dbh, dby, hs[len(inputs)-1]\",\n \"def softmax_loss_naive(W, X, y, reg):\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n\\n #############################################################################\\n # TODO: Compute the softmax loss and its gradient using explicit loops. #\\n # Store the loss in loss and the gradient in dW. If you are not careful #\\n # here, it is easy to run into numeric instability. Don't forget the #\\n # regularization! #\\n #############################################################################\\n # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\\n\\n num_train = X.shape[0]\\n # print(\\\"num_train:\\\", num_train)\\n num_classes = W.shape[1]\\n # print(\\\"num_classes:\\\", num_classes)\\n \\n for i in range(num_train):\\n scores = X[i].dot(W) # scores is 1 * C\\n correct_class = y[i]\\n \\n # LOSS DUE TO TRAINING SAMPLE = -log(exp^correct_score / sum(exp^all_other_scores))\\n log_c = np.max(scores)\\n scores -= log_c\\n correct_class_score = scores[correct_class]\\n exp_scores = np.exp(scores)\\n sum_exp_scores = np.sum(np.exp(scores))\\n proportion = np.exp(correct_class_score) / sum_exp_scores\\n loss -= np.log(proportion)\\n # print(proportion)\\n \\n # ALTERNATIVELY: (we split the log)\\n# loss -= scores[y[i]]\\n# loss += np.log(np.sum(np.exp(X[i].dot(W))))\\n \\n # UPDATE GRADIENT\\n for j in range(num_classes):\\n p = np.exp(scores[j]) / sum_exp_scores # \\\"probability\\\" of class j\\n dW[:,j] += (p - (j == y[i])) * X[i,:]\\n # dW is D by C\\n\\n loss /= num_train\\n loss += reg * np.sum(W * W) \\n dW /= num_train\\n dW += reg * 2 * W\\n\\n # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\\n \\n return loss, dW\",\n \"def JS_loss_fun_grad(teacher_preds, student_pred, graph):\\n # if FLAGS.heat:\\n # student_pred = logit2prob_heat(student_pred)\\n # else:\\n # student_pred = logit2prob(student_pred) \\n student_pred = logit2prob(student_pred)\\n loss = noisy_op.compute_loss(student_pred, teacher_preds, graph, name=\\\"nosiy_loss\\\")\\n # loss.set_shape((1,))\\n tf.add_to_collection('losses', loss)\\n return tf.add_n(tf.get_collection('losses'), name='total_loss'), loss\",\n \"def compute_loss(self, X, y):\\r\\n # INSERT YOUR CODE HERE\\r\\n #raise Exception('Function not yet implemented!')\\r\\n\\r\\n # Computing the loss using the below formula\\r\\n # Loss = -(1/m)*sum( (y_i)*log(σ(wTx_i)) + (1-y_i)*log(1 - σ(wTx_i)))\\r\\n # m = number of examples and i for ith example\\r\\n\\r\\n loss = 0\\r\\n X = np.append(X, np.array([[1]]*X.shape[0]), axis=1)\\r\\n # for idx,example in enumerate(X):\\r\\n # loss = loss + y[idx] * np.log(self.sigmoid(np.dot(example, self.w))) + (1 - y[idx]) * np.log(1 - self.sigmoid(np.dot(example, self.w)))\\r\\n # loss = -loss/ X.shape[0]\\r\\n\\r\\n loss = -np.mean(y * np.log(self.sigmoid(np.dot(X, self.w))) + (1 - y) * np.log(1 - self.sigmoid(np.dot(X, self.w))))\\r\\n return loss\",\n \"def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\\n\\n\\t#calculate the predictions\\n\\t#outputVectors: U: (V,d) ->!!diff from 3(a) dimension\\n\\tvhat = predicted\\t#center word or BOW: (d,1)\\n\\tz = np.dot(outputVectors, vhat)\\t#(V,1)\\n\\tpreds = softmax(z)\\t#yhat: (V,1)\\n\\n\\t#calculate the cost \\n\\tcost = -np.log(preds[target])\\n\\n\\t#gradients\\n\\tgrad_pred = preds \\n\\tgrad_pred[target] -= 1\\t#yhat - y\\n\\n\\tgrad = np.outer(grad_pred, vhat)\\t#(V, d)\\n\\tgradPred = np.dot(outputVectors.T, grad_pred)\\t#dvc\\n\\n\\treturn cost, gradPred, grad\",\n \"def get_loss(self, x, y):\\n \\\"*** YOUR CODE HERE question 3 ***\\\"\\n return nn.SoftmaxLoss(self.run(x), y)\",\n \"def softmax_loss_naive(W, X, y, reg):\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n\\n #############################################################################\\n # TODO: Compute the softmax loss and its gradient using explicit loops. #\\n # Store the loss in loss and the gradient in dW. If you are not careful #\\n # here, it is easy to run into numeric instability. Don't forget the #\\n # regularization! #\\n #############################################################################\\n num_train = X.shape[0]\\n num_classe = W.shape[1]\\n loss = 0.0\\n\\n for i in range(num_train): #pour chaque image de l'ensemble d'entrainement\\n scores = X[i].dot(W)\\n scores -= max(scores)\\n\\n correct_class_score = scores[y[i]] #y[i]=c\\n e_syi = np.exp(correct_class_score)\\n e_sj = np.sum(np.exp(scores))\\n\\n loss -= np.log(e_syi/e_sj)\\n\\n for k in range(num_classe): #pour chaque classe\\n dW[:, k] += ((np.exp(scores[k])/e_sj) - (k == y[i])) * X[i].T\\n\\n # Right now the loss is a sum over all training examples, but we want it\\n # to be an average instead so we divide by num_train.\\n loss /= num_train\\n dW/= num_train\\n\\n # Add regularization to the loss.\\n loss += reg * np.sum(W * W)\\n dW += 2 * reg * W\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n\\n return loss, dW\",\n \"def lossFunc(inputs, targets, hprev):\\n xs, hs, ys, ps = {}, {}, {}, {} # input, hidden, output, out_prob states for each time t\\n hs[-1] = np.copy(hprev)\\n loss = 0\\n \\n # forward pass\\n for t in xrange(len(inputs)):\\n xs[t] = np.zeros((vocab_size,1)) \\n xs[t][inputs[t]] = 1. # convert input to one-hot\\n hs[t] = np.tanh(np.dot(Wxh, xs[t]) + np.dot(Whh, hs[t-1]) + bh)\\n ys[t] = np.dot(Why, hs[t]) + by\\n ps[t] = np.exp(ys[t]) / np.sum(np.exp(ys[t]))\\n loss += -np.log(ps[t][targets[t],0])\\n \\n # backward pass\\n dWxh, dWhh, dWhy = np.zeros_like(Wxh), np.zeros_like(Whh), np.zeros_like(Why)\\n dbh, dby = np.zeros_like(bh), np.zeros_like(by)\\n dhnext = np.zeros_like(hs[0])\\n for t in reversed(xrange(len(inputs))):\\n # backprop into y\\n dy = np.copy(ps[t])\\n dy[targets[t]] -= 1\\n # backprop into Why, hs, and by\\n dWhy += np.dot(dy, hs[t].T)\\n dby += dy\\n dh = np.dot(Why.T, dy) + dhnext\\n # backprop through tanh activition\\n dhraw = (1 - hs[t] * hs[t]) * dh\\n # backprop into Wxh, Whh, hs, and bh\\n dbh += dhraw\\n dWxh += np.dot(dhraw, xs[t].T)\\n dWhh += np.dot(dhraw, hs[t-1].T)\\n dhnext = np.dot(Whh.T, dhraw)\\n # clip gradient preventing exploding\\n for dparam in [dWxh, dWhh, dWhy, dbh, dby]:\\n np.clip(dparam, -5, 5, out=dparam)\\n\\n return loss, dWxh, dWhh, dWhy, dbh, dby, hs[len(inputs)-1]\",\n \"def compute_loss(self, x, gt):\\n loss = sum([torch.mean((out - gt)**2) for out in self.forward(x)])\\n return loss\",\n \"def softmax_loss_naive(W, X, y, reg):\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n\\n #############################################################################\\n # TODO: Compute the softmax loss and its gradient using explicit loops. #\\n # Store the loss in loss and the gradient in dW. If you are not careful #\\n # here, it is easy to run into numeric instability. Don't forget the #\\n # regularization! #\\n #############################################################################\\n for i in range(X.shape[0]):\\n scores = X[i].dot(W)\\n \\n idx_max = np.argmax(scores)\\n s_max = scores[idx_max]\\n scores -= s_max # shift for numerical stability\\n \\n temp = np.exp(scores)\\n summation = np.sum(temp)\\n loss += (- scores[y[i]] + np.log(summation))\\n \\n # computing gradients\\n # (1) an explicit version:\\n# for j in range(W.shape[1]):\\n# if j == y[i]:\\n# dW[:, j] -= X[i]\\n# dW[:, idx_max] -= (-X[i])\\n \\n# dW[:, j] += (1 / summation) * temp[j] * X[i]\\n# dW[:, idx_max] += (1 / summation) * temp[j] * (-X[i])\\n# elif j == idx_max:\\n# dW[:, j] += 0 # X[i] + (-X[i]) = 0\\n# else:\\n# dW[:, j] += (1 / summation) * temp[j] * X[i]\\n# dW[:, idx_max] += (1 / summation) * temp[j] * (-X[i])\\n \\n # (2) a more concise version:\\n softmax_scores = temp / summation\\n for j in range(W.shape[1]):\\n if j == y[i]:\\n dW[:, j] += (-1 + softmax_scores[j]) * X[i]\\n else:\\n dW[:, j] += softmax_scores[j] * X[i]\\n \\n loss /= X.shape[0]\\n dW /= X.shape[0]\\n \\n loss += reg * np.sum(W * W)\\n dW += 2 * reg * W\\n\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n\\n return loss, dW\",\n \"def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\\n\\n # Implement the cost and gradients for one predicted word vector\\n # and one target word vector as a building block for word2vec\\n # models, assuming the softmax prediction function and cross\\n # entropy loss.\\n\\n # Inputs:\\n # - predicted: numpy ndarray, predicted word vector (\\\\hat{v} in\\n # the written component or \\\\hat{r} in an earlier version)\\n # - target: integer, the index of the target word\\n # - outputVectors: \\\"output\\\" vectors (as rows) for all tokens\\n # - dataset: needed for negative sampling, unused here.\\n\\n # Outputs:\\n # - cost: cross entropy cost for the softmax word prediction\\n # - gradPred: the gradient with respect to the predicted word\\n # vector\\n # - grad: the gradient with respect to all the other word\\n # vectors\\n\\n # We will not provide starter code for this function, but feel\\n # free to reference the code you previously wrote for this\\n # assignment!\\n\\n ### YOUR CODE HERE\\n yhat = softmax(np.dot(outputVectors, predicted))\\n\\n cost = -np.log(yhat[target])\\n\\n yhat_y = yhat.copy()\\n yhat_y[target] -= 1\\n\\n gradPred = np.dot(yhat_y, outputVectors)\\n\\n grad = yhat_y[:, np.newaxis] * np.tile(predicted, (yhat_y.shape[0], 1))\\n ### END YOUR CODE\\n\\n return cost, gradPred, grad\",\n \"def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\\n\\n ### YOUR CODE HERE\\n # identify the target predicted vector and then find the dot product\\n # between the vector and the output vectors\\n # outputVector structured as V x D \\n # v_c structured as 1xD matrix\\n # we are assuming here that the output vector and the \\n # predicted vector is structured so that each row represent a word / token in {1, V}\\n v_c = predicted\\n z_w = np.dot(outputVectors, v_c)\\n # the output yhat is a 1xV matrix\\n yhat = softmax(z_w)\\n # create the one hot vector for the predicted word\\n # calculate the difference for gradient\\n ydiff = yhat.copy()\\n ydiff[target] -= 1.0\\n\\n # find the cross-entropy cost function based on yhat\\n # cost = calc_cost_from_prediction(y, yhat)\\n cost = - np.log( yhat[target] )\\n\\n # calculate the gradient wrt to the v_c (the predicted word vector)\\n # the gradient is U(yhat - y)\\n # the output should be a D x 1 matrix, same as v_c\\n # y is a one-hot vector that represents the actual word\\n # and we multiply it by output vector, it can also be calculated\\n # by using index to find the vector\\n gradPred = np.dot( outputVectors.T, ydiff)\\n\\n\\n # calculate the gradient wrt to all other word vectors\\n # the gradient is v_c(yhat - y)\\n # we multiple yhat by v_c to get a V x D matrix\\n grad = np.outer(ydiff, v_c)\\n\\n ### END YOUR CODE\\n return cost, gradPred, grad\",\n \"def softmax_classifier(W, input, label, lamda):\\n\\n ############################################################################\\n # TODO: Put your code here\\n\\n loss = 0.0\\n num_train = input.shape[0]\\n num_classes = W.shape[1]\\n\\n score = np.dot(input, W) # (N,C)\\n prediction = np.argmax(score, axis=1)\\n score -= np.max(score, axis=1, keepdims=True)\\n\\n # # cross entropy loss\\n # # take exponent of the score and normalized with sum of all exponents.\\n probs = np.exp(score) # (N,C)\\n e_y = np.sum(np.multiply(probs,label), axis=1) # (N,) probability for correct class\\n e_sum = np.sum(probs, axis=1) # (N,) sum of probability over all classes\\n\\n # implementation of loss equivalent l_i = -f_y_i + log sum_j(e^(f_j))\\n # loss = np.sum(-np.log(e_y/e_sum)) # sum of -log across all samples.\\n # loss /= num_train # average loss\\n loss = np.sum(-1 * e_y) + np.sum(np.log(e_sum))\\n loss /= num_train\\n\\n loss += lamda * np.sum(W * W) # regularization \\n\\n # Gradient\\n delta_score = probs / e_sum.reshape(num_train,1) # (N,C)\\n delta_score -= label # (NxC)\\n gradient = np.dot(input.T, delta_score)\\n gradient /= num_train\\n gradient += lamda * 2 * W\\n\\n ############################################################################\\n\\n return loss, gradient, prediction\",\n \"def backward_val(self):\\n self.loss_similarity = [NCC(warped_img, self.batch_fixed) for warped_img in self.warped_img_list]\\n self.loss_similarity_mean = torch.mean(torch.stack(self.loss_similarity))\\n self.loss_smooth = [GradNorm(disp_map) for disp_map in self.disp_list]\\n self.loss_smooth_mean = torch.mean(torch.stack(self.loss_smooth))\\n if len(self.strain_compensated_list) > 1:\\n self.loss_consistency_strain = [NCC(self.strain_compensated_list[t-1][:,:,143:-143,:], self.strain_compensated_list[t][:,:,143:-143,:]) for t in range(1, len(self.strain_compensated_list))]\\n self.loss_consistency_strain_mean = torch.mean(torch.stack(self.loss_consistency_strain))\\n self.loss_total = 1 - self.loss_similarity_mean + self.loss_smooth_mean * self.alpha + (1 - self.loss_consistency_strain_mean) * self.beta\\n else:\\n self.loss_total = 1 - self.loss_similarity_mean + self.loss_smooth_mean * self.alpha\",\n \"def softmax_loss_naive(W, X, y, reg):\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n\\n #############################################################################\\n # TODO: Compute the softmax loss and its gradient using explicit loops. #\\n # Store the loss in loss and the gradient in dW. If you are not careful #\\n # here, it is easy to run into numeric instability. Don't forget the #\\n # regularization! #\\n #############################################################################\\n # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\\n\\n for i in range(X.shape[0]):\\n# c = np.matmul(X[i],W)\\n# c -= np.amax(c)\\n# e_c = np.exp(c)\\n# denom = np.sum(e_c)\\n# #Nice fact: we know that the largest element in c will also be the largest softmax value, so we only\\n# # need to transform that one value. \\n# sm_c = e_c/denom\\n# \\n# loss1 += -np.log(sm_c[y[i]])\\n\\n # Need to make this whole dang thing more numerically stable. \\n c = np.matmul(X[i],W)\\n c -= np.amax(c)\\n e_c = np.exp(c)\\n denom = np.sum(e_c)\\n sm_c = e_c/denom\\n\\n loss += np.log(denom) - c[y[i]]\\n# print(-np.log(sm_c[y[i]]) - (np.log(denom)-c[y[i]]))\\n\\n \\\"\\\"\\\"They are basically the same value\\\"\\\"\\\"\\n\\n # now computing some gradients\\n dL_ds = sm_c\\n dL_ds[y[i]] -= 1\\n #note that sm_c is modified now!\\n \\\"\\\"\\\" #ah, something fundamentally different is happening with numpy. When an array element\\n is changed, it's really changed for good. And it changes for all pointers pointing to same object.\\n yikes. Actually it's the same with python lists. Anything pointing to And underlying object can\\n change that underlying object for all things that point to it. Alas.\\\"\\\"\\\"\\n# import pdb; pdb.set_trace()\\n \\\"\\\"\\\"Okay I just coudln't bear the for loops...\\\"\\\"\\\"\\n dW_update = np.matmul(X[i].reshape(1,X.shape[1]).T,dL_ds[np.newaxis,:])\\n dW+=dW_update\\n # for n in range(W.shape[0]):\\n# for m in range(W.shape[1]):\\n# if m == y[i]:\\n# dW[n,m] += X[i,n]*(sm_c[m]-e_c[m])\\n# else:\\n# dW[n,m] += X[i,n]*sm_c[m]\\n\\n # should be numerically unstable I think.\\n\\n loss /= X.shape[0]\\n loss += reg*np.sum(W*W)\\n\\n dW /= X.shape[0]\\n dW += reg*2*W\\n # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\\n\\n return loss, dW\",\n \"def softmax_loss(x, y):\\n probs = np.exp(x - np.max(x, axis=1, keepdims=True))\\n probs /= np.sum(probs, axis=1, keepdims=True)\\n N = x.shape[0]\\n loss = -np.sum(np.log(probs[np.arange(N), y])) / N\\n dx = probs.copy()\\n dx[np.arange(N), y] -= 1\\n dx /= N\\n return loss, dx\",\n \"def softmax_loss_naive(W, X, y, reg):\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n num_train = X.shape[1]\\n num_classes = W.shape[0]\\n #############################################################################\\n # Compute the softmax loss and its gradient using explicit loops. #\\n # Store the loss in loss and the gradient in dW. If you are not careful #\\n # here, it is easy to run into numeric instability. Don't forget the #\\n # regularization! #\\n #############################################################################\\n for i in range(num_train): # for each image\\n # compute the score\\n scores = W.dot(X[:, i])\\n\\n # shift the values of f so that the highest number is 0:\\n scores -= np.max(scores)\\n\\n # compute the loss\\n loss += -np.log(np.exp(scores[y[i]]) / np.sum(np.exp(scores)))\\n\\n # gradient(https://github.com/seyedamo/cs231n/blob/master/assignment1/cs231n/classifiers/softmax.py)\\n scores = np.exp(scores)\\n scores /= np.sum(scores)\\n for j in range(num_classes): # for each class\\n dW[j, :] += scores[j] * X[:, i].T\\n\\n # dW wrt correct class scores w_yi\\n dW[y[i], :] += -X[:, i].T\\n\\n # Average the loss \\n loss /= num_train\\n\\n # Add regularization to the loss.\\n loss += 0.5 * reg * np.sum(W * W)\\n\\n # average of the gradient\\n dW /= num_train\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n return loss, dW\",\n \"def loss(self, labels, input_data):\\n\\n pred, out = self.inference(input_data)\\n loss = tf.reduce_mean(tf.losses.sparse_softmax_cross_entropy(labels, out), name=\\\"loss\\\") + \\\\\\n tf.losses.get_regularization_loss()\\n return loss, pred\",\n \"def calc_loss(self, x: np.ndarray, y: np.ndarray) -> float:\\n return self.descent.calc_loss(x, y)\",\n \"def grad_softmax_cross_entropy_loss(logit, labels):\\n return softmax(logit) - labels\",\n \"def loss(self, X, y=None):\\n X = X.astype(self.dtype)\\n mode = 'test' if y is None else 'train'\\n\\n # We are gonna store everythin in a dictionnary hidden\\n hidden = {}\\n hidden['h0'] = X.reshape(X.shape[0], np.prod(X.shape[1:]))\\n\\n for i in range(self.L):\\n idx = i + 1\\n # Naming of the variable\\n w = self.params['W' + str(idx)]\\n b = self.params['b' + str(idx)]\\n h = hidden['h' + str(idx - 1)]\\n\\n # Computing of the forward pass.\\n # Special case of the last layer (output)\\n if idx == self.L:\\n h, cache_h = affine_forward(h, w, b)\\n hidden['h' + str(idx)] = h\\n hidden['cache_h' + str(idx)] = cache_h\\n\\n # For all other layers\\n else:\\n h, cache_h = affine_relu_forward(h, w, b)\\n hidden['h' + str(idx)] = h\\n hidden['cache_h' + str(idx)] = cache_h\\n\\n scores = hidden['h' + str(self.L)]\\n\\n # If test mode return early\\n if mode == 'test':\\n return scores\\n\\n # Computing of the loss\\n data_loss, dscores = softmax_loss(scores, y)\\n reg_loss = 0\\n for w in [self.params[f] for f in self.params.keys() if f[0] == 'W']:\\n reg_loss += 0.5 * self.reg * np.sum(w * w)\\n\\n loss = data_loss + reg_loss\\n\\n # Backward pass\\n\\n hidden['dh' + str(self.L)] = dscores\\n for i in range(self.L)[::-1]:\\n idx = i + 1\\n dh = hidden['dh' + str(idx)]\\n h_cache = hidden['cache_h' + str(idx)]\\n if idx == self.L:\\n dh, dw, db = affine_backward(dh, h_cache)\\n hidden['dh' + str(idx - 1)] = dh\\n hidden['dW' + str(idx)] = dw\\n hidden['db' + str(idx)] = db\\n else:\\n dh, dw, db = affine_relu_backward(dh, h_cache)\\n hidden['dh' + str(idx - 1)] = dh\\n hidden['dW' + str(idx)] = dw\\n hidden['db' + str(idx)] = db\\n\\n # w gradients where we add the regulariation term\\n list_dw = {key[1:]: val + self.reg * self.params[key[1:]]\\n for key, val in hidden.iteritems() if key[:2] == 'dW'}\\n # Paramerters b\\n list_db = {key[1:]: val for key, val in hidden.iteritems() if key[:2] == 'db'}\\n # Parameters gamma\\n list_dgamma = {key[1:]: val for key, val in hidden.iteritems() if key[:6] == 'dgamma'}\\n # Paramters beta\\n list_dbeta = {key[1:]: val for key, val in hidden.iteritems() if key[:5] == 'dbeta'}\\n grads = {}\\n grads.update(list_dw)\\n grads.update(list_db)\\n grads.update(list_dgamma)\\n grads.update(list_dbeta)\\n return loss, grads\",\n \"def softmax_loss_naive(W, X, y, reg):\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n\\n # needed for calculations\\n num_train = X.shape[1]\\n\\n for i in xrange(num_train):\\n # calculate the scores for the current training example with the current weights\\n scores = W.dot(X[:, i])\\n # scale by the max for numerical stability\\n scores -= np.max(scores)\\n # calculate the loss\\n loss += -scores[y[i]] + np.log(np.sum(np.exp(scores)))\\n\\n ## L' = -1_y + 1/(\\\\sum_{}^{} e^f) * e^f\\n # e^f\\n scores = np.exp(scores)\\n # 1/(\\\\sum_{}^{} e^f)\\n scores /= np.sum(scores)\\n # -1_y\\n scores[y[i]] -= 1\\n\\n # now scale it by the data\\n # we need to use [:, np.newaxis] because when you make a X by 1 dimension slices in numpy the 1 dimension is null\\n dW += scores[:, np.newaxis].dot(X[:, i][:, np.newaxis].T)\\n\\n\\n # get the average loss\\n loss /= num_train\\n # get the average gradient\\n dW /= num_train\\n\\n # regularize the loss function\\n loss += 0.5 * reg * np.sum(W * W)\\n\\n return loss, dW\",\n \"def _compute_loss(self, parameters, inputs, ground_truth):\\n predictions = self.network_forward(parameters, inputs)\\n loss = np.mean((ground_truth - predictions) ** 2)\\n return loss\",\n \"def _compute_loss(self, parameters, inputs, ground_truth):\\n predictions = self.network_forward(parameters, inputs)\\n loss = np.mean((ground_truth - predictions) ** 2)\\n return loss\",\n \"def loss_fn(gr_truth, pred):\\n return 100 * dice_loss(pred, gr_truth) + softmax_weighted_loss(pred, gr_truth)\",\n \"def _loss_gradient(x0, x1, b, w, lam, weights=None):\\n nvars = len(w)\\n\\n # initialize + regularization term\\n loss = 0.5 * lam * np.sum(w ** 2)\\n gradient = np.zeros(nvars + 1) # first position is b\\n gradient[1:] = lam * w\\n\\n # we need prediction for x\\n pred_x_0_1 = [LogisticRegression._sigmoid(x0, b, w), LogisticRegression._sigmoid(x1, b, w)]\\n\\n # the log likelihood\\n log_like_x_0_1 = [np.log(1.0 - pred_x_0_1[0]),\\n np.log(pred_x_0_1[1])]\\n\\n # also need the error for gradient.\\n error = [pred_x_0_1[0],\\n pred_x_0_1[1] - 1]\\n\\n if weights is None:\\n loss += -np.sum(log_like_x_0_1[1]) - np.sum(log_like_x_0_1[0])\\n gradient[0] += np.sum(error[0]) + np.sum(error[1]) # * 1 for bias term \\n for k in range(nvars):\\n gradient[k + 1] += np.sum(error[0] * x0[:, k]) + np.sum(error[1] * x1[:, k])\\n else:\\n loss += -np.sum(weights[1] * log_like_x_0_1[1]) - np.sum(weights[0] * log_like_x_0_1[0])\\n gradient[0] += np.sum(error[0] * weights[0]) + np.sum(error[1] * weights[1])\\n for k in range(nvars):\\n gradient[k + 1] += ( np.sum(weights[0] * error[0] * x0[:, k]) +\\n np.sum(weights[1] * error[1] * x1[:, k]) )\\n return loss, gradient\",\n \"def compute_loss_and_gradients(self, X, y):\\n # Before running forward and backward pass through the model,\\n # clear parameter gradients aggregated from the previous pass\\n # TODO Set parameter gradient to zeros\\n # Hint: using self.params() might be useful!\\n self.fulllayer1.W.grad = np.zeros_like(self.fulllayer1.W.grad)\\n self.fulllayer1.B.grad = np.zeros_like(self.fulllayer1.B.grad)\\n self.fulllayer2.W.grad = np.zeros_like(self.fulllayer2.W.grad)\\n self.fulllayer2.B.grad = np.zeros_like(self.fulllayer2.B.grad)\\n\\n\\n # TODO Compute loss and fill param gradients\\n # by running forward and backward passes through the model\\n res = self.fulllayer1.forward(X)\\n res2 = self.reglayer1.forward(res)\\n res3 = self.fulllayer2.forward(res2)\\n\\n loss, grad = softmax_with_cross_entropy(res3, y)\\n\\n back3 = self.fulllayer2.backward(grad)\\n back2 = self.reglayer1.backward(back3)\\n back = self.fulllayer1.backward(back2)\\n \\n # After that, implement l2 regularization on all params\\n # Hint: self.params() is useful again!\\n\\n for params in self.params().keys():\\n # print(params)\\n # print(self.params()[params].value)\\n loc_loss, loc_grad = l2_regularization(self.params()[params].value, self.reg)\\n loss += loc_loss\\n self.params()[params].grad += loc_grad\\n\\n return loss\",\n \"def full_loss(preds, targets, chamfer_lambda, physical_lambda, has_anno=None, joint_idxs=None):\\n\\n coords_pred = preds[2]\\n if has_anno is not None:\\n coords_pred = coords_pred[has_anno]\\n if joint_idxs is not None:\\n coords_pred = coords_pred[:, joint_idxs]\\n\\n # Coord Loss Only\\n coord_loss = F.mse_loss(coords_pred, targets[0])\\n loss = coord_loss\\n\\n # Chamfer Loss\\n # with torch.no_grad():\\n # coord_loss = F.mse_loss(coords_pred, targets[0])\\n dist1, idx1, dist2, idx2, _ = chamfer_dist(preds[0], targets[1])\\n chamfer_loss = (dist1 + dist2).mean()\\n # loss = chamfer_lambda * chamfer_loss + coord_loss\\n # loss = chamfer_loss\\n\\n # Physical loss\\n p_loss = physical_loss(preds[6])\\n # loss += (physical_lambda * p_loss)\\n\\n return loss, coord_loss, chamfer_loss, p_loss\",\n \"def loss(params: hk.Params, batch, label) -> jnp.ndarray:\\r\\n logits = net.apply(params, batch)\\r\\n labels = jax.nn.one_hot(label, n_classes)\\r\\n\\r\\n # Cross Entropy Loss\\r\\n softmax_xent = -jnp.sum(labels * jax.nn.log_softmax(logits))\\r\\n softmax_xent /= labels.shape[0]\\r\\n return softmax_xent\",\n \"def softmax_loss(x, y):\\n # softmax\\n num = np.exp(x)\\n den = np.sum(num, axis=1)\\n softmax = num/den[:, None]\\n N = x.shape[0]\\n\\n # compute the los per class\\n loss = softmax[np.arange(N), y]\\n loss = -np.log(loss)\\n\\n # sum all the losses and divide by number of class\\n # Also add the regularization loss term\\n loss = np.sum(loss)/N \\n \\n dscores = softmax\\n dscores[np.arange(N), y] -= 1\\n dscores /= N\\n\\n return loss, dscores\",\n \"def compute_loss_and_gradients(self, X, y):\\n # TODO Compute loss and fill param gradients\\n # by running forward and backward passes through the model\",\n \"def softmax_loss_naive(W, X, y, reg):\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n\\n #############################################################################\\n # TODO: Compute the softmax loss and its gradient using explicit loops. #\\n # Store the loss in loss and the gradient in dW. If you are not careful #\\n # here, it is easy to run into numeric instability. Don't forget the #\\n # regularization! #\\n #############################################################################\\n (num_class, D), (D, num_train) = (W.shape, X.shape)\\n class_scores = np.dot(W, X)\\n \\n # Subtract maximum unnormalized score from each set of class scores\\n for i in range(num_train):\\n max_class_score = np.max(class_scores[:, i])\\n for j in range(num_class):\\n class_scores[j, i] -= max_class_score\\n \\n # Compute softmax and update gradient\\n for i in range(num_train):\\n normalization_term = sum(np.exp(class_score) for class_score in class_scores[:, i])\\n for j in range(num_class):\\n class_scores[j, i] = np.exp(class_scores[j, i]) / normalization_term\\n # Thanks again to MyHumbleSelf for making me examine this further and discover a bug in my derivation of the softmax gradient!\\n dW[j] += (class_scores[j, i] - (j==y[i])) * X[:, i]\\n \\n # Compute cross-entropy errors and total loss from that\\n losses = [np.log(class_scores[y[i], i]) for i in range(num_train)]\\n loss = -sum(losses) / num_train\\n\\n # Add regularization to loss and normalize dW\\n loss += 0.5 * reg * np.sum(W * W)\\n dW /= num_train\\n dW += reg * W\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n\\n return loss, dW\",\n \"def loss(self, X, y=None, reg=0.0):\\r\\n Ws = self.weights\\r\\n bs = self.biases\\r\\n N, D = X.shape # number of samples, number of features per sample\\r\\n\\r\\n # Compute the forward pass\\r\\n self.activations = []\\r\\n for i in xrange(len(Ws)): # for each set of weights\\r\\n W,b = Ws[i], bs[i]\\r\\n if i == 0:\\r\\n H = np.dot(X,W) + b\\r\\n else:\\r\\n H = np.dot(self.activations[-1],W) + b\\r\\n if i < len(Ws) - 1: # if we're computing hidden activations, apply nonlinear function\\r\\n H = (H > 0) * (H) + (H < 0) * (H/100.0)\\r\\n self.activations.append(H)\\r\\n scores = self.activations[-1]\\r\\n \\r\\n # If there's no labels provided, stop here\\r\\n if y is None:\\r\\n return scores\\r\\n\\r\\n # Compute the loss\\r\\n exped_scores = np.exp(scores)\\r\\n sums = np.sum(exped_scores,axis=1)\\r\\n # softmax classifier loss\\r\\n data_loss = (-1.0/N) * np.sum(np.log(exped_scores[range(N),y.astype(int)] / sums))\\r\\n\\r\\n # loss due to regularization\\r\\n reg_loss = 0\\r\\n for i in xrange(len(Ws)):\\r\\n reg_loss += np.sum(Ws[i]**2)\\r\\n reg_loss *= reg*(0.5)\\r\\n\\r\\n loss = data_loss + reg_loss\\r\\n \\r\\n # Compute gradients\\r\\n weights_grads = []\\r\\n biases_grads = []\\r\\n activation_grads = []\\r\\n for i in xrange(len(Ws)):\\r\\n weights_grads.append(np.copy(Ws[i]))\\r\\n biases_grads.append(np.copy(bs[i]))\\r\\n activation_grads.append(np.copy(self.activations[i]))\\r\\n\\r\\n DlossDscores = np.array(exped_scores / (N * np.matrix(sums).T))\\r\\n DlossDscores[range(N),y.astype(int)] -= (1.0/N)\\r\\n \\r\\n for i in xrange(len(Ws)-1,-1,-1):\\r\\n if i == 0:\\r\\n weights_grads[0] = np.dot(X.T, activation_grads[0]) + reg*Ws[0]\\r\\n biases_grads[0] = np.dot(np.ones((1,N)), activation_grads[0])[0]\\r\\n elif i == len(Ws)-1:\\r\\n H = self.activations[i-1]\\r\\n weights_grads[i] = np.dot(H.T, DlossDscores) + reg*Ws[i]\\r\\n biases_grads[i] = np.dot(np.ones((1,N)), DlossDscores)[0]\\r\\n dH = np.dot(DlossDscores, Ws[i].T)\\r\\n activation_grads[i-1] = dH\\r\\n else:\\r\\n H = self.activations[i-1]\\r\\n dH_out = activation_grads[i]\\r\\n weights_grads[i] = np.dot(H.T, dH_out) + reg*Ws[i]\\r\\n biases_grads[i] = np.dot(np.ones((1,N)), dH_out)[0]\\r\\n dH = np.dot(dH_out, Ws[i].T)\\r\\n dH = dH * (H > 0) + dH/100.0 * (H < 0)\\r\\n activation_grads[i-1] = dH\\r\\n \\r\\n grads = {}\\r\\n grads['weights'] = weights_grads\\r\\n grads['biases'] = biases_grads\\r\\n\\r\\n return loss, grads\",\n \"def loss(self, X, y=None):\\n W1, b1 = self.params['W1'], self.params['b1']\\n W2, b2 = self.params['W2'], self.params['b2']\\n W3, b3 = self.params['W3'], self.params['b3']\\n \\n # pass conv_param to the forward pass for the convolutional layer\\n filter_size = W1.shape[2]\\n conv_param = {'stride': 1, 'pad': (filter_size - 1) / 2}\\n\\n # pass pool_param to the forward pass for the max-pooling layer\\n pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\\n\\n scores = None\\n ############################################################################\\n # TODO: Implement the forward pass for the three-layer convolutional net, #\\n # computing the class scores for X and storing them in the scores #\\n # variable. #\\n ############################################################################\\n \\n N, C, H, W = X.shape;\\n\\n #print 'X shape = ' + str(X.shape);\\n\\n # Get conv layer output. Note that it is not 2-dimensional \\n # conv - relu - 2x2 maxpool\\n v1, cache1 = conv_relu_pool_forward(X, W1, b1, conv_param, pool_param);\\n\\n #print 'v1 shape = ' + str(v1.shape);\\n\\n # Reshape to 2D\\n v1shape = v1.shape; # Used to reshape back to original form in backward pass\\n v1 = np.reshape(v1,(N,-1));\\n #print 'v1 shape = ' + str(v1.shape);\\n\\n # Feed forward to hidden layer (affine-relu)\\n v2, cache2 = affine_relu_forward(v1, W2, b2);\\n #print 'v2 shape = ' + str(v2.shape);\\n\\n # Feed forward to final layer (affine only)\\n v3, cache3 = affine_forward(v2, W3, b3)\\n #print 'v3 shape = ' + str(v3.shape);\\n\\n # Compute scores\\n scores = v3;\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n if y is None:\\n return scores\\n \\n loss, grads = 0, {}\\n ############################################################################\\n # TODO: Implement the backward pass for the three-layer convolutional net, #\\n # storing the loss and gradients in the loss and grads variables. Compute #\\n # data loss using softmax, and make sure that grads[k] holds the gradients #\\n # for self.params[k]. Don't forget to add L2 regularization! #\\n ############################################################################\\n \\n # Calculate softmax loss from layer 2 output\\n # Loss gets regularized here\\n # Each separate gradient must be regularized later when calculated\\n loss, dv3 = softmax_loss(scores,y); # Softmax loss and gradient\\n #print 'dv3 shape = ' + str(dv3.shape);\\n reg = self.reg;\\n loss += 0.5 * reg * (np.sum(W1*W1) + np.sum(W2*W2) + np.sum(W3*W3)); # Regularize\\n\\n # Do backward pass through layer 2 affine\\n dv2, dw3, db3 = affine_backward(dv3, cache3);\\n dw3 += reg*W3; # Regularize\\n #print 'dv2 shape = ' + str(dv2.shape);\\n\\n\\n # Backward pass through hidden layer\\n dv1, dw2, db2 = affine_relu_backward(dv2, cache2);\\n dw2 += reg*W2; # Regularize\\n #print 'dv1 shape = ' + str(dv1.shape);\\n\\n # Reshape dv1 to be compatible with convolutional layer\\n dv1 = np.reshape(dv1,v1shape);\\n #print 'dv1 shape = ' + str(dv1.shape);\\n\\n # Do backward pass through convolutional layer\\n dx, dw1, db1 = conv_relu_pool_backward(dv1, cache1);\\n dw1 += reg*W1; # Regularize\\n\\n # Store all weight and bias gradients in grads\\n grads['W1'] = dw1; grads['b1'] = db1;\\n grads['W2'] = dw2; grads['b2'] = db2;\\n grads['W3'] = dw3; grads['b3'] = db3;\\n\\n\\n\\n\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n return loss, grads\",\n \"def loss(self, X, y=None):\\n X = X.astype(self.dtype)\\n mode = 'test' if y is None else 'train'\\n\\n scores = None\\n ############################################################################\\n # Implementing the forward pass for the fully-connected net, computing #\\n # the class scores for X and storing them in the scores variable. #\\n ############################################################################\\n\\n l_input = X.copy()\\n out = []\\n cache = []\\n for i in range(self.num_layers - 1):\\n # layerwise compute the forward pass and store outputs in out list\\n key = ['W' + str(i+1), 'b' + str(i+1)]\\n lout, lcache = affine_sigmoid_forward(l_input, self.params[key[0]], self.params[key[1]])\\n out.append(lout)\\n cache.append(lcache)\\n l_input = lout\\n\\n key = ['W' + str(self.num_layers), 'b' + str(self.num_layers)]\\n scores, lcache = affine_forward(out[self.num_layers - 2], self.params[key[0]], self.params[key[1]])\\n cache.append(lcache)\\n \\n # regularization parameter compute by summing square of all weight vectors\\n R = 0\\n for i in range(1, self.num_layers + 1):\\n key = 'W' + str(i)\\n R += np.sum(np.power(self.params[key], 2))\\n\\n # If test mode return early\\n if mode == 'test':\\n return scores\\n\\n loss, grads = 0.0, {}\\n\\n ########################\\n # Backward pass to compute the loss and gradients\\n ########################\\n\\n loss, dscore = softmax_loss(scores, y)\\n # Apply regularization of the loss \\n loss = loss + 0.5 * self.reg * R\\n\\n key = ['W' + str(self.num_layers), 'b' + str(self.num_layers)]\\n dx, grads[key[0]], grads[key[1]] = affine_backward(dscore, cache[self.num_layers - 1])\\n grads[key[0]] += self.reg * self.params[key[0]] \\n\\n for i in range(self.num_layers - 1, 0, -1):\\n key = ['W' + str(i), 'b' + str(i)]\\n dx, grads[key[0]], grads[key[1]] = affine_sigmoid_backward(dx, cache[i-1])\\n # Apply regularization to the gradients\\n grads[key[0]] += self.reg * self.params[key[0]]\\n\\n return loss, grads\",\n \"def loss(self, X, y=None):\\n X = X.astype(self.dtype)\\n mode = 'test' if y is None else 'train'\\n\\n # Set train/test mode for batchnorm params and dropout param since they\\n # behave differently during training and testing.\\n if self.dropout_param is not None:\\n self.dropout_param['mode'] = mode \\n if self.use_batchnorm:\\n for bn_param in self.bn_params:\\n bn_param[mode] = mode\\n\\n scores = None\\n \\n ### forward pass ###\\n L = self.num_layers\\n past_caches = [0 for i in range(L)]\\n \\n if self.use_dropout:\\n dropout_caches = [0 for i in range(L)]\\n \\n out = X\\n if self.use_batchnorm:\\n for i in range(L-1):\\n\\n out, past_caches[i] = affine_batch_relu_forward(out, self.params['W' + str(i+1)],\\n self.params['b' + str(i+1)], \\n self.params['gamma' + str(i+1)],\\n self.params['beta' + str(i+1)],\\n self.bn_params[i])\\n if self.use_dropout:\\n out, dropout_caches[i] = dropout_forward(out, self.dropout_param)\\n else:\\n for i in range(L-1):\\n\\n out, past_caches[i] = affine_relu_forward(out, self.params['W' + str(i+1)],\\n self.params['b' + str(i+1)])\\n if self.use_dropout:\\n out, dropout_caches[i] = dropout_forward(out, self.dropout_param)\\n \\n scores, past_caches[L-1] = affine_forward(out, self.params['W' + str(L)],\\n self.params['b' + str(L)])\\n \\n ### backpropagation ###\\n\\n # If test mode return early\\n if mode == 'test':\\n return scores\\n\\n loss, grads = 0.0, {}\\n \\n loss_l2 = 0\\n \\n loss, dx = softmax_loss(scores, y)\\n for i in range(L-1): \\n W = 'W' + str(i+1)\\n loss_l2 += np.sum(self.params[W]*self.params[W])\\n loss_l2 *= 0.5 * self.reg\\n loss += loss_l2\\n \\n W_final = 'W'+str(L)\\n b_final = 'b'+str(L)\\n dx, grads[W_final], grads[b_final] = affine_backward(dx, past_caches[L-1])\\n grads[W_final] += self.reg * self.params[W_final]\\n \\n if self.use_batchnorm:\\n for i in range(L-1):\\n ind = L-1-i\\n W = 'W'+str(ind)\\n b = 'b'+str(ind)\\n gamma = 'gamma' + str(ind)\\n beta = 'beta' + str(ind)\\n \\n if self.use_dropout:\\n dx = dropout_backward(dx, dropout_caches[-i-2])\\n\\n dx, grads[W], grads[b], grads[gamma], grads[beta] = affine_batch_relu_backward(dx, past_caches[-i-2])\\n grads[W] += self.reg * self.params[W]\\n\\n else:\\n for i in range(L-1):\\n ind = L-1-i\\n W = 'W'+str(ind)\\n b = 'b'+str(ind)\\n \\n if self.use_dropout:\\n dx = dropout_backward(dx, dropout_caches[-i-2])\\n\\n dx, grads[W], grads[b] = affine_relu_backward(dx, past_caches[-i-2])\\n grads[W] += self.reg * self.params[W]\\n\\n return loss, grads\",\n \"def softmax_loss1(x, y):\\n # tmp = np.max(x, axis=1, keepdims=True)\\n shifted_logits = x - np.max(x, axis=1, keepdims=True)\\n Z = np.sum(np.exp(shifted_logits), axis=1, keepdims=True)\\n log_probs = shifted_logits - np.log(Z)\\n probs = np.exp(log_probs)\\n N = x.shape[0]\\n # tmp2 = np.arange(N)\\n tmp3 = log_probs[np.arange(N), y]\\n # tmp4 = log_probs[[0,1,2],[2,5,0]]\\n loss = -np.sum(log_probs[np.arange(N), y]) / N\\n dx = probs.copy()\\n dx[np.arange(N), y] -= 1\\n dx /= N\\n return loss, dx\",\n \"def loss(self, x, y):\\n (N,D) = x.shape\\n k1 = np.matmul(x,np.transpose(self.w)) + self.b\\n y1 = y.reshape((N,1))\\n c2 = 0\\n c1 = (np.log(1+np.exp(-1*y1*k1)))\\n for i in range(N):\\n c2 += c1[i][0]\\n l = c2 / N + (0.5 * self.l2_reg * np.dot(self.w,np.transpose(self.w)))\\n l1 = l[0][0]\\n return l1\\n\\n\\n #raise NotImplementedError\",\n \"def softmax_weighted_loss(pred, gr_truth):\\n gr_truth = tf.cast(gr_truth, dtype='int32')\\n gr_truth = one_hot(gr_truth)\\n softmax_pred = tf.nn.softmax(pred)\\n loss = 0\\n\\n for i in range(8):\\n gti = gr_truth[:, :, :, :, i]\\n predi = softmax_pred[:, :, :, :, i]\\n weighted = 1 - (tf.reduce_sum(gti) / tf.reduce_sum(gr_truth))\\n loss += -tf.reduce_mean(weighted * gti * tf.math.log(tf.clip_by_value(predi, 0.005, 1)))\\n\\n return loss\",\n \"def lossFun(review, target, hprev):\\n xs, hs, ys, ps = {}, {}, {}, {}\\n hs[-1] = np.copy(hprev)\\n loss = 0\\n\\n # forward pass\\n for t in range(len(review)):\\n xs[t] = np.zeros((vector_len,1)) # encode in 1-of-k representation\\n for j in range(32):\\n xs[t][j] = review[t][j]\\n hs[t] = np.tanh(np.dot(Wxh, xs[t]) + np.dot(Whh, hs[t-1]) + bh) # hidden state\\n\\n #Many 2 one\\n last = len(review) - 1\\n ys = np.dot(Why, hs[last]) + by # unnormalized log probabilities for next chars\\n ps = np.exp(ys) / np.sum(np.exp(ys)) # probabilities for next chars\\n loss = -np.log(ps[target,0]) # softmax (cross-entropy loss)\\n\\n # backward pass: compute gradients going backwards\\n dWxh, dWhh, dWhy = np.zeros_like(Wxh), np.zeros_like(Whh), np.zeros_like(Why)\\n dbh, dby = np.zeros_like(bh), np.zeros_like(by)\\n dhnext = np.zeros_like(hs[0])\\n\\n dy = np.subtract(ps,target) # backprop into y. see http://cs231n.github.io/neural-networks-case-study/#grad if confused here\\n dWhy += np.dot(dy, hs[last].T)\\n dby += dy\\n dh = np.dot(Why.T, dy) + dhnext # backprop into h\\n for t in reversed(range(len(review))):\\n dhraw = (1 - (hs[t] * hs[t].T)) * dh # backprop through tanh nonlinearity\\n dbh += dhraw\\n dWxh += np.dot(dhraw, xs[t].T)\\n dWhh += np.dot(dhraw, hs[t-1].T)\\n dhnext = np.dot(Whh.T, dhraw)\\n for dparam in [dWxh, dWhh, dWhy, dbh, dby]:\\n np.clip(dparam, -5, 5, out=dparam) # clip to mitigate exploding gradients\\n return loss, dWxh, dWhh, dWhy, dbh, dby, hs[last]\",\n \"def calc_loss(self, outputs, labels):\\n information_loss = self.bottleneck.buffer_capacity.mean() # Taking the mean is equivalent of scaling with 1/K\\n cross_entropy = F.cross_entropy(outputs, target=labels)\\n total = cross_entropy + self.beta * information_loss\\n self.ce_loss.append(cross_entropy.cpu().detach().numpy())\\n self.info_loss.append(information_loss.cpu().detach().numpy())\\n self.total_loss.append(total.cpu().detach().numpy())\\n return total\",\n \"def softmax_loss_naive(W, X, y, reg):\\r\\n # Initialize the loss and gradient to zero.\\r\\n loss = 0.0\\r\\n dW = np.zeros_like(W)\\r\\n num_train = X.shape[1] # d*n\\r\\n num_class = W.shape[0]\\r\\n\\r\\n #############################################################################\\r\\n # Compute the softmax loss and its gradient using explicit loops. #\\r\\n # Store the loss in loss and the gradient in dW. If you are not careful #\\r\\n # here, it is easy to run into numeric instability. Don't forget the #\\r\\n # regularization! #\\r\\n #############################################################################\\r\\n loss = 0.0\\r\\n for i in range(num_train):\\r\\n X_i = X[:,i] # D*1\\r\\n score_i = W.dot(X_i)\\r\\n score_i -= np.max(score_i) #C*1 but keepdims = false so it becomes 1*C\\r\\n exp_score_i = np.exp(score_i)\\r\\n probs_i = exp_score_i/np.sum(exp_score_i) #1*C\\r\\n correct_logprobs_i = -np.log(probs_i[y[i]])\\r\\n loss += correct_logprobs_i\\r\\n \\r\\n dscore_i = probs_i.reshape(num_class,-1)#c*1\\r\\n dscore_i[y[i]] -= 1 #C*1\\r\\n X_i = X_i.reshape(1,-1)# 1*D\\r\\n dW += dscore_i.dot(X_i)\\r\\n \\r\\n loss /= num_train\\r\\n loss += 0.5*reg*np.sum(W*W)\\r\\n\\r\\n dW /= num_train\\r\\n dW += reg*W\\r\\n \\r\\n return loss, dW\",\n \"def cross_entropoy_loss_naive(W, X, y, reg):\\n # pylint: disable=too-many-locals\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n \\n\\n C = W.shape[1]\\n# print(\\\"no. of classes {}\\\".format(C))\\n N,D = X.shape\\n# print(\\\"no. of data {} and dimension {}\\\".format(N,D))\\n for i in range(N):\\n xi = X[i,:]\\n# print(\\\"one record shape: {}\\\".format(xi.shape))\\n scores = np.zeros(C)\\n for c in range(C):\\n w = W[:,c]\\n# print(\\\"weight for one record {}\\\".format(w.shape))\\n scores[c] = xi.dot(w)\\n scores -= np.max(scores)\\n actual_y = y[i]\\n total_score = np.sum(np.exp(scores)) \\n loss_i = -scores[actual_y] + np.log(total_score)\\n# print('naive score : {}'.format(scores[actual_y]))\\n loss += loss_i\\n \\n #gradient\\n probability = np.exp(scores)/total_score\\n for j in range(C):\\n dW[:,j] += probability[j]*xi\\n \\n dW[:,actual_y] -= xi\\n loss = loss/N\\n reg_loss = 0.5*reg*np.sum(W*W)\\n loss = loss + reg_loss\\n print(\\\"loss : {}\\\".format(loss))\\n dW = dW/N\\n dW += reg*W\\n \\n \\n \\n \\n\\n ############################################################################\\n # TODO: Compute the cross-entropy loss and its gradient using explicit #\\n # loops. Store the loss in loss and the gradient in dW. If you are not #\\n # careful here, it is easy to run into numeric instability. Don't forget #\\n # the regularization! #\\n ############################################################################\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n return loss, dW\",\n \"def softmax_loss_vectorized(W, X, y, reg):\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n\\n #############################################################################\\n # TODO: Compute the softmax loss and its gradient using no explicit loops. #\\n # Store the loss in loss and the gradient in dW. If you are not careful #\\n # here, it is easy to run into numeric instability. Don't forget the #\\n # regularization! #\\n #############################################################################\\n # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\\n\\n num_train = X.shape[0]\\n # print(\\\"num_train:\\\", num_train)\\n num_classes = W.shape[1]\\n # print(\\\"num_classes:\\\", num_classes)\\n \\n scores = X.dot(W) # scores is N*D x D*C -> N*C \\n log_c = np.max(scores, axis=1).T\\n scores -= log_c[:,None]\\n correct_class_score = scores[np.arange(num_train),y]\\n exp_scores = np.exp(scores)\\n sum_exp_scores = np.sum(np.exp(scores), axis=1)\\n proportion = np.exp(correct_class_score) / sum_exp_scores\\n loss -= np.sum(np.log(proportion))\\n \\n # calculating dW = (p - (c = correct c ? 1 : 0)) * x\\n correct_class_one_hot = np.zeros_like(scores)\\n correct_class_one_hot[np.arange(num_train),y] += 1\\n p = np.exp(scores) / sum_exp_scores[:,None] - correct_class_one_hot # N*C / N:1 -> N*C\\n dW += X.T.dot(p) # D*N x N*C -> D*C\\n\\n loss /= num_train\\n loss += 0.5 * reg * np.sum(W * W) \\n dW /= num_train\\n dW += reg * W\\n\\n # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\\n\\n return loss, dW\",\n \"def Weighted_Cross_Entropy(y_true, y_pred, eps = 1e-10):\\n y_pred = tf.cast(y_pred, 'float64')\\n y_true = tf.cast(y_true, 'float64')\\n # deduce weights based on true pixel value\\n class_weights = weights * y_true\\n # compute your (unweighted) softmax cross entropy loss\\n unweighted_losses = y_true*tf.math.log(y_pred + eps)\\n ##print(unweighted_losses.dtype, weights.dtype)\\n weighted_losses = unweighted_losses * class_weights\\n # reduce the result to get your final loss\\n loss = -tf.reduce_sum(weighted_losses)\\n return loss\",\n \"def add_loss_op(self, preds):\\n ### YOUR CODE HERE (~2-4 lines)\\n trans = tf.get_variable('trans',\\n shape=[Config.n_classes, Config.n_classes],\\n initializer=tf.contrib.layers.xavier_initializer())\\n log_likelihood, _ = crf_log_likelihood(preds,\\n self.labels_placeholder,\\n self.length_placeholder,\\n trans)\\n #log_likelihood = tf.boolean_mask(log_likelihood, self.mask_placeholder)\\n loss = tf.reduce_mean(-1.0 * log_likelihood)\\n \\n ### END YOUR CODE\\n return trans, loss\",\n \"def softmax_loss_naive(W, X, y, reg):\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n num_train = X.shape[0]\\n\\n #############################################################################\\n # TODO: Compute the softmax loss and its gradient using explicit loops. #\\n # Store the loss in loss and the gradient in dW. If you are not careful #\\n # here, it is easy to run into numeric instability. Don't forget the #\\n # regularization! #\\n #############################################################################\\n scores = X.dot(W)\\n scores_exp = np.exp(scores-np.max(scores, axis=1, keepdims=True))\\n\\n sum = np.sum(scores_exp, axis=1, keepdims=True)\\n probability = scores_exp/sum\\n #list containing the correct classification\\n indices = [range(num_train), y]\\n correct_class_score = probability[indices]\\n\\n #calculate -log(prob_y) and take the sum across all training examples\\n loss = np.sum(-np.log(correct_class_score))\\n loss /= num_train\\n loss += 0.5 * reg * np.sum(W * W)\\n\\n #Compute Gradient\\n probability[indices] -=1\\n dW = X.T.dot(probability)\\n dW /= num_train\\n dW += .5 * reg * W\\n\\n\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n\\n return loss, dW\",\n \"def softmax_loss_naive(W, X, y, reg):\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n\\n #############################################################################\\n # TODO: Compute the softmax loss and its gradient using explicit loops. #\\n # Store the loss in loss and the gradient in dW. If you are not careful #\\n # here, it is easy to run into numeric instability. Don't forget the #\\n # regularization! #\\n #############################################################################\\n num_train = X.shape[0]\\n num_classes = W.shape[1]\\n for i in xrange(num_train):\\n scores = X[i, :].dot(W)\\n scores -= np.max(scores)\\n correct_scores = scores[y[i]]\\n score_sum = np.sum(np.exp(scores))\\n h = np.exp(correct_scores) / score_sum\\n loss += -np.log(h)\\n for j in xrange(num_classes):\\n if j == y[i]:\\n dW[:, y[i]] += (np.exp(scores[j]) / score_sum - 1) * X[i, :]\\n else:\\n dW[:, j] += (np.exp(scores[j]) / score_sum) * X[i, :]\\n \\n \\n loss /= num_train + ( reg * np.sum(W * W))\\n dW /= num_train\\n\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n\\n return loss, dW\",\n \"def loss(output, y):\\n #Computes softmax cross entropy between logits and labels.\\n xentropy = tf.nn.softmax_cross_entropy_with_logits(logits=output, labels=y)\\n loss = tf.reduce_mean(xentropy)\\n\\n return loss\",\n \"def backward(self):\\n self.loss_similarity = [LNCC(warped_img, self.batch_fixed, self.corr_kernel) for warped_img in self.warped_img_list]\\n self.loss_similarity_mean = torch.mean(torch.stack(self.loss_similarity))\\n self.loss_smooth = [GradNorm(disp_map) for disp_map in self.disp_list]\\n self.loss_smooth_mean = torch.mean(torch.stack(self.loss_smooth))\\n if len(self.strain_compensated_list) > 1:\\n self.loss_consistency_strain = [LNCC(self.strain_compensated_list[t-1][:,:,143:-143,:], self.strain_compensated_list[t][:,:,143:-143,:], self.corr_kernel) for t in range(1, len(self.strain_compensated_list))]\\n self.loss_consistency_strain_mean = torch.mean(torch.stack(self.loss_consistency_strain))\\n self.loss_total = 1 - self.loss_similarity_mean + self.loss_smooth_mean * self.alpha + (1 - self.loss_consistency_strain_mean) * self.beta\\n else:\\n self.loss_total = 1 - self.loss_similarity_mean + self.loss_smooth_mean * self.alpha\",\n \"def _compute_loss(self):\\n state, action, reward, next_state, done = self.replay_buffer.sample(self.batch_size)\\n\\n state = torch.FloatTensor(state)\\n next_state = torch.FloatTensor(next_state)\\n action = torch.LongTensor(action)\\n reward = torch.FloatTensor(reward)\\n done = torch.FloatTensor(done)\\n\\n q_values = self.dqn(state)\\n q_value = q_values.gather(1, action.unsqueeze(1)).squeeze(1)\\n\\n next_q_values = self.target_dqn(next_state)\\n next_q_value = next_q_values.max(1)[0]\\n target = reward + self.discount_factor * next_q_value * (1 - done)\\n\\n # loss = F.smooth_l1_loss(q_value, target.detach())\\n loss = F.mse_loss(q_value, target.detach())\\n\\n return loss\",\n \"def loss(params: hk.Params, batch, labels, xent_weight=self.weights, l1_coeff=self.l1_coef, l2_coeff=self.l2_coef) -> jnp.ndarray:\\n logits = net.apply(params, batch)\\n labels = jax.nn.one_hot(label, 2)\\n\\n # Note that in our problem, regularization should be after the AND-mask.\\n sum_in_layer = lambda p: jnp.sum(p)\\n sum_p_layers = [sum_in_layer(p) for p in jax.tree_leaves(params)]\\n l1_loss = sum(sum_p_layers)\\n l2_loss = 0.5 * sum(jnp.sum(jnp.square(p)) for p in jax.tree_leaves(params))\\n softmax_xent = -jnp.sum(labels * jax.nn.log_softmax(logits) * xent_weight)\\n softmax_xent /= labels.shape[0]\\n\\n return softmax_xent + l2_coeff * l2_loss + l1_coeff * l1_loss\",\n \"def softmax_loss_naive(W, X, y, reg):\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n\\n #############################################################################\\n # TODO: Compute the softmax loss and its gradient using explicit loops. #\\n # Store the loss in loss and the gradient in dW. If you are not careful #\\n # here, it is easy to run into numeric instability. Don't forget the #\\n # regularization! #\\n #############################################################################\\n num_classes = W.shape[1]\\n num_train = X.shape[0]\\n\\n for i in xrange(num_train):\\n scores = X[i].dot(W)\\n\\n # Normalization trick to resolve numerical instability\\n # when dealing with the large exponential terms.\\n scores -= np.max(scores)\\n\\n # Cache some terms that are used repeatedly.\\n exp_scores = np.exp(scores)\\n sum_exp_scores = np.sum(exp_scores)\\n correct_class_score = scores[y[i]]\\n \\n # Update the loss \\n loss -= correct_class_score\\n loss += np.log(sum_exp_scores)\\n\\n # Update the gradient\\n dW[:,y[i]] -= X[i,:].T\\n for j in xrange(num_classes):\\n dW[:,j] += ((X[i,:].T * exp_scores[j]) / sum_exp_scores)\\n\\n \\n # Right now the loss is a sum over all training examples, but we want it\\n # to be an average instead so we divide by num_train.\\n loss /= num_train\\n\\n dW /= num_train\\n\\n # Add regularization to the loss.\\n loss += 0.5 * reg * np.sum(W * W)\\n\\n dW += reg*W\\n \\n pass\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n\\n return loss, dW\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7552237","0.74971294","0.7361533","0.7297716","0.7081309","0.7060637","0.70372635","0.70132375","0.7011851","0.698142","0.69772744","0.6949587","0.69317883","0.6925177","0.69105256","0.6898687","0.6895407","0.68951285","0.6879018","0.682814","0.68271774","0.68171346","0.678197","0.6772994","0.677283","0.6769999","0.6758701","0.674012","0.6729392","0.6726501","0.67256474","0.6722454","0.6711791","0.66988856","0.66948336","0.66917944","0.6689964","0.66878927","0.6686313","0.66858184","0.66770375","0.6676498","0.66738045","0.6672796","0.6671613","0.66715395","0.6666551","0.6663173","0.666155","0.6657128","0.66540796","0.6645166","0.6623059","0.6622559","0.66216964","0.6602848","0.6597533","0.659613","0.6595406","0.6593584","0.65913385","0.65881467","0.6584044","0.65774447","0.6573238","0.65713376","0.6571029","0.65702116","0.65644085","0.6556959","0.6556959","0.6541268","0.6537505","0.65340954","0.653276","0.65323585","0.65270865","0.65262604","0.6513302","0.6496416","0.6491057","0.64785504","0.64769125","0.6463163","0.64554536","0.64445245","0.6438918","0.6432792","0.6431099","0.6421611","0.6411627","0.6408724","0.64080924","0.64042586","0.6396917","0.6387818","0.63876307","0.6381051","0.6380174","0.6373116"],"string":"[\n \"0.7552237\",\n \"0.74971294\",\n \"0.7361533\",\n \"0.7297716\",\n \"0.7081309\",\n \"0.7060637\",\n \"0.70372635\",\n \"0.70132375\",\n \"0.7011851\",\n \"0.698142\",\n \"0.69772744\",\n \"0.6949587\",\n \"0.69317883\",\n \"0.6925177\",\n \"0.69105256\",\n \"0.6898687\",\n \"0.6895407\",\n \"0.68951285\",\n \"0.6879018\",\n \"0.682814\",\n \"0.68271774\",\n \"0.68171346\",\n \"0.678197\",\n \"0.6772994\",\n \"0.677283\",\n \"0.6769999\",\n \"0.6758701\",\n \"0.674012\",\n \"0.6729392\",\n \"0.6726501\",\n \"0.67256474\",\n \"0.6722454\",\n \"0.6711791\",\n \"0.66988856\",\n \"0.66948336\",\n \"0.66917944\",\n \"0.6689964\",\n \"0.66878927\",\n \"0.6686313\",\n \"0.66858184\",\n \"0.66770375\",\n \"0.6676498\",\n \"0.66738045\",\n \"0.6672796\",\n \"0.6671613\",\n \"0.66715395\",\n \"0.6666551\",\n \"0.6663173\",\n \"0.666155\",\n \"0.6657128\",\n \"0.66540796\",\n \"0.6645166\",\n \"0.6623059\",\n \"0.6622559\",\n \"0.66216964\",\n \"0.6602848\",\n \"0.6597533\",\n \"0.659613\",\n \"0.6595406\",\n \"0.6593584\",\n \"0.65913385\",\n \"0.65881467\",\n \"0.6584044\",\n \"0.65774447\",\n \"0.6573238\",\n \"0.65713376\",\n \"0.6571029\",\n \"0.65702116\",\n \"0.65644085\",\n \"0.6556959\",\n \"0.6556959\",\n \"0.6541268\",\n \"0.6537505\",\n \"0.65340954\",\n \"0.653276\",\n \"0.65323585\",\n \"0.65270865\",\n \"0.65262604\",\n \"0.6513302\",\n \"0.6496416\",\n \"0.6491057\",\n \"0.64785504\",\n \"0.64769125\",\n \"0.6463163\",\n \"0.64554536\",\n \"0.64445245\",\n \"0.6438918\",\n \"0.6432792\",\n \"0.6431099\",\n \"0.6421611\",\n \"0.6411627\",\n \"0.6408724\",\n \"0.64080924\",\n \"0.64042586\",\n \"0.6396917\",\n \"0.6387818\",\n \"0.63876307\",\n \"0.6381051\",\n \"0.6380174\",\n \"0.6373116\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7278144"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":12189,"cells":{"query":{"kind":"string","value":"This functions performs the forward pass which computes for the class scores given the input."},"document":{"kind":"string","value":"def network_forward(self, X):\n \n #############################################################################\n # TODO: Perform a forward pass on the network and store the caches of #\n # each layer inside the cache_list #\n #############################################################################\n ActivationFunction = None\n if self.hidden_activation_fn == \"sigmoid\":\n ActivationFunction = lambda x: self.sigmoid_forward(x)\n elif self.hidden_activation_fn == \"tanh\":\n ActivationFunction = lambda x: self.tanh_forward(x)\n elif self.hidden_activation_fn == \"relu\":\n ActivationFunction = lambda x: self.relu_forward(x)\n\n Layer1Value, cacheL1 = self.fully_connected_forward(X, self.params[\"W1\"], self.params[\"b1\"])\n Layer1ValueActivation, cacheL1A = ActivationFunction(Layer1Value)\n scores, cacheL2 = self.fully_connected_forward(Layer1ValueActivation, self.params[\"W2\"], self.params[\"b2\"])\n\n # Cache\n cache_list =[cacheL1, cacheL1A, cacheL2]\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n return scores, cache_list"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _forward(self, x):\n # Computing: `x * w^T`\n score = CArray(x.dot(self.w.T)).todense().ravel() + self.b\n\n scores = CArray.ones(shape=(x.shape[0], self.n_classes))\n scores[:, 0] = -score.ravel().T\n scores[:, 1] = score.ravel().T\n\n return scores","def _forward(self, *args, calc_score=False):\n with chainer.using_config('train', False), chainer.no_backprop_mode():\n if calc_score:\n self(*args)\n return self.y\n else:\n if self.predictor is None:\n print(\"[ERROR] predictor is not set or not build yet.\")\n return\n # TODO: it passes all the args, sometimes (x, y) which is too many arguments.\n # Consider how to deal with the number of input\n if hasattr(self.predictor, '_forward'):\n fn = self.predictor._forward\n else:\n fn = self.predictor\n return fn(*filter_args(fn, args))","def compute(self) -> None:\n \n self.model.eval()\n \n with torch.no_grad():\n for (input, target, _) in self.loader:\n\n # self.model = self.model.train(False) # TEST @lacoupe\n output, _ = self.model(input)\n \n output = (output >= 0.5)\n \n for out, tar in zip(output, target):\n \n tar = bool(tar)\n \n if out and tar:\n self.confusion['true_positive'] += 1\n elif not out and not tar:\n self.confusion['true_negative'] += 1\n elif out and not tar:\n self.confusion['false_positive'] += 1\n elif not out and tar:\n self.confusion['false_negative'] += 1\n \n self.accuracy = (self.confusion['true_positive'] + self.confusion['true_negative']) \\\n / sum(list(self.confusion.values()))\n \n if (self.confusion['true_positive'] + self.confusion['false_positive']) == 0.:\n self.precision = 0.\n else:\n self.precision = self.confusion['true_positive'] \\\n / (self.confusion['true_positive'] + self.confusion['false_positive'])\n \n if (self.confusion['true_positive'] + self.confusion['false_negative']) == 0.:\n self.recall = 0.\n else:\n self.recall = self.confusion['true_positive'] \\\n / (self.confusion['true_positive'] + self.confusion['false_negative'])\n \n if (self.precision + self.recall) == 0.:\n self.f1_score = 0.\n else:\n self.f1_score = 2 * self.precision * self.recall / (self.precision + self.recall)","def forward(self, x):\n # Introspect number of classes from anchors and input shape.\n num_anchors = len(self.anchors)\n batch_size, num_predictions, h, w = x.shape\n num_classes = int(num_predictions / num_anchors) - 5\n x = x.reshape((batch_size, num_anchors, num_classes + 5, h, w))\n\n # Indices 0-3 correspond to xywh energies, index 4 corresponds to\n # objectness energy, and 5: correspond to class energies.\n xywh_energy = x[:, :, 0:4, :, :]\n obj_energy = x[:, :, 4:5, :, :]\n class_energy = x[:, :, 5:, :, :]\n\n bbox_xywh = xywh_energy.clone().detach()\n\n # Cell offsets C_x and C_y from original paper.\n cx = torch.linspace(0, w - 1, w, device=self.device).repeat(h, 1)\n cy = torch.linspace(\n 0, h - 1, h, device=self.device\n ).repeat(w, 1).t().contiguous()\n\n # Get bbox center x and y coordinates.\n bbox_xywh[:, :, 0, :, :].sigmoid_().add_(cx).div_(w)\n bbox_xywh[:, :, 1, :, :].sigmoid_().add_(cy).div_(h)\n\n # Anchor priors (P_w and P_h in original paper).\n anchors = self.anchors\n\n anchor_w = torch.tensor(\n anchors, device=self.device\n )[:, 0].reshape(1, num_anchors, 1, 1)\n\n anchor_h = torch.tensor(\n anchors, device=self.device\n )[:, 1].reshape(1, num_anchors, 1, 1)\n\n # Get bbox width and height.\n bbox_xywh[:, :, 2, :, :].exp_().mul_(anchor_w)\n bbox_xywh[:, :, 3, :, :].exp_().mul_(anchor_h)\n\n # Get objectness and class scores.\n obj_score = obj_energy.clone().detach().sigmoid()\n class_score = F.softmax(class_energy.clone().detach(), dim=2)\n\n class_prob, class_idx = torch.max(class_score, 2, keepdim=True)\n class_prob.mul_(obj_score)\n\n # Flatten resulting tensors along anchor box and grid cell dimensions;\n # this makes it easier to combine predictions across scales from other\n # YOLO layers in Darknet.forward().\n # `bbox_xywh` -> (batch_size x num_predictions x 4) tensor, where last\n # dim corresponds to xywh coordinates of prediction.\n # `class_prob`, `class_idx` -> (batch_size x num_predictions)\n # tensors, where dim 1 corresponds to the probability and index,\n # respectively, of the class with the greatest probability.\n bbox_xywh = bbox_xywh.permute(0, 1, 3, 4, 2).reshape(batch_size, -1, 4)\n class_prob = class_prob.reshape(batch_size, -1)\n class_idx = class_idx.reshape(batch_size, -1)\n\n return bbox_xywh, class_prob, class_idx","def forward_train(self, cls_score, gt_label):\n if self._do_squeeze:\n cls_score = cls_score.unsqueeze(0).squeeze()\n return super().forward_train(cls_score, gt_label)","def forward(self, inp):\n out = self.features(inp)\n out = out.view(out.size(0), -1) # linearized the output of the module 'features'\n out = self.classifier(out)\n return out","def forward(self, inputs):\n raise NotImplementedError","def loss(self, X, y=None):\n W1 = self.params['W1']\n mode = 'test' if y is None else 'train'\n\n # pass conv_param to the forward pass for the convolutional layer\n filter_size = W1.shape[2]\n conv_param = {'stride': 1, 'pad': (filter_size - 1) / 2}\n\n # pass pool_param to the forward pass for the max-pooling layer\n pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\n\n cache = {}\n\n if self.use_batchnorm:\n for bn_param in self.bn_params:\n bn_param[mode] = mode\n\n scores = None\n ############################################################################\n # TODO: Implement the forward pass for the three-layer convolutional net, #\n # computing the class scores for X and storing them in the scores #\n # variable. #\n ############################################################################\n input = X\n for l in xrange(1, self.conv_layers + 1):\n if self.use_batchnorm:\n W, b, gamma, beta = self.get_params_for_layer(l, get_gamma_beta=True)\n input, cache['cache%d' % l] = conv_norm_relu_pool_forward(input, W, b, conv_param, pool_param, gamma, beta, self.bn_params[l])\n else:\n W, b = self.get_params_for_layer(l)\n input, cache['cache%d' % l] = conv_relu_pool_forward(input, W, b, conv_param, pool_param)\n\n l = self.conv_layers + 1\n if self.use_batchnorm:\n W, b, gamma, beta = self.get_params_for_layer(l, get_gamma_beta=True)\n h_out, h_cache = affine_norm_relu_forward(input, W, b, gamma, beta, self.bn_params[l])\n else:\n W, b = self.get_params_for_layer(l)\n h_out, h_cache = affine_relu_forward(input, W, b)\n\n l = l + 1\n W, b = self.get_params_for_layer(l)\n scores, scores_cache = affine_forward(h_out, W, b)\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n if y is None:\n return scores\n\n loss, grads = 0, {}\n ############################################################################\n # TODO: Implement the backward pass for the three-layer convolutional net, #\n # storing the loss and gradients in the loss and grads variables. Compute #\n # data loss using softmax, and make sure that grads[k] holds the gradients #\n # for self.params[k]. Don't forget to add L2 regularization! #\n ############################################################################\n loss, loss_dx = softmax_loss(scores, y)\n\n for l in xrange(1, self.num_layers + 1):\n loss += 0.5 * self.reg * np.sum(self.params['W%d' % l] * self.params['W%d' % l])\n\n l = self.num_layers\n scores_dx, scores_dw, scores_db = affine_backward(loss_dx, scores_cache)\n self.set_grads(l, grads, scores_dw, scores_db)\n l = l - 1\n\n if self.use_batchnorm:\n a_dx, a_dw, a_db, a_dgamma, a_dbeta = affine_norm_relu_backward(scores_dx, h_cache)\n self.set_grads(l, grads, a_dw, a_db, a_dgamma, a_dbeta)\n else:\n a_dx, a_dw, a_db = affine_relu_backward(scores_dx, h_cache)\n self.set_grads(l, grads, a_dw, a_db)\n l = l - 1\n\n conv_layers = l\n next_input = a_dx\n for l in xrange(conv_layers, 0, -1):\n current_cache = cache['cache%d' % l]\n if self.use_batchnorm:\n c_dx, c_dw, c_db, c_dgamma, c_dbeta = conv_norm_relu_pool_backward(next_input, current_cache)\n self.set_grads(l, grads, c_dw, c_db, c_dgamma, c_dbeta)\n else:\n c_dx, c_dw, c_db = conv_relu_pool_backward(next_input, current_cache)\n self.set_grads(l, grads, c_dw, c_db)\n next_input = c_dx\n\n for l in xrange(1, self.conv_layers + 3):\n grads['W%d' % l] += self.reg * self.params['W%d' % l]\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n return loss, grads","def forward(self, *input):\n \n item_text, item_img, uidx = input\n # compute latent codes\n user_codes = self.user_embdding(uidx)\n item_img_codes = self.ilatent_img_codes(item_img)\n item_text_codes = self.ilatent_text_codes(item_text)\n #ubianry = self.hash(user_codes)\n #ibinary = [self.hash(h) for h in item_codes]\n uscore_img = self.uscores(user_codes, item_img_codes)\n iscore_img = self.iscores(item_img_codes)\n uscore_text = self.uscores(user_codes, item_text_codes)\n iscore_text = self.iscores(item_text_codes)\n score = uscore_img + uscore_text + iscore_img + iscore_text\n\n binary = torch.zeros_like(score)#self.scores(ubianry, ibinary).view(-1, 1)\n return score, binary","def forward(self, inp, return_all_scores=False):\n gate = self.gate(inp)\n gate_top_k_val, gate_top_k_idx = torch.topk(\n gate, k=self.top_k, dim=-1, largest=True, sorted=False\n ) # [.. x top_k]\n gate_top_k_val = gate_top_k_val.view(-1, self.top_k)\n\n # (BxL) x 1 x top_k\n gate_score = F.softmax(gate_top_k_val, dim=-1)\n\n if return_all_scores:\n return gate_top_k_idx, gate_top_k_val, gate\n return gate_top_k_idx, gate_top_k_val","def loss(self, X, y=None):\n W1, b1 = self.params['W1'], self.params['b1']\n W2, b2 = self.params['W2'], self.params['b2']\n W3, b3 = self.params['W3'], self.params['b3']\n \n # pass conv_param to the forward pass for the convolutional layer\n filter_size = W1.shape[2]\n conv_param = {'stride': 1, 'pad': (filter_size - 1) / 2}\n\n # pass pool_param to the forward pass for the max-pooling layer\n pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\n\n scores = None\n ############################################################################\n # TODO: Implement the forward pass for the three-layer convolutional net, #\n # computing the class scores for X and storing them in the scores #\n # variable. #\n ############################################################################\n \n N, C, H, W = X.shape;\n\n #print 'X shape = ' + str(X.shape);\n\n # Get conv layer output. Note that it is not 2-dimensional \n # conv - relu - 2x2 maxpool\n v1, cache1 = conv_relu_pool_forward(X, W1, b1, conv_param, pool_param);\n\n #print 'v1 shape = ' + str(v1.shape);\n\n # Reshape to 2D\n v1shape = v1.shape; # Used to reshape back to original form in backward pass\n v1 = np.reshape(v1,(N,-1));\n #print 'v1 shape = ' + str(v1.shape);\n\n # Feed forward to hidden layer (affine-relu)\n v2, cache2 = affine_relu_forward(v1, W2, b2);\n #print 'v2 shape = ' + str(v2.shape);\n\n # Feed forward to final layer (affine only)\n v3, cache3 = affine_forward(v2, W3, b3)\n #print 'v3 shape = ' + str(v3.shape);\n\n # Compute scores\n scores = v3;\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n \n if y is None:\n return scores\n \n loss, grads = 0, {}\n ############################################################################\n # TODO: Implement the backward pass for the three-layer convolutional net, #\n # storing the loss and gradients in the loss and grads variables. Compute #\n # data loss using softmax, and make sure that grads[k] holds the gradients #\n # for self.params[k]. Don't forget to add L2 regularization! #\n ############################################################################\n \n # Calculate softmax loss from layer 2 output\n # Loss gets regularized here\n # Each separate gradient must be regularized later when calculated\n loss, dv3 = softmax_loss(scores,y); # Softmax loss and gradient\n #print 'dv3 shape = ' + str(dv3.shape);\n reg = self.reg;\n loss += 0.5 * reg * (np.sum(W1*W1) + np.sum(W2*W2) + np.sum(W3*W3)); # Regularize\n\n # Do backward pass through layer 2 affine\n dv2, dw3, db3 = affine_backward(dv3, cache3);\n dw3 += reg*W3; # Regularize\n #print 'dv2 shape = ' + str(dv2.shape);\n\n\n # Backward pass through hidden layer\n dv1, dw2, db2 = affine_relu_backward(dv2, cache2);\n dw2 += reg*W2; # Regularize\n #print 'dv1 shape = ' + str(dv1.shape);\n\n # Reshape dv1 to be compatible with convolutional layer\n dv1 = np.reshape(dv1,v1shape);\n #print 'dv1 shape = ' + str(dv1.shape);\n\n # Do backward pass through convolutional layer\n dx, dw1, db1 = conv_relu_pool_backward(dv1, cache1);\n dw1 += reg*W1; # Regularize\n\n # Store all weight and bias gradients in grads\n grads['W1'] = dw1; grads['b1'] = db1;\n grads['W2'] = dw2; grads['b2'] = db2;\n grads['W3'] = dw3; grads['b3'] = db3;\n\n\n\n\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n \n return loss, grads","def forward(self, x):\n batch_size = x.shape[0]\n expected_shape = (batch_size, self.num_classes)\n\n out = self.feature_extractor(x)\n out = torch.flatten(out, 1)\n out = self.classifier(out)\n\n assert out.shape == (batch_size, self.num_classes),\\\n f\"Expected output of forward pass to be: {expected_shape}, but got: {out.shape}\"\n return out","def forward(self, x):\n batch_size = x.shape[0]\n expected_shape = (batch_size, self.num_classes)\n\n out = self.feature_extractor(x)\n out = torch.flatten(out, 1)\n out = self.classifier(out)\n\n assert out.shape == (batch_size, self.num_classes),\\\n f\"Expected output of forward pass to be: {expected_shape}, but got: {out.shape}\"\n return out","def forward(self, x):\n out = self.conv(x)\n out = out.view(out.size(0), -1)\n\n # critic\n out1 = self.fc1(out)\n\n # auxiliary classifier\n out2 = self.fc10(out)\n\n return out1, out2","def forward(self, pred, gt, weight=None):\n num_pos = torch.relu(torch.sum(gt) - 1) + 1\n num_neg = torch.relu(torch.sum(1 - gt) - 1) + 1\n if weight is not None:\n loss = nn.BCEWithLogitsLoss(reduction='none')(pred, gt.float())\n loss = torch.mean(loss * weight)\n elif self.balanced is False:\n loss = nn.BCEWithLogitsLoss(reduction='mean')(pred, gt.float())\n else:\n loss = nn.BCEWithLogitsLoss(pos_weight=num_neg * 1.0 / num_pos, reduction='mean')(pred, gt.float())\n\n # compute precision, recall, f1\n pred_labels = pred > 0\n gt, pred_labels, pred = gt.detach().cpu().numpy(), pred_labels.detach().cpu().numpy(), pred.detach().cpu().numpy()\n precision = precision_score(gt[0], pred_labels[0])\n recall = recall_score(gt[0], pred_labels[0])\n f1 = f1_score(gt[0], pred_labels[0])\n mean_logit_true = np.sum(pred * gt) / max(1, np.sum(gt))\n mean_logit_false = np.sum(pred * (1 - gt)) / max(1, np.sum(1 - gt))\n\n eval_stats = {\n \"loss\": loss,\n \"precision\": float(precision),\n \"recall\": float(recall),\n \"f1\": float(f1),\n \"logit_true\": float(mean_logit_true),\n \"logit_false\": float(mean_logit_false)\n }\n return eval_stats","def _forward(self, subj_embs, obj_embs, subj_feats, pred_feats, obj_feats):\n visual = torch.cat((\n self.fc_subject(subj_feats),\n self.fc_predicate(pred_feats),\n self.fc_object(obj_feats)\n ), dim=1)\n features = self.fc_projector(visual)\n classifiers = self.get_classifiers(subj_embs, obj_embs)\n scores = F.cosine_similarity(classifiers, features.unsqueeze(1), dim=2)\n scores_bin = self.fc_classifier_bin(visual)\n if self.mode == 'test':\n scores = self.softmax(5 * scores)\n scores_bin = self.softmax(scores_bin)\n return scores, scores_bin, classifiers","def score(self, data):\n\n score_mappings = {\n \"0\": np.log(self.class_zero_doc_count / self.total_docs),\n \"1\": np.log(self.class_one_doc_count / self.total_docs)\n }\n\n features = self.featurize(data)\n\n for f in features:\n\n if(f[0] in self.class_zero):\n cond_prob_zero = np.log((self.class_zero[f[0]] + 1) / (self.class_zero_feature_count + len(self.vocab)))\n elif(f[0] in self.vocab):\n cond_prob_zero = np.log(1 / (self.class_zero_feature_count + len(self.vocab)))\n else:\n cond_prob_zero = 0\n\n if(f[0] in self.class_one):\n cond_prob_one = np.log((self.class_one[f[0]] + 1) / (self.class_one_feature_count + len(self.vocab)))\n elif(f[0] in self.vocab):\n cond_prob_one = np.log(1 / (self.class_one_feature_count + len(self.vocab)))\n else:\n cond_prob_one = 0\n\n score_mappings[\"0\"] += cond_prob_zero\n score_mappings[\"1\"] += cond_prob_one\n\n score_mappings[\"0\"] = np.exp(score_mappings[\"0\"])\n score_mappings[\"1\"] = np.exp(score_mappings[\"1\"])\n\n return score_mappings","def forward(self, inputs):\r\n #print (len(inputs))\r\n out = self.fc1(inputs)\r\n out = self.fc2(out)\r\n self.out = out\r\n return out\r\n #raise NotImplementedError('Implement the forward method of the model')\r","def forward(self, x):\n out = self.features(x)\n out = self.avgpool(out)\n out = torch.flatten(out, 1)\n out = self.classifier(out)\n return out","def forward(self, x):\n out = self.features(x)\n out = self.avgpool(out)\n out = torch.flatten(out, 1)\n out = self.classifier(out)\n return out","def forward(ctx, scores):\n size = scores.size()\n prob = F.softmax(scores, dim=-1)\n idx = multinomial(prob.view(-1, size[-1]), num_samples=1, replacement=False).view(size[:-1])\n scores_net = eye(scores.size(-1), device=scores.device)\n return scores_net[idx]","def get_scores(self):\n hist = self.confusion_matrix\n # hist = [TN,FP;FN,TP]\n acc = np.diag(hist).sum() / hist.sum()\n acc_cls = np.diag(hist) / hist.sum(axis=1)\n acc_cls = np.nanmean(acc_cls)\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\n # iou = iu.sum() / self.n_classes\n mean_iou = np.nanmean(iu) # if classes = 2: iou = miou\n freq = hist.sum(axis=1) / hist.sum()\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\n cls_iou = dict(zip(range(self.n_classes), iu))\n\n ##############################################\n tn = hist[0, 0]\n tp = np.diag(hist).sum() - tn\n fp = np.triu(hist, 1).sum()\n fn = np.tril(hist, -1).sum()\n precision = tp / (tp + fp)\n recall = tp / (tp + fn)\n f1 = 2 * precision * recall / (precision + recall)\n\n # for medical img, img_seg \\in [0,1]\n dice = 2 * tp / (tp + tp + fn + fp)\n # dice = f1-score\n dsc = 2 * tp / (tp + fn + fp)\n # dsc = jaccard\n # voe = 2 * abs(fp + fn) / (tp + tp + fn + fp)\n # voe = 1 - dsc\n\n k2 = {\n # \"Overall Acc: \\t\": acc,\n 'Mean Acc': float(judge_nan(acc_cls)),\n # \"FreqW Acc : \\t\": fwavacc,\n 'Mean IoU': float(judge_nan(mean_iou)),\n 'F1-score': float(judge_nan(f1)),\n 'DSC': float(judge_nan(dsc)),\n 'Precision': float(judge_nan(precision)),\n 'Recall': float(judge_nan(recall)),\n }\n\n return k2","def forward(self, X, training=False):\n pass","def accuracy(self, data, class_loss_scores=False):\n predicts = [self.feedforward(xy[0].T) for xy in data]\n refs = [xy[1].T for xy in data]\n if class_loss_scores:\n # TODO NOTE that class loss function indicate an error not positive label,\n # loss function inverse scores\n predicts = [1.0 - self.cost.class_loss_scores(s) for s in predicts]\n # threshold network score\n pred_labs = [cf.step(x, self.threshold) for x in predicts]\n return metrics.micro_f1(refs, pred_labs, False)","def forward(self, input):\n raise NotImplementedError","def forward(self, input):\n raise NotImplementedError","def forward_train(self, *args, **kwargs):\n pass","def forward(self, inputs):\n _, state = self.core(inputs)\n return state","def forward(self, input):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n assert input.shape[1] == self.n_neurons, \"The shape of the input tensor is not correct.\"\n\n bn_fct = CustomBatchNormManualFunction()\n out = bn_fct.apply(input, self.gamma, self.beta, self.eps)\n ########################\n # END OF YOUR CODE #\n #######################\n\n return out","def forward(self, inp):\n if self.mode=='pre':\n return self.pretrain_forward(inp)\n elif self.mode=='meta':\n data_shot, label_shot, data_query, val = inp\n return self.meta_forward(data_shot, label_shot, data_query, val)\n elif self.mode=='preval':\n data_shot, label_shot, data_query = inp\n return self.preval_forward(data_shot, label_shot, data_query)\n else:\n raise ValueError('Please set the correct mode.')","def loss(self, X, y=None):\n W1, b1 = self.params['W1'], self.params['b1']\n W2, b2 = self.params['W2'], self.params['b2']\n W3, b3 = self.params['W3'], self.params['b3']\n \n # pass conv_param to the forward pass for the convolutional layer\n filter_size = W1.shape[2]\n conv_param = {'stride': 1, 'pad': (filter_size - 1) / 2}\n\n # pass pool_param to the forward pass for the max-pooling layer\n pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\n\n ############################################################################\n # TODO: Implement the forward pass for the three-layer convolutional net, #\n # computing the class scores for X and storing them in the scores #\n # variable. #\n ############################################################################\n \n scores = None \n cache = {}\n # def conv_relu_pool_forward(x, w, b, conv_param, pool_param): return out, cache;\n out, cache['layer1'] = layer_utils.conv_relu_pool_forward(X, W1, b1, conv_param, pool_param) \n # def affine_relu_forward(x, w, b): return out, cache;\n out, cache['layer2'] = layer_utils.affine_relu_forward(out, W2, b2)\n # def affine_forward(x, w, b): return out, cache;\n scores, cache['layer3'] = layers.affine_forward(out, W3, b3)\n\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n \n if y is None:\n return scores\n \n ############################################################################\n # TODO: Implement the backward pass for the three-layer convolutional net, #\n # storing the loss and gradients in the loss and grads variables. Compute #\n # data loss using softmax, and make sure that grads[k] holds the gradients #\n # for self.params[k]. Don't forget to add L2 regularization! #\n ############################################################################\n \n loss, grads = 0, {}\n\n # def softmax_loss(x, y): return loss, dscore;\n loss, dscores = layers.softmax_loss(scores, y)\n loss += 0.5 * self.reg * (np.sum(W1 * W1) + np.sum(W2 * W2) + np.sum(W3 * W3))\n\n # def affine_backward(dout, cache): return dx, dw, db;\n dout, dW3, db3 = layers.affine_backward(dscores, cache['layer3']) \n # def affine_relu_backward(dout, cache): return dx, dw, db;\n dout, dW2, db2 = layer_utils.affine_relu_backward(dout, cache['layer2'])\n # def conv_relu_pool_backward(dout, cache): return dx, dw, db;\n dout, dW1, db1 = layer_utils.conv_relu_pool_backward(dout, cache['layer1'])\n\n # reg\n grads['W3'], grads['b3'] = dW3 + self.reg * W3, db3\n grads['W2'], grads['b2'] = dW2 + self.reg * W2, db2\n grads['W1'], grads['b1'] = dW1 + self.reg * W1, db1\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n \n return loss, grads","def forwardPass(self, inputs):\n #############################################################################\n # TODO: Implement the forward phase of the model. It has two hidden layers \n # and the output layer. The activation function of the two hidden layers is \n # sigmoid function. The output layer activation function is the softmax function\n # because we are working with multi-class classification. \n #############################################################################\n\n # layer 1 \n # compute the forward pass on the first hidden layer with the sigmoid function\n\n self.hidden1 = np.dot(inputs, self.weights1) #(9000, 785) (785, 5)\n # self.hidden1 = self.sigmoid_fun(self.hidden1) #(9000, 5)\n self.hidden1 = 1.0 / (1.0 + np.exp(-self.beta*self.hidden1))\n self.hidden1 = np.concatenate((self.hidden1, -np.ones((np.shape(inputs)[0], 1))), axis=1) # (9000,6)\n\n\n # layer 2\n # compute the forward pass on the second hidden layer with the sigmoid function\n self.hidden2 = np.dot(self.hidden1, self.weights2) # (9000,6) (6, 5)\n self.hidden2 = self.sigmoid_fun(self.hidden2) # (9000,5)\n self.hidden2 = np.concatenate((self.hidden2, -np.ones((np.shape(self.hidden1)[0], 1))), axis=1) # (9000,6)\n\n # output layer\n # compute the forward pass on the output layer with softmax function\n outputs = np.dot(self.hidden2, self.weights3) # (9000,6) (6, 10)\n normalisers = np.sum(np.exp(outputs), axis=1)*np.ones((1, np.shape(outputs)[0]))\n outputs = np.transpose(np.transpose(np.exp(outputs)) / normalisers)\n # outputs = self.softmax_fun(outputs) # (9000,10)\n # print(outputs)\n #############################################################################\n # END of YOUR CODE \n #############################################################################\n return outputs","def forward(self, inp):\n if self.mode=='train':\n return self.pretrain_forward(inp)\n elif self.mode=='meta':\n data_shot, label_shot, data_query = inp\n return self.meta_forward(data_shot, label_shot, data_query)\n elif self.mode=='val':\n data_shot, label_shot, data_query = inp\n return self.preval_forward(data_shot, label_shot, data_query)\n else:\n raise ValueError('Please set the correct mode.')","def preval_forward(self, data_shot, label_shot, data_query):\n embedding_query = self.encoder(data_query)\n embedding_shot = self.encoder(data_shot)\n logits = self.base_learner(embedding_shot)\n #loss = self.FL(logits, label_shot) + self.CD(logits,label_shot) + self.LS(logits,label_shot)\n loss = self.CD(logits,label_shot)\n grad = torch.autograd.grad(loss, self.base_learner.parameters())\n fast_weights = list(map(lambda p: p[1] - 0.01 * p[0], zip(grad, self.base_learner.parameters())))\n logits_q = self.base_learner(embedding_query, fast_weights)\n\n for _ in range(1, 100):\n logits = self.base_learner(embedding_shot, fast_weights)\n #loss = self.FL(logits, label_shot) + self.CD(logits,label_shot) + self.LS(logits,label_shot)\n loss = self.CD(logits,label_shot)\n grad = torch.autograd.grad(loss, fast_weights)\n fast_weights = list(map(lambda p: p[1] - 0.01 * p[0], zip(grad, fast_weights)))\n logits_q = self.base_learner(embedding_query, fast_weights) \n return logits_q","def forward(self, *inputs):\n raise NotImplementedError","def forward_single(self, x, scale):\n cls_feat = x\n reg_feat = x\n for cls_conv in self.cls_convs:\n cls_feat = cls_conv(cls_feat)\n for reg_conv in self.reg_convs:\n reg_feat = reg_conv(reg_feat)\n cls_score = self.atss_cls(cls_feat)\n # we just follow atss, not apply exp in bbox_pred\n bbox_pred = scale(self.atss_reg(reg_feat)).float()\n iou_pred = self.atss_iou(reg_feat)\n return cls_score, bbox_pred, iou_pred","def forward(self, x):\n out = self.features(x)\n out = out.view(out.size(0), -1)\n out = self.classifier(out)\n return out","def forward(self, outputs):\n if isinstance(outputs, (tuple, list)):\n adv_loss = 0.0\n for i, outputs_ in enumerate(outputs):\n if isinstance(outputs_, (tuple, list)):\n # case including feature maps\n outputs_ = outputs_[-1]\n adv_loss += self.criterion(outputs_)\n if self.average_by_discriminators:\n adv_loss /= i + 1\n else:\n adv_loss = self.criterion(outputs)\n\n return adv_loss","def forward(self, input):\n raise NotImplementedError()","def forward(self, x):\n # pylint: disable=arguments-differ\n x = x.permute([0, 3, 1, 2, ])\n x = self.power(x * 0.00392156885937 + 0.0, 1.0)\n cat = self.conv1(x)\n x = self.conv2(cat)\n x = self.concat8((cat, x), 1)\n conv_final = self.conv3(x)\n conv_final_permute = conv_final.permute([0, 2, 3, 1])\n loc_pred, obj_pred, cls_pred = torch.split(conv_final_permute, [64, 16, 64], 3)\n # obj_perm = self.obj_pred(obj_perm) # sigmoid might lead to gradient losing.\n #cls_reshape = torch.reshape(cls_perm, (-1, 4))\n #cls_pred_prob = self.cls_pred_prob(cls_reshape)\n #cls_pred = torch.reshape(cls_pred_prob, cls_perm.shape)\n return obj_pred, cls_pred, loc_pred","def forward(self, input_tokens, prev_scores, timestep, *inputs, src_tuple=None):\n input_tokens = input_tokens.unsqueeze(1)\n log_probs_per_model, attn_weights_per_model, state_outputs, beam_axis_per_state, possible_translation_tokens = self._get_decoder_outputs(input_tokens, prev_scores, timestep, *inputs, src_tuple=src_tuple)\n average_log_probs = torch.mean(torch.cat(log_probs_per_model, dim=1), dim=1, keepdim=True)\n if possible_translation_tokens is None:\n word_rewards = self.word_rewards\n else:\n word_rewards = self.word_rewards.index_select(0, possible_translation_tokens)\n word_rewards = word_rewards.unsqueeze(dim=0).unsqueeze(dim=0)\n average_log_probs_with_rewards = average_log_probs + word_rewards\n average_attn_weights = torch.mean(torch.cat(attn_weights_per_model, dim=1), dim=1, keepdim=True)\n best_scores_k_by_k, best_tokens_k_by_k = torch.topk(average_log_probs_with_rewards.squeeze(1), k=self.beam_size)\n prev_scores_k_by_k = prev_scores.view(-1, 1).expand(-1, self.beam_size)\n total_scores_k_by_k = best_scores_k_by_k + prev_scores_k_by_k\n total_scores_flat = total_scores_k_by_k.view(-1)\n best_tokens_flat = best_tokens_k_by_k.view(-1)\n best_scores, best_indices = torch.topk(total_scores_flat, k=self.beam_size)\n best_tokens = best_tokens_flat.index_select(dim=0, index=best_indices).view(-1)\n prev_hypos = best_indices // self.beam_size\n attention_weights = average_attn_weights.index_select(dim=0, index=prev_hypos)\n if possible_translation_tokens is not None:\n best_tokens = possible_translation_tokens.index_select(dim=0, index=best_tokens)\n self.input_names = ['prev_tokens', 'prev_scores', 'timestep']\n for i in range(len(self.models)):\n self.input_names.append(f'fixed_input_{i}')\n if possible_translation_tokens is not None:\n self.input_names.append('possible_translation_tokens')\n attention_weights = attention_weights.squeeze(1)\n outputs = [best_tokens, best_scores, prev_hypos, attention_weights]\n self.output_names = ['best_tokens_indices', 'best_scores', 'prev_hypos_indices', 'attention_weights_average']\n for i in range(len(self.models)):\n self.output_names.append(f'fixed_input_{i}')\n if self.tile_internal:\n outputs.append(inputs[i].repeat(1, self.beam_size, 1))\n else:\n outputs.append(inputs[i])\n if possible_translation_tokens is not None:\n self.output_names.append('possible_translation_tokens')\n outputs.append(possible_translation_tokens)\n for i, state in enumerate(state_outputs):\n beam_axis = beam_axis_per_state[i]\n if beam_axis is None:\n next_state = state\n else:\n next_state = state.index_select(dim=beam_axis, index=prev_hypos)\n outputs.append(next_state)\n self.output_names.append(f'state_output_{i}')\n self.input_names.append(f'state_input_{i}')\n return tuple(outputs)","def forward(self, x):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n\n x = self.pool1(F.relu(self.batch1(self.conv1(x))))\n x = self.pool2(F.relu(self.batch2(self.conv2(x))))\n x = F.relu(self.batch3a(self.conv3a(x)))\n x = self.pool3(F.relu(self.batch3b(self.conv3b(x))))\n x = F.relu(self.batch4a(self.conv4a(x)))\n x = self.pool4(F.relu(self.batch4b(self.conv4b(x))))\n x = F.relu(self.batch5a(self.conv5a(x)))\n x = self.pool5(F.relu(self.batch5b(self.conv5b(x))))\n x = self.avgpool(x)\n x = x.reshape(x.shape[0], -1)\n out = self.fc1(x)\n\n# raise NotImplementedError\n ########################\n # END OF YOUR CODE #\n #######################\n\n return out","def fwd_pass( self, X, ls_emb, sp_emb, y, optimizer, loss_function, train=False, report=True):\n if train:\n self.zero_grad()\n outputs = self(X, ls_emb, sp_emb)\n loss = loss_function(outputs, y)\n\n if train:\n loss.backward()\n optimizer.step()\n\n if report:\n tp = 0\n tn = 0\n fn = 0\n fp = 0\n for i,j in zip(outputs, y):\n if torch.argmax(i) == torch.argmax(j):\n if j.data.cpu().numpy()[0] == 1: #positive instance\n tp += 1\n else: \n tn += 1\n else:\n if j.data.cpu().numpy()[0] == 1:\n fn += 1\n else:\n fp += 1\n\n #matches = [torch.argmax(i) == torch.argmax(j) for i,j in zip(outputs, y)]\n acc = (tp+tn)/(tp+tn+fp+fn)\n conf = [tp, fp, fn, tn]\n return acc, loss, conf\n else:\n return None,None","def scoring(self):\n pass","def forward_propagation(self):\n pred_y = argmax(self.model.predict(train_x), axis=1)\n\n accuracy_func = Accuracy()\n accuracy_func.update_state(pred_y, train_y)\n self.accuracy = accuracy_func.result().numpy()","def forward(self, X):\n features = self.get_conv_feats(X)\n prediction = blah\n return (prediction)","def f1_score_model(self, model, X, y):\n\n prediction = model.predict_classes(X)\n f1_macro = f1_score(y, prediction, average='macro')\n f1_micro = f1_score(y, prediction, average='macro')\n print(\"f1_macro: \", f1_score(y, prediction, average='macro'))\n print(\"f1_micro: \", f1_score(y, prediction, average=\"micro\"))\n print(\"f1_weighted: \", f1_score(y, prediction, average=\"weighted\"))\n return f1_macro, f1_micro","def cvWorker(epochs, theta, folds, trainFunc, testFunc, report, queue):\n\n # track how many correct predictions are made over all folds with current hyperparams\n totalCorrect = 0;\n totalAttempts = 0;\n for (i,f) in enumerate(folds): \n \n testFold = f;\n trainFold = reduce(operator.add, folds[:i] + folds[i+1:]); # flatten training fold \n \n # learn weights \n w = trainFunc(trainFold, epochs, theta);\n \n # accumulate test accuracy\n [correct, attempts] = testFunc(w, testFold);\n totalCorrect += correct;\n totalAttempts += attempts; \n \n # update based on results and post to queue\n rate = totalCorrect / totalAttempts;\n if not (report == None):\n tabs = '\\t' * report;\n print tabs, 'Cross validation accuracy=', rate, 'for theta=', theta;\n results = (theta, rate); \n queue.put(results)\n \n return;","def forward_single(self, x):\n cls_feat = x\n reg_feat = x\n for cls_conv in self.cls_convs:\n cls_feat = cls_conv(cls_feat)\n for reg_conv in self.reg_convs:\n reg_feat = reg_conv(reg_feat)\n cls_score = self.retina_cls(cls_feat)\n bbox_pred = self.retina_reg(reg_feat)\n return cls_score, bbox_pred","def predict(self, X):\r\n \r\n # To speed up, we apply the scoring function to all the instances\r\n # at the same time.\r\n scores = X.dot(self.w)\r\n \r\n # Create the output array.\r\n # At the positions where the score is positive, this will contain\r\n # self.positive class, otherwise self.negative_class.\r\n out = numpy.select([scores>=0.0, scores<0.0], [self.positive_class, \r\n self.negative_class])\r\n return out","def score(self, X, y):\r\n n_feature, _ = self.check_model()\r\n _, n_label = y.shape\r\n y = self.check_X_y_weights(X, y)\r\n\r\n if X.shape[1] == (n_feature + 1):\r\n X = X[:, 1:]\r\n\r\n assert (X.shape[1] == n_feature), \"X is of the wrong shape\"\r\n\r\n if self.scoring_func is None:\r\n y_pred = self.forward(X)\r\n\r\n loss = self.loss_func(torch.from_numpy(y_pred).float(),\r\n torch.from_numpy(y).float())\r\n loss = torch.mean(torch.sum(loss, 1)).numpy()\r\n\r\n return - loss\r\n else:\r\n y_pred = self.predict(X)\r\n return self.scoring_func(y_pred, y)","def forward(self, inputs, target_oneHot):\n\n N = inputs.size()[0]\n\n # predicted probabilities for each pixel along channel\n inputs = F.softmax(inputs, dim=1)\n\n # Numerator Product\n inter = inputs * target_oneHot\n # Sum over all pixels N x C x H x W => N x C\n inter = inter.view(N, self.classes, -1).sum(2)\n\n # Denominator\n union = inputs + target_oneHot - (inputs * target_oneHot)\n # Sum over all pixels N x C x H x W => N x C\n union = union.view(N, self.classes, -1).sum(2)\n\n loss = inter / union\n\n ## Return average loss over classes and batch\n # return 1 - loss.mean()\n return -(loss.mean() - 1.)","def classification_score(self, x, y):\t\n\t\tpass","def f1_score(self):\n self.overall_f1_score = f1_score(\n self.y_true, self.y_pred, average = self.average_type).round(self.digits_count_fp)\n self.classes_f1_score = f1_score(\n self.y_true, self.y_pred, average = None).round(self.digits_count_fp)","def pre_step(x, y):\r\n feed_dict = {\r\n cnn.input_x: x,\r\n cnn.input_y: y,\r\n cnn.dropout_keep_prob: 1.0\r\n }\r\n scores = sess.run([cnn.scores], feed_dict)\r\n return scores","def forward(self, y_pred, y_true):\n if not isinstance(y_true, Tensor):\n y_true = y_true.class_id\n if not isinstance(y_pred, Tensor):\n y_pred = y_pred.class_id\n\n pred_class = y_pred.argmax(dim=self.axis)\n true_class = y_true.long()\n correct_predictions = pred_class == true_class\n loss = correct_predictions.float().mean(dim=self.axis)\n if self.reduction == \"none\":\n return loss\n elif self.reduction == \"sum\":\n return loss.sum()\n elif self.reduction == \"mean\":\n return loss.mean()","def __call__(\n self,\n batch: PredictionBatch,\n target: Target,\n scores: torch.FloatTensor,\n ) -> None:\n raise NotImplementedError","def forward(self, x: torch.Tensor) -> tuple:\n \n x_range_view = x[:, 2:]\n \n dla_out = self.dla(x_range_view)\n\n class_preds = self.classes(dla_out)\n\n return class_preds","def forward(self, x, y):\n x1 = x.clone()\n x1[range(x1.size(0)), y] = -float(\"Inf\")\n x_gt = x[range(x.size(0)), y].unsqueeze(1)\n x_topk = torch.topk(x1, 15, dim=1)[0] # 15 Negative classes to focus on, its a hyperparameter\n x_new = torch.cat([x_gt, x_topk], dim=1)\n\n return self.ce(x_new, torch.zeros(x_new.size(0)).cuda().long())","def preval_forward(self, data_shot, label_shot, data_query):\n embedding_query = self.encoder(data_query)\n embedding_shot = self.encoder(data_shot)\n logits = self.base_learner(embedding_shot)\n loss = F.cross_entropy(logits, label_shot)\n grad = torch.autograd.grad(loss, self.base_learner.parameters())\n fast_weights = list(map(lambda p: p[1] - 0.01 * p[0], zip(grad, self.base_learner.parameters())))\n logits_q = self.base_learner(embedding_query, fast_weights)\n\n for _ in range(1, 100):\n logits = self.base_learner(embedding_shot, fast_weights)\n loss = F.cross_entropy(logits, label_shot)\n grad = torch.autograd.grad(loss, fast_weights)\n fast_weights = list(map(lambda p: p[1] - 0.01 * p[0], zip(grad, fast_weights)))\n logits_q = self.base_learner(embedding_query, fast_weights) \n return logits_q","def _forward(self, inputs):\n if is_tf_available():\n # TODO trace model\n predictions = self.model(inputs)[0]\n else:\n import torch\n with torch.no_grad():\n predictions = self.model(**inputs)[0]\n\n return predictions.numpy()","def forward(self, inputs):\n coords = inputs['point'].to(self.device)\n feat = inputs['feat'].to(self.device)\n\n out_features_list = []\n for i in range(len(self.point_features)):\n feat, _ = self.point_features[i]((feat, coords))\n out_features_list.append(feat)\n # feat: num_batches * 1024 * num_points -> num_batches * 1024 -> num_batches * 128\n feat = self.cloud_features(feat.max(dim=-1, keepdim=False).values)\n out_features_list.append(\n feat.unsqueeze(-1).repeat([1, 1, coords.size(-1)]))\n out = self.classifier(torch.cat(out_features_list, dim=1))\n return out.transpose(1, 2)","def feed_forward(self, inputs):\n raise NotImplementedError()","def forward(self, inputs, hx):\n output_size = 2 * self._num_units\n if self._use_gc_for_ru:\n fn = self._gconv\n else:\n fn = self._fc\n value = torch.sigmoid(fn(inputs, hx, output_size, bias_start=1.0))\n value = torch.reshape(value, (-1, self._num_nodes, output_size))\n r, u = torch.split(tensor=value, split_size_or_sections=self._num_units, dim=-1)\n r = torch.reshape(r, (-1, self._num_nodes * self._num_units))\n u = torch.reshape(u, (-1, self._num_nodes * self._num_units))\n\n c = self._gconv(inputs, r * hx, self._num_units)\n if self._activation is not None:\n c = self._activation(c)\n\n new_state = u * hx + (1.0 - u) * c\n return new_state","def _feed_forward(self, X):\n # Add code to calculate a1 and probs\n z1 = X.dot(self.Wxh) + self.bh\n a1 = np.tanh(z1)\n z2 = a1.dot(self.Why) + self.by\n exp_scores = np.exp(z2)\n probs = exp_scores/np.sum(exp_scores, axis=1, keepdims=True)\n return a1, probs","def scores(model,X_train,y_train, X_test,y_test,inside):\r\n \r\n model.best_apply(X_test,y_test)\r\n y_pred = model.forward(X_test).cpu()\r\n y_pred = np.asarray(torch.argmax(y_pred, dim = 1).squeeze())\r\n y_test_ = np.asarray(torch.argmax(y_test.cpu(), dim = 1))\r\n acc1 = accuracy_score(y_test_,y_pred)\r\n model.best_apply(X_train,y_train)\r\n y_pred = model.forward(X_train).cpu()\r\n y_pred = np.asarray(torch.argmax(y_pred, dim = 1).squeeze())\r\n y_train_ = np.asarray(torch.argmax(y_train.cpu(), dim = 1))\r\n acc2 = accuracy_score(y_train_,y_pred)\r\n if inside :\r\n print(\"###### Results ##########\")\r\n print(\"The Validation Acuuracy is : \",acc1)\r\n print(\"The Training Acuuracy is : \",acc2)\r\n return [acc1,acc2]","def train(self, dataset): \n dataset = dataset[dataset[:,-1].argsort()] # Sort the dataset by classes.\n #print dataset\n \n ########\n # Compute p(y=1) for all ys.\n ########\n label_counts = np.bincount(dataset[:,-1]) # Get the number of occurrences of each class, sorted. \n self.p_ys = np.log(label_counts * 1.0 / len(dataset)) # Compute probs. \n \n ########\n # Compute p(x|y) for all x,y.\n ########\n self.feature_count = len(dataset[0]) - 1 \n self.class_count = len(label_counts)\n \n self.p_xi_given_ys = np.zeros((self.class_count, self.feature_count)) # Initialize matrix\n start_index = 0\n for i in range(self.class_count): # Loop over each class \n end_index = start_index + label_counts[i] # end of this class index \n class_word_counts = np.sum(dataset[start_index:end_index,:-1]) # sum all words of class i \n denominator = class_word_counts + self.alpha * self.feature_count # Here we add the feature_count as Laplace smoothing\n \n for j in range(self.feature_count): # Loop over each feature\n single_word_count = np.sum(dataset[start_index:end_index,j]) # sum number times word j appears in class i \n numerator = single_word_count + self.alpha\n self.p_xi_given_ys[i][j] = log(numerator * 1.0 / denominator) # Compute p(xi|y)\n \n start_index = end_index","def train(self, dataset): \n dataset = dataset[dataset[:,-1].argsort()] # Sort the dataset by classes.\n #print dataset\n \n ########\n # Compute p(y=1) for all ys.\n ########\n label_counts = np.bincount(dataset[:,-1]) # Get the number of occurrences of each class, sorted. \n self.p_ys = label_counts * 1.0 / len(dataset) # Compute probs. \n \n ########\n # Compute p(x|y) for all x,y.\n ########\n self.feature_count = len(dataset[0]) - 1 \n self.class_count = len(label_counts)\n \n self.p_xi_given_ys = np.zeros((self.class_count, self.feature_count)) # Initialize matrix\n start_index = 0\n for i in range(self.class_count): # Loop over each class \n end_index = start_index + label_counts[i] # end of this class index \n denominator = label_counts[i] + 2.0 * self.alpha\n \n for j in range(self.feature_count): # Loop over each feature\n numerator = np.sum(dataset[start_index:end_index,j]) + self.alpha # Sum number of times word j = 1 in class i\n self.p_xi_given_ys[i][j] = numerator * 1.0 / denominator # Compute p(xi|y)\n \n start_index = end_index","def forward(ctx, input, gamma, beta, eps=1e-5):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n\n ####### Forward pass of batch normalization ######\n\n # In this section, we have to perform the forward pass of batch normalization\n # with more intermediate steps, since we want to propagate error terms. \n # To illustrate it better, we began from the bottom and follow our way to the top.\n # In that way, we unfolded every function step by step.\n\n # Step 3.2.3: Calculate variance\n var = input.var(dim=0, unbiased=False)\n\n # Step 3.2.2: add eps for numerical stability, then sqrt\n sqrt_var = torch.sqrt(var + eps)\n\n # Step 3.2: ivert sqrtwar\n inv_sqrt_var = 1./sqrt_var\n\n # Step 3.1.1: Calculate mean\n mean = input.mean(dim=0)\n\n # Step 3.1: subtract mean vector of every trainings example\n input_mean = input - mean\n\n # Step 3 - Execute normalization\n input_norm = input_mean * inv_sqrt_var \n\n # Step 2: Nor the two transformation steps\n scaled_input_norm = gamma * input_norm\n\n # Step 1: scale and shift\n out = scaled_input_norm + beta\n #################################################\n # store tensors and non-tensorial constants\n ctx.save_for_backward(gamma, inv_sqrt_var, mean, input)\n ctx.foo = eps\n ########################\n # END OF YOUR CODE #\n #######################\n\n return out","def forward(self, x):\n vgg_out = self.vgg(x)\n cls_out = self.classifier(vgg_out)\n reg_out = self.regressor(vgg_out)\n #out = torch.cat((cls_out, reg_out), 0) # might be the wrong dimension\n \n return cls_out,reg_out","def forward(self, x):\n # sources保存特征图，loc与conf保存所有PriorBox的位置与类别预测特征\n sources = list()\n loc = list()\n conf = list()\n\n # 对输入图像卷积到conv4_3，将特征添加到sources中\n for k in range(23):\n x = self.vgg[k](x)\n\n s = self.L2Norm(x)\n sources.append(s)\n\n # 继续卷积到conv7，将特征添加到sources中\n for k in range(23, len(self.vgg)):\n x = self.vgg[k](x)\n sources.append(x)\n\n # 继续利用额外的卷积层计算，并将特征添加到sources中\n for k, v in enumerate(self.extras):\n x = F.relu(v(x), inplace=True)\n if k % 2 == 1: # 间隔一层\n sources.append(x)\n\n # 对sources中的特征图利用类别与位置网络进行卷积计算，并保存到loc与conf中\n for (x, l, c) in zip(sources, self.loc, self.conf):\n loc.append(l(x).permute(0, 2, 3, 1).contiguous())\n conf.append(c(x).permute(0, 2, 3, 1).contiguous())\n\n loc = torch.cat([o.view(o.size(0), -1) for o in loc], 1)\n conf = torch.cat([o.view(o.size(0), -1) for o in conf], 1)\n\n if self.phase == \"test\":\n output = self.detect(\n loc.view(loc.size(0), -1, 4), # loc preds\n self.softmax(conf.view(conf.size(0), -1, self.num_classes)), # conf preds\n self.priors.type(type(x.data)) # default boxes\n )\n else:\n # 对于训练来说，output包括了loc与conf的预测值以及PriorBox的信息\n output = (\n loc.view(loc.size(0), -1, 4),\n conf.view(conf.size(0), -1, self.num_classes),\n self.priors\n )\n return output","def forward(self, inputs, **kwargs):\n x = self.ff_module1(inputs)\n x = self.mha_module(x, **kwargs)\n x = self.conv_module(x)\n x = self.ff_module2(x)\n\n return x","def forward(self, X, labels):\n features = self.get_conv_feats(X)\n W = self.W\n T = self.T\n log_prob = CRFautograd.apply(W, T, features, labels)\n return log_prob","def forward_pass(self):\n # Compute the support set's mean and var and use these as the moments for\n # batch norm on the query set.\n train_embeddings = self.embedding_fn(self.episode.train_images,\n self.is_training)\n self.train_embeddings = train_embeddings['embeddings']\n support_set_moments = None\n if not self.transductive_batch_norm:\n support_set_moments = train_embeddings['moments']\n test_embeddings = self.embedding_fn(\n self.episode.test_images,\n self.is_training,\n moments=support_set_moments,\n backprop_through_moments=self.backprop_through_moments)\n self.test_embeddings = test_embeddings['embeddings']","def forward(self, *args, mode=\"train\", **kwargs):\n raise NotImplementedError","def fit(self):\n accuracy = 0\n no_improvement = 0\n epochs = trange(self.args.epochs, desc=\"Accuracy\")\n self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.args.learning_rate)\n self.model.train()\n for epoch in epochs:\n self.optimizer.zero_grad()\n prediction = self.model(self.propagation_matrix, self.features)\n loss = torch.nn.functional.nll_loss(prediction[self.train_nodes], self.target[self.train_nodes])\n loss = loss + self.args.lambd*torch.sum(self.model.page_rank_convolution_1.weight_matrix**2)\n loss.backward()\n self.optimizer.step()\n new_accuracy = self.score(self.validation_nodes)\n epochs.set_description(\"Validation Accuracy: %g\" % round(new_accuracy,4))\n if new_accuracy < accuracy:\n no_improvement = no_improvement + 1\n if no_improvement == self.args.early_stopping:\n epochs.close()\n break\n else:\n no_improvement = 0\n accuracy = new_accuracy \n acc = self.score(self.test_nodes)\n print(\"\\nTest accuracy: \" + str(round(acc,4)) )","def calculate_scores(self):\n # Prediction based scores\n #self.report = classification_report(self.y_test, self.y_pred)\n self.accuracy = accuracy_score(self.y_real, self.y_pred)\n self.precision = precision_score(self.y_real, self.y_pred)\n self.recall = recall_score(self.y_real, self.y_pred)\n self.f1 = f1_score(self.y_real, self.y_pred)\n \n # Probability based scores\n self.fpr, self.tpr, _ = roc_curve(self.y_real, self.y_proba)\n self.average_precision = average_precision_score(self.y_real, self.y_proba)\n self.brier_loss = brier_score_loss(self.y_real, self.y_proba)\n self.roc_auc = roc_auc_score(self.y_real, self.y_proba)\n self.prec_cur, self.recall_cur, _ = precision_recall_curve(self.y_real, self.y_proba)","def train(self, input_scores: np.ndarray, true_labels: np.ndarray) -> None:\n self.model.compile(\n loss=\"categorical_crossentropy\", optimizer=\"adam\", metrics=[\"acc\"]\n )\n\n input_scores = np.moveaxis(input_scores, 0, -1)\n\n train_data, val_data, train_labels, val_labels = train_test_split(\n input_scores, true_labels, test_size=0.2, stratify=true_labels\n )\n\n train_labels = keras.utils.to_categorical(\n train_labels, num_classes=self.num_classes\n )\n val_labels = keras.utils.to_categorical(\n val_labels, num_classes=self.num_classes\n )\n\n self.model.fit(\n x=train_data,\n y=train_labels,\n validation_data=(val_data, val_labels),\n epochs=30,\n callbacks=[\n TerminateOnNaN(),\n EarlyStopping(\n patience=15, monitor=\"val_acc\", restore_best_weights=True\n ),\n ],\n )","def forward(self, images):\n # assuming that the precomputed features are not already l2-normalized\n x = l2norm(images.view( images.size(0), -1))\n #print(images.shape, self.fc )\n x = self.relu(self.fc1(x))\n x = self.fc2(x)\n #x = F.log_softmax(x) #no need of log softmax here if we use cross entropy as loss\n #x = self.softmax(x)\n # normalize in the joint embedding space\n \n\n return x","def loss(self, X, y=None):\n\n # In dev testing, the loss fnc stops at \"scores\" , unfollowed by \"softmax\" probability prediction.\n # In real testing, \"self.predict()\" needs to be implemented in Solver() class.\n \n if y is None:\n for bn_param in self.bn_params:\n bn_param[\"mode\"] = \"test\"\n\n\n W1, b1 = self.params['W1'], self.params['b1']\n gamma1, beta1 = self.params[\"sbnGamma1\"], self.params[\"sbnBeta1\"]\n bn_param1 = self.bn_params[0]\n\n W2, b2 = self.params['W2'], self.params['b2']\n gamma2, beta2 = self.params[\"sbnGamma2\"], self.params[\"sbnBeta2\"]\n bn_param2 = self.bn_params[1]\n\n W3, b3 = self.params['W3'], self.params['b3']\n gamma3, beta3 = self.params[\"bnGamma3\"], self.params[\"bnBeta3\"]\n bn_param3 = self.bn_params[2]\n\n W4, b4 = self.params['W4'], self.params['b4']\n \n # pass conv_param to the forward pass for the convolutional layer\n conv_param = self.conv_param\n\n # pass pool_param to the forward pass for the max-pooling layer\n pool_param = self.maxpool_params\n\n ############################################################################\n # TODO: Implement the forward pass for the three-layer convolutional net, #\n # computing the class scores for X and storing them in the scores #\n # variable. #\n ############################################################################\n \n scores = None \n cache = {}\n # def conv_sbn_relu_forward(x, w, b, gamma, beta, conv_param, bn_param): return out, cache;\n out, cache[\"layer1\"] = layer_utils.conv_sbn_relu_forward(X, W1, b1, gamma1, beta1, conv_param, bn_param1) \n out, cache[\"layer2\"] = layer_utils.conv_sbn_relu_forward(out, W2, b2, gamma2, beta2, conv_param, bn_param2)\n\n # def max_pool_forward_fast(x, pool_param): return out, cache;\n out, cache[\"maxpool\"] = fast_layers.max_pool_forward_fast(out, pool_param)\n\n # def affine_bn_relu_forward(x, w, b, gamma, beta, bn_param): return out, cache;\n \n out, cache[\"layer3\"] = layer_utils.affine_bn_relu_forward(out, W3, b3, gamma3, beta3, bn_param3)\n\n # def affine_forward(x, w, b): return out, cache;\n scores, cache[\"layer4\"] = layers.affine_forward(out, W4, b4)\n\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n \n if y is None:\n return scores\n \n ############################################################################\n # TODO: Implement the backward pass for the three-layer convolutional net, #\n # storing the loss and gradients in the loss and grads variables. Compute #\n # data loss using softmax, and make sure that grads[k] holds the gradients #\n # for self.params[k]. Don't forget to add L2 regularization! #\n ############################################################################\n \n loss, grads = 0, {}\n\n # def softmax_loss(x, y): return loss, dscore;\n loss, dscores = layers.softmax_loss(scores, y)\n loss += 0.5 * self.reg * (np.sum(W1 * W1) + np.sum(W2 * W2) + np.sum(W3 * W3) + np.sum(W4 * W4))\n\n # def affine_backward(dout, cache): return dx, dw, db;\n dout, dW4, db4 = layers.affine_backward(dscores, cache[\"layer4\"]) \n\n # def affine_bn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\n dout, dW3, db3, dgamma3, dbeta3 = layer_utils.affine_bn_relu_backward(dout, cache[\"layer3\"])\n\n # print cache[\"layer3\"]\n\n # def max_pool_backward_fast(dout, cache): return max_pool_backward_im2col(dout, real_cache);\n # def max_pool_backward_im2col(dout, cache): return dx;\n dout = fast_layers.max_pool_backward_fast(dout, cache[\"maxpool\"])\n\n # def conv_sbn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\n dout, dW2, db2, dgamma2, dbeta2 = layer_utils.conv_sbn_relu_backward(dout, cache[\"layer2\"])\n _, dW1, db1, dgamma1, dbeta1 = layer_utils.conv_sbn_relu_backward(dout, cache[\"layer1\"])\n\n # reg\n grads['W4'], grads['b4'] = dW4 + self.reg * W4, db4\n \n grads['W3'], grads['b3'] = dW3 + self.reg * W3, db3\n grads[\"bnGamma3\"], grads[\"bnBeta3\"] = dgamma3, dbeta3\n\n grads['W2'], grads['b2'] = dW2 + self.reg * W2, db2\n grads[\"sbnGamma2\"], grads[\"sbnBeta2\"] = dgamma2, dbeta2\n\n grads['W1'], grads['b1'] = dW1 + self.reg * W1, db1\n grads[\"sbnGamma1\"], grads[\"sbnBeta1\"] = dgamma1, dbeta1\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n \n return loss, grads","def compute_forward(self, batch, stage):\n\n # We first move the batch to the appropriate device.\n batch = batch.to(self.device)\n # Compute features, embeddings, and predictions\n feats, lens = self.prepare_features(batch.sig, stage)\n embeddings = self.modules.embedding_model(feats.cuda(), lens.cuda())\n predictions = self.modules.classifier(embeddings)\n return predictions","def f1_score(self):","def forward(self, train_imgs, test_imgs, train_bb, test_bb, test_win, test_bb_inwin, *args, **kwargs):\n\n assert train_imgs.dim() == 5 and test_imgs.dim() == 5, 'Expect 5 dimensional inputs'\n # Extract backbone features, OrderedDict, layer2 [30, 512, 36, 36] layer3 [30, 1024, 18, 18]\n train_feat = self.extract_backbone_features(train_imgs.reshape(-1, *train_imgs.shape[-3:]))\n test_feat = self.extract_backbone_features(test_imgs.reshape(-1, *test_imgs.shape[-3:]))\n\n test_win = test_win.reshape(-1, 4)\n\n # Classification features\n train_feat_clf = self.get_backbone_clf_feat(train_feat)\n test_feat_clf = self.get_backbone_clf_feat(test_feat)\n\n # Run classifier module, train_skfeat.dim()=5, test_skfeat.dim()=5\n target_scores, train_skfeat, test_skfeat, channel_importance = self.classifier(train_feat_clf, test_feat_clf,\n train_bb, *args, **kwargs)\n\n train_feat_se, test_feat_se = self.adjust_skfeat(train_skfeat, test_skfeat, channel_importance)\n # Using the same feature with the classifier to estimate the target state\n bboxes, cls = self.state_estimator(train_feat_se, test_feat_se,\n train_bb, test_win, test_bb_inwin, target_scores)\n\n return target_scores, bboxes, cls","def forward(self, x):\n out = self.pre_processing(x)\n out = self.a3(out)\n out = self.b3(out)\n out = self.maxpool(out)\n out = self.a4(out)\n out = self.b4(out)\n out = self.c4(out)\n out = self.d4(out)\n out = self.e4(out)\n out = self.maxpool(out)\n out = self.a5(out)\n out = self.b5(out)\n out = self.avgpool(out)\n out = out.view(out.size(0), -1) # reshape the output tensor\n out = self.linear(out)\n\n return out","def _forward_alg(self, feats):\n\n init_alphas = torch.full((self.batch_size, 1, self.tagset_size), -10000.).to(self.device)\n # START_TAG has all of the score.\n init_alphas[:, 0, self.tag2idx[START_TAG]] = 0.\n forward_var = init_alphas\n\n # Iterate through the sentence\n for i in range(feats.shape[1]):\n feat = feats[:,i,:]\n\n emit_score = feat.view(self.batch_size, self.tagset_size, 1)\n next_tag_var = forward_var + self.transitions + emit_score\n forward_var = torch.logsumexp(next_tag_var,dim=-1).view(self.batch_size, 1, self.tagset_size)\n\n terminal_var = forward_var + self.transitions[self.tag2idx[STOP_TAG]]\n alpha = torch.logsumexp(terminal_var,dim=-1)\n return alpha","def classification(features, scores, n_classes, model_type=0, save_path='results/',\n lr=.01, batch_size=10, n_epochs=20, test_size=.3,\n verbose=False, save_results=False, normalize=True):\n # features, scores = read_data_from_csv()\n verbose_opc = 0\n if verbose:\n print(\"[INFO] Shuffle Data\")\n verbose_opc = 1\n\n features, scores = shuffle(features, scores, random_state=0)\n\n if normalize:\n if verbose:\n print(\"[INFO] Normalizing Data\")\n scaler = StandardScaler()\n scaler.fit(features)\n features = scaler.transform(features)\n\n if verbose:\n print(\"[INFO] Splitting data into train and test sets\")\n x_train, x_test, y_train, y_test = train_test_split(features, scores, test_size=test_size)\n\n\n\n if verbose:\n print(\"[INFO] Creating the machine learning model\")\n\n model = None\n if model_type == 0:\n model = res_model(x_train.shape[1:], n_classes)\n elif model_type == 1:\n model = simple_model(x_train.shape[1:], n_classes)\n elif model_type == 2:\n model = sklearn.svm.SVC(gamma='auto')\n elif model_type == 3:\n model = RandomForestClassifier()\n elif model_type == 4:\n model = AdaBoostClassifier()\n elif model_type == 5:\n model = xgb.XGBClassifier(objective=\"multi:softprob\", random_state=42)\n\n h = None\n if model_type >= 0 and model_type <= 1:\n # classes 0.0 ,0.5, 1.0, 1.5, 2.0\n y_cat_train = to_categorical(y_train, n_classes)\n y_cat_test = to_categorical(y_test, n_classes)\n\n model.compile(loss=\"logcosh\",\n #optimizer=keras.optimizers.SGD(lr=lr, momentum=.3),\n optimizer=\"adamax\",\n metrics=['accuracy'])\n\n h = model.fit(x_train, y_cat_train,\n batch_size=batch_size,\n epochs=n_epochs,\n validation_data=(x_test, y_cat_test),\n verbose=verbose_opc)\n\n evaluate_model(x_test, y_cat_test, batch_size, model, n_epochs, h, n_classes, folder_name=save_path,\n save_results=save_results, is_rna=True)\n else:\n model.fit(x_train, y_train)\n\n evaluate_model(x_test, y_test, batch_size, model, n_epochs, h, n_classes, folder_name=save_path,\n save_results=save_results)\n\n return model","def training_step(self, x):\n self.train()\n rec_error, feat, y = self.forward(x)\n # Reconstruction Loss\n rec_loss = torch.mean(rec_error)\n loss = rec_loss\n\n self.zero_grad()\n loss.backward()\n self.optimizer.step()\n self.eval()\n print('Rec Loss: {}'.format(rec_loss.cpu().data))\n print()\n return loss, feat, y","def custom_scoring(y_te, y_pred):\n #weights computed with training data set\n w = np.array([0.02409584, 0.00787456, 0.03685528, 0.01760536, 0.04589969, 0.8483942 , 0.01724058, 0.00203449]);\n \n ## F1 SCORES\n #evaluate F1 score, precision and recall for each label, \n #along with custom proportionally weighted F1 score\n #and built in weighted and macro F1 scores\n F1_tab, Ptab, Rtab, pf1 = F1_score(y_te, y_pred, w)\n f = F1Score(8, threshold = 0.5, average = 'weighted')\n f.update_state(y_te, y_pred)\n wf1 = f.result().numpy() #weighted f1 score\n f.reset_states()\n f = F1Score(8, threshold = 0.5, average = 'macro')\n f.update_state(y_te, y_pred)\n mf1 = f.result().numpy() #macro f1 score\n f.reset_states()\n\n ##EDIT DISTANCE\n #edit_dist_av = LevDistMultilabels(y_true, y_pred)\n\n ##ACCURACY\n #evaluate accuracy per label\n acc_tab = Acc(y_te, y_pred)\n\n return wf1, mf1, pf1, F1_tab, Ptab, Rtab, acc_tab","def loss(self, X, y=None):\n X = X.astype(self.dtype)\n mode = 'test' if y is None else 'train'\n\n scores = None\n ############################################################################\n # Implementing the forward pass for the fully-connected net, computing #\n # the class scores for X and storing them in the scores variable. #\n ############################################################################\n\n l_input = X.copy()\n out = []\n cache = []\n for i in range(self.num_layers - 1):\n # layerwise compute the forward pass and store outputs in out list\n key = ['W' + str(i+1), 'b' + str(i+1)]\n lout, lcache = affine_sigmoid_forward(l_input, self.params[key[0]], self.params[key[1]])\n out.append(lout)\n cache.append(lcache)\n l_input = lout\n\n key = ['W' + str(self.num_layers), 'b' + str(self.num_layers)]\n scores, lcache = affine_forward(out[self.num_layers - 2], self.params[key[0]], self.params[key[1]])\n cache.append(lcache)\n \n # regularization parameter compute by summing square of all weight vectors\n R = 0\n for i in range(1, self.num_layers + 1):\n key = 'W' + str(i)\n R += np.sum(np.power(self.params[key], 2))\n\n # If test mode return early\n if mode == 'test':\n return scores\n\n loss, grads = 0.0, {}\n\n ########################\n # Backward pass to compute the loss and gradients\n ########################\n\n loss, dscore = softmax_loss(scores, y)\n # Apply regularization of the loss \n loss = loss + 0.5 * self.reg * R\n\n key = ['W' + str(self.num_layers), 'b' + str(self.num_layers)]\n dx, grads[key[0]], grads[key[1]] = affine_backward(dscore, cache[self.num_layers - 1])\n grads[key[0]] += self.reg * self.params[key[0]] \n\n for i in range(self.num_layers - 1, 0, -1):\n key = ['W' + str(i), 'b' + str(i)]\n dx, grads[key[0]], grads[key[1]] = affine_sigmoid_backward(dx, cache[i-1])\n # Apply regularization to the gradients\n grads[key[0]] += self.reg * self.params[key[0]]\n\n return loss, grads","def forward_prop(net, input_values, threshold_fn=stairstep):\n raise NotImplementedError","def forward(self, input):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n assert input.shape[1] == self.n_neurons, \"The shape of the input tensor is not correct.\"\n\n # compute mean\n mean = input.mean(dim=0)\n\n # compute variance\n var = input.var(dim=0, unbiased=False)\n\n # normalize\n input_norm = (input-mean)/(torch.sqrt(var + self.eps))\n\n # scale and shift\n out = self.gamma*input_norm + self.beta\n ########################\n # END OF YOUR CODE #\n #######################\n\n return out","def score(self, X, y=...):\n ...","def calc_score(model, scorer, X, y_true):\n\n y_preds = model.predict(X)\n score = scorer(y_true, y_preds)\n\n return score","def on_iter_forward(self, runner):\n # unpack features into features and targets\n *features, target = runner.batch\n # Forward features\n runner.output = runner.model(*features)\n # Ensure `targetL` and `outputL` are always in a list format.\n targetL = [target] if not isinstance(target, (list, tuple)) else target\n outputL = [runner.output] if not isinstance(runner.output, (list, tuple)) else runner.output\n # Compute loss\n runner.loss = runner.criterion(*outputL, *targetL)\n runner.target = target","def _prob_to_class(self, forward):\n predict_pos = self.activation(forward)\n predict_neg = 1 - predict_pos\n\n return torch.stack((predict_neg, predict_pos)).argmax(0).float()","def forward(self, tokens, lprobs, rewards, sample, scr_scores, reduce=True, **kwargs):\n\n loss, sc_loss = self.compute_loss(tokens, lprobs, rewards)\n try:\n n_pos = rewards.ge(0.0).sum().div(rewards.size(1)).item()\n except:\n n_pos = rewards.ge(0.0).sum().floor_divide(rewards.size(1)).item()\n\n nsentences = tokens.size(0)\n ntokens = tokens.ne(self.padding_idx).sum().item()\n sample_size = nsentences if self.args.sentence_avg else ntokens\n\n logging_output = {\n 'cider': np.sum(scr_scores) if reduce else scr_scores,\n 'loss': utils.item(loss.data) if reduce else loss.data,\n 'sc_loss': utils.item(sc_loss.data) if reduce else sc_loss.data,\n 'n_positive': n_pos,\n 'ntokens': ntokens,\n 'nsentences': nsentences,\n 'sample_size': sample_size,\n }\n return loss, sample_size, logging_output","def __init__(self, num_class):\n self.sum_hit_at_one = 0.0\n self.sum_perr = 0.0\n self.sum_f1score = 0.0\n self.sum_f2score = 0.0\n self.sum_loss = 0.0\n self.num_examples = 0","def feedforward(self, inputs):\n processsum = 0\n for i in range(len(inputs)):\n processsum = processsum + inputs[i] * self.weights[i]\n return self.activate(processsum)","def forward(self, *args):\r\n _, (hn, _) = self.enc(*args)\r\n\r\n y_pred = self.mlp(hn)\r\n return y_pred","def clf_scores(cm) -> float:\n \n # Number of correct elements of given class - diagonal\n acc = cm.trace()/np.sum(cm)\n \n # Total number of elements with true class j - sum of column j\n # Total number of elements with predicted class i - sum of row i\n precision_class = cm.diagonal()/cm.sum(axis=1)\n recall_class = cm.diagonal()/cm.sum(axis=0)\n f1_class = 2*precision_class*recall_class/(precision_class + recall_class)\n \n return {\n 'accuracy': acc, \n 'precision': precision_class, \n 'recall': recall_class, \n 'F1': f1_class\n }"],"string":"[\n \"def _forward(self, x):\\n # Computing: `x * w^T`\\n score = CArray(x.dot(self.w.T)).todense().ravel() + self.b\\n\\n scores = CArray.ones(shape=(x.shape[0], self.n_classes))\\n scores[:, 0] = -score.ravel().T\\n scores[:, 1] = score.ravel().T\\n\\n return scores\",\n \"def _forward(self, *args, calc_score=False):\\n with chainer.using_config('train', False), chainer.no_backprop_mode():\\n if calc_score:\\n self(*args)\\n return self.y\\n else:\\n if self.predictor is None:\\n print(\\\"[ERROR] predictor is not set or not build yet.\\\")\\n return\\n # TODO: it passes all the args, sometimes (x, y) which is too many arguments.\\n # Consider how to deal with the number of input\\n if hasattr(self.predictor, '_forward'):\\n fn = self.predictor._forward\\n else:\\n fn = self.predictor\\n return fn(*filter_args(fn, args))\",\n \"def compute(self) -> None:\\n \\n self.model.eval()\\n \\n with torch.no_grad():\\n for (input, target, _) in self.loader:\\n\\n # self.model = self.model.train(False) # TEST @lacoupe\\n output, _ = self.model(input)\\n \\n output = (output >= 0.5)\\n \\n for out, tar in zip(output, target):\\n \\n tar = bool(tar)\\n \\n if out and tar:\\n self.confusion['true_positive'] += 1\\n elif not out and not tar:\\n self.confusion['true_negative'] += 1\\n elif out and not tar:\\n self.confusion['false_positive'] += 1\\n elif not out and tar:\\n self.confusion['false_negative'] += 1\\n \\n self.accuracy = (self.confusion['true_positive'] + self.confusion['true_negative']) \\\\\\n / sum(list(self.confusion.values()))\\n \\n if (self.confusion['true_positive'] + self.confusion['false_positive']) == 0.:\\n self.precision = 0.\\n else:\\n self.precision = self.confusion['true_positive'] \\\\\\n / (self.confusion['true_positive'] + self.confusion['false_positive'])\\n \\n if (self.confusion['true_positive'] + self.confusion['false_negative']) == 0.:\\n self.recall = 0.\\n else:\\n self.recall = self.confusion['true_positive'] \\\\\\n / (self.confusion['true_positive'] + self.confusion['false_negative'])\\n \\n if (self.precision + self.recall) == 0.:\\n self.f1_score = 0.\\n else:\\n self.f1_score = 2 * self.precision * self.recall / (self.precision + self.recall)\",\n \"def forward(self, x):\\n # Introspect number of classes from anchors and input shape.\\n num_anchors = len(self.anchors)\\n batch_size, num_predictions, h, w = x.shape\\n num_classes = int(num_predictions / num_anchors) - 5\\n x = x.reshape((batch_size, num_anchors, num_classes + 5, h, w))\\n\\n # Indices 0-3 correspond to xywh energies, index 4 corresponds to\\n # objectness energy, and 5: correspond to class energies.\\n xywh_energy = x[:, :, 0:4, :, :]\\n obj_energy = x[:, :, 4:5, :, :]\\n class_energy = x[:, :, 5:, :, :]\\n\\n bbox_xywh = xywh_energy.clone().detach()\\n\\n # Cell offsets C_x and C_y from original paper.\\n cx = torch.linspace(0, w - 1, w, device=self.device).repeat(h, 1)\\n cy = torch.linspace(\\n 0, h - 1, h, device=self.device\\n ).repeat(w, 1).t().contiguous()\\n\\n # Get bbox center x and y coordinates.\\n bbox_xywh[:, :, 0, :, :].sigmoid_().add_(cx).div_(w)\\n bbox_xywh[:, :, 1, :, :].sigmoid_().add_(cy).div_(h)\\n\\n # Anchor priors (P_w and P_h in original paper).\\n anchors = self.anchors\\n\\n anchor_w = torch.tensor(\\n anchors, device=self.device\\n )[:, 0].reshape(1, num_anchors, 1, 1)\\n\\n anchor_h = torch.tensor(\\n anchors, device=self.device\\n )[:, 1].reshape(1, num_anchors, 1, 1)\\n\\n # Get bbox width and height.\\n bbox_xywh[:, :, 2, :, :].exp_().mul_(anchor_w)\\n bbox_xywh[:, :, 3, :, :].exp_().mul_(anchor_h)\\n\\n # Get objectness and class scores.\\n obj_score = obj_energy.clone().detach().sigmoid()\\n class_score = F.softmax(class_energy.clone().detach(), dim=2)\\n\\n class_prob, class_idx = torch.max(class_score, 2, keepdim=True)\\n class_prob.mul_(obj_score)\\n\\n # Flatten resulting tensors along anchor box and grid cell dimensions;\\n # this makes it easier to combine predictions across scales from other\\n # YOLO layers in Darknet.forward().\\n # `bbox_xywh` -> (batch_size x num_predictions x 4) tensor, where last\\n # dim corresponds to xywh coordinates of prediction.\\n # `class_prob`, `class_idx` -> (batch_size x num_predictions)\\n # tensors, where dim 1 corresponds to the probability and index,\\n # respectively, of the class with the greatest probability.\\n bbox_xywh = bbox_xywh.permute(0, 1, 3, 4, 2).reshape(batch_size, -1, 4)\\n class_prob = class_prob.reshape(batch_size, -1)\\n class_idx = class_idx.reshape(batch_size, -1)\\n\\n return bbox_xywh, class_prob, class_idx\",\n \"def forward_train(self, cls_score, gt_label):\\n if self._do_squeeze:\\n cls_score = cls_score.unsqueeze(0).squeeze()\\n return super().forward_train(cls_score, gt_label)\",\n \"def forward(self, inp):\\n out = self.features(inp)\\n out = out.view(out.size(0), -1) # linearized the output of the module 'features'\\n out = self.classifier(out)\\n return out\",\n \"def forward(self, inputs):\\n raise NotImplementedError\",\n \"def loss(self, X, y=None):\\n W1 = self.params['W1']\\n mode = 'test' if y is None else 'train'\\n\\n # pass conv_param to the forward pass for the convolutional layer\\n filter_size = W1.shape[2]\\n conv_param = {'stride': 1, 'pad': (filter_size - 1) / 2}\\n\\n # pass pool_param to the forward pass for the max-pooling layer\\n pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\\n\\n cache = {}\\n\\n if self.use_batchnorm:\\n for bn_param in self.bn_params:\\n bn_param[mode] = mode\\n\\n scores = None\\n ############################################################################\\n # TODO: Implement the forward pass for the three-layer convolutional net, #\\n # computing the class scores for X and storing them in the scores #\\n # variable. #\\n ############################################################################\\n input = X\\n for l in xrange(1, self.conv_layers + 1):\\n if self.use_batchnorm:\\n W, b, gamma, beta = self.get_params_for_layer(l, get_gamma_beta=True)\\n input, cache['cache%d' % l] = conv_norm_relu_pool_forward(input, W, b, conv_param, pool_param, gamma, beta, self.bn_params[l])\\n else:\\n W, b = self.get_params_for_layer(l)\\n input, cache['cache%d' % l] = conv_relu_pool_forward(input, W, b, conv_param, pool_param)\\n\\n l = self.conv_layers + 1\\n if self.use_batchnorm:\\n W, b, gamma, beta = self.get_params_for_layer(l, get_gamma_beta=True)\\n h_out, h_cache = affine_norm_relu_forward(input, W, b, gamma, beta, self.bn_params[l])\\n else:\\n W, b = self.get_params_for_layer(l)\\n h_out, h_cache = affine_relu_forward(input, W, b)\\n\\n l = l + 1\\n W, b = self.get_params_for_layer(l)\\n scores, scores_cache = affine_forward(h_out, W, b)\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n if y is None:\\n return scores\\n\\n loss, grads = 0, {}\\n ############################################################################\\n # TODO: Implement the backward pass for the three-layer convolutional net, #\\n # storing the loss and gradients in the loss and grads variables. Compute #\\n # data loss using softmax, and make sure that grads[k] holds the gradients #\\n # for self.params[k]. Don't forget to add L2 regularization! #\\n ############################################################################\\n loss, loss_dx = softmax_loss(scores, y)\\n\\n for l in xrange(1, self.num_layers + 1):\\n loss += 0.5 * self.reg * np.sum(self.params['W%d' % l] * self.params['W%d' % l])\\n\\n l = self.num_layers\\n scores_dx, scores_dw, scores_db = affine_backward(loss_dx, scores_cache)\\n self.set_grads(l, grads, scores_dw, scores_db)\\n l = l - 1\\n\\n if self.use_batchnorm:\\n a_dx, a_dw, a_db, a_dgamma, a_dbeta = affine_norm_relu_backward(scores_dx, h_cache)\\n self.set_grads(l, grads, a_dw, a_db, a_dgamma, a_dbeta)\\n else:\\n a_dx, a_dw, a_db = affine_relu_backward(scores_dx, h_cache)\\n self.set_grads(l, grads, a_dw, a_db)\\n l = l - 1\\n\\n conv_layers = l\\n next_input = a_dx\\n for l in xrange(conv_layers, 0, -1):\\n current_cache = cache['cache%d' % l]\\n if self.use_batchnorm:\\n c_dx, c_dw, c_db, c_dgamma, c_dbeta = conv_norm_relu_pool_backward(next_input, current_cache)\\n self.set_grads(l, grads, c_dw, c_db, c_dgamma, c_dbeta)\\n else:\\n c_dx, c_dw, c_db = conv_relu_pool_backward(next_input, current_cache)\\n self.set_grads(l, grads, c_dw, c_db)\\n next_input = c_dx\\n\\n for l in xrange(1, self.conv_layers + 3):\\n grads['W%d' % l] += self.reg * self.params['W%d' % l]\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n return loss, grads\",\n \"def forward(self, *input):\\n \\n item_text, item_img, uidx = input\\n # compute latent codes\\n user_codes = self.user_embdding(uidx)\\n item_img_codes = self.ilatent_img_codes(item_img)\\n item_text_codes = self.ilatent_text_codes(item_text)\\n #ubianry = self.hash(user_codes)\\n #ibinary = [self.hash(h) for h in item_codes]\\n uscore_img = self.uscores(user_codes, item_img_codes)\\n iscore_img = self.iscores(item_img_codes)\\n uscore_text = self.uscores(user_codes, item_text_codes)\\n iscore_text = self.iscores(item_text_codes)\\n score = uscore_img + uscore_text + iscore_img + iscore_text\\n\\n binary = torch.zeros_like(score)#self.scores(ubianry, ibinary).view(-1, 1)\\n return score, binary\",\n \"def forward(self, inp, return_all_scores=False):\\n gate = self.gate(inp)\\n gate_top_k_val, gate_top_k_idx = torch.topk(\\n gate, k=self.top_k, dim=-1, largest=True, sorted=False\\n ) # [.. x top_k]\\n gate_top_k_val = gate_top_k_val.view(-1, self.top_k)\\n\\n # (BxL) x 1 x top_k\\n gate_score = F.softmax(gate_top_k_val, dim=-1)\\n\\n if return_all_scores:\\n return gate_top_k_idx, gate_top_k_val, gate\\n return gate_top_k_idx, gate_top_k_val\",\n \"def loss(self, X, y=None):\\n W1, b1 = self.params['W1'], self.params['b1']\\n W2, b2 = self.params['W2'], self.params['b2']\\n W3, b3 = self.params['W3'], self.params['b3']\\n \\n # pass conv_param to the forward pass for the convolutional layer\\n filter_size = W1.shape[2]\\n conv_param = {'stride': 1, 'pad': (filter_size - 1) / 2}\\n\\n # pass pool_param to the forward pass for the max-pooling layer\\n pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\\n\\n scores = None\\n ############################################################################\\n # TODO: Implement the forward pass for the three-layer convolutional net, #\\n # computing the class scores for X and storing them in the scores #\\n # variable. #\\n ############################################################################\\n \\n N, C, H, W = X.shape;\\n\\n #print 'X shape = ' + str(X.shape);\\n\\n # Get conv layer output. Note that it is not 2-dimensional \\n # conv - relu - 2x2 maxpool\\n v1, cache1 = conv_relu_pool_forward(X, W1, b1, conv_param, pool_param);\\n\\n #print 'v1 shape = ' + str(v1.shape);\\n\\n # Reshape to 2D\\n v1shape = v1.shape; # Used to reshape back to original form in backward pass\\n v1 = np.reshape(v1,(N,-1));\\n #print 'v1 shape = ' + str(v1.shape);\\n\\n # Feed forward to hidden layer (affine-relu)\\n v2, cache2 = affine_relu_forward(v1, W2, b2);\\n #print 'v2 shape = ' + str(v2.shape);\\n\\n # Feed forward to final layer (affine only)\\n v3, cache3 = affine_forward(v2, W3, b3)\\n #print 'v3 shape = ' + str(v3.shape);\\n\\n # Compute scores\\n scores = v3;\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n if y is None:\\n return scores\\n \\n loss, grads = 0, {}\\n ############################################################################\\n # TODO: Implement the backward pass for the three-layer convolutional net, #\\n # storing the loss and gradients in the loss and grads variables. Compute #\\n # data loss using softmax, and make sure that grads[k] holds the gradients #\\n # for self.params[k]. Don't forget to add L2 regularization! #\\n ############################################################################\\n \\n # Calculate softmax loss from layer 2 output\\n # Loss gets regularized here\\n # Each separate gradient must be regularized later when calculated\\n loss, dv3 = softmax_loss(scores,y); # Softmax loss and gradient\\n #print 'dv3 shape = ' + str(dv3.shape);\\n reg = self.reg;\\n loss += 0.5 * reg * (np.sum(W1*W1) + np.sum(W2*W2) + np.sum(W3*W3)); # Regularize\\n\\n # Do backward pass through layer 2 affine\\n dv2, dw3, db3 = affine_backward(dv3, cache3);\\n dw3 += reg*W3; # Regularize\\n #print 'dv2 shape = ' + str(dv2.shape);\\n\\n\\n # Backward pass through hidden layer\\n dv1, dw2, db2 = affine_relu_backward(dv2, cache2);\\n dw2 += reg*W2; # Regularize\\n #print 'dv1 shape = ' + str(dv1.shape);\\n\\n # Reshape dv1 to be compatible with convolutional layer\\n dv1 = np.reshape(dv1,v1shape);\\n #print 'dv1 shape = ' + str(dv1.shape);\\n\\n # Do backward pass through convolutional layer\\n dx, dw1, db1 = conv_relu_pool_backward(dv1, cache1);\\n dw1 += reg*W1; # Regularize\\n\\n # Store all weight and bias gradients in grads\\n grads['W1'] = dw1; grads['b1'] = db1;\\n grads['W2'] = dw2; grads['b2'] = db2;\\n grads['W3'] = dw3; grads['b3'] = db3;\\n\\n\\n\\n\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n return loss, grads\",\n \"def forward(self, x):\\n batch_size = x.shape[0]\\n expected_shape = (batch_size, self.num_classes)\\n\\n out = self.feature_extractor(x)\\n out = torch.flatten(out, 1)\\n out = self.classifier(out)\\n\\n assert out.shape == (batch_size, self.num_classes),\\\\\\n f\\\"Expected output of forward pass to be: {expected_shape}, but got: {out.shape}\\\"\\n return out\",\n \"def forward(self, x):\\n batch_size = x.shape[0]\\n expected_shape = (batch_size, self.num_classes)\\n\\n out = self.feature_extractor(x)\\n out = torch.flatten(out, 1)\\n out = self.classifier(out)\\n\\n assert out.shape == (batch_size, self.num_classes),\\\\\\n f\\\"Expected output of forward pass to be: {expected_shape}, but got: {out.shape}\\\"\\n return out\",\n \"def forward(self, x):\\n out = self.conv(x)\\n out = out.view(out.size(0), -1)\\n\\n # critic\\n out1 = self.fc1(out)\\n\\n # auxiliary classifier\\n out2 = self.fc10(out)\\n\\n return out1, out2\",\n \"def forward(self, pred, gt, weight=None):\\n num_pos = torch.relu(torch.sum(gt) - 1) + 1\\n num_neg = torch.relu(torch.sum(1 - gt) - 1) + 1\\n if weight is not None:\\n loss = nn.BCEWithLogitsLoss(reduction='none')(pred, gt.float())\\n loss = torch.mean(loss * weight)\\n elif self.balanced is False:\\n loss = nn.BCEWithLogitsLoss(reduction='mean')(pred, gt.float())\\n else:\\n loss = nn.BCEWithLogitsLoss(pos_weight=num_neg * 1.0 / num_pos, reduction='mean')(pred, gt.float())\\n\\n # compute precision, recall, f1\\n pred_labels = pred > 0\\n gt, pred_labels, pred = gt.detach().cpu().numpy(), pred_labels.detach().cpu().numpy(), pred.detach().cpu().numpy()\\n precision = precision_score(gt[0], pred_labels[0])\\n recall = recall_score(gt[0], pred_labels[0])\\n f1 = f1_score(gt[0], pred_labels[0])\\n mean_logit_true = np.sum(pred * gt) / max(1, np.sum(gt))\\n mean_logit_false = np.sum(pred * (1 - gt)) / max(1, np.sum(1 - gt))\\n\\n eval_stats = {\\n \\\"loss\\\": loss,\\n \\\"precision\\\": float(precision),\\n \\\"recall\\\": float(recall),\\n \\\"f1\\\": float(f1),\\n \\\"logit_true\\\": float(mean_logit_true),\\n \\\"logit_false\\\": float(mean_logit_false)\\n }\\n return eval_stats\",\n \"def _forward(self, subj_embs, obj_embs, subj_feats, pred_feats, obj_feats):\\n visual = torch.cat((\\n self.fc_subject(subj_feats),\\n self.fc_predicate(pred_feats),\\n self.fc_object(obj_feats)\\n ), dim=1)\\n features = self.fc_projector(visual)\\n classifiers = self.get_classifiers(subj_embs, obj_embs)\\n scores = F.cosine_similarity(classifiers, features.unsqueeze(1), dim=2)\\n scores_bin = self.fc_classifier_bin(visual)\\n if self.mode == 'test':\\n scores = self.softmax(5 * scores)\\n scores_bin = self.softmax(scores_bin)\\n return scores, scores_bin, classifiers\",\n \"def score(self, data):\\n\\n score_mappings = {\\n \\\"0\\\": np.log(self.class_zero_doc_count / self.total_docs),\\n \\\"1\\\": np.log(self.class_one_doc_count / self.total_docs)\\n }\\n\\n features = self.featurize(data)\\n\\n for f in features:\\n\\n if(f[0] in self.class_zero):\\n cond_prob_zero = np.log((self.class_zero[f[0]] + 1) / (self.class_zero_feature_count + len(self.vocab)))\\n elif(f[0] in self.vocab):\\n cond_prob_zero = np.log(1 / (self.class_zero_feature_count + len(self.vocab)))\\n else:\\n cond_prob_zero = 0\\n\\n if(f[0] in self.class_one):\\n cond_prob_one = np.log((self.class_one[f[0]] + 1) / (self.class_one_feature_count + len(self.vocab)))\\n elif(f[0] in self.vocab):\\n cond_prob_one = np.log(1 / (self.class_one_feature_count + len(self.vocab)))\\n else:\\n cond_prob_one = 0\\n\\n score_mappings[\\\"0\\\"] += cond_prob_zero\\n score_mappings[\\\"1\\\"] += cond_prob_one\\n\\n score_mappings[\\\"0\\\"] = np.exp(score_mappings[\\\"0\\\"])\\n score_mappings[\\\"1\\\"] = np.exp(score_mappings[\\\"1\\\"])\\n\\n return score_mappings\",\n \"def forward(self, inputs):\\r\\n #print (len(inputs))\\r\\n out = self.fc1(inputs)\\r\\n out = self.fc2(out)\\r\\n self.out = out\\r\\n return out\\r\\n #raise NotImplementedError('Implement the forward method of the model')\\r\",\n \"def forward(self, x):\\n out = self.features(x)\\n out = self.avgpool(out)\\n out = torch.flatten(out, 1)\\n out = self.classifier(out)\\n return out\",\n \"def forward(self, x):\\n out = self.features(x)\\n out = self.avgpool(out)\\n out = torch.flatten(out, 1)\\n out = self.classifier(out)\\n return out\",\n \"def forward(ctx, scores):\\n size = scores.size()\\n prob = F.softmax(scores, dim=-1)\\n idx = multinomial(prob.view(-1, size[-1]), num_samples=1, replacement=False).view(size[:-1])\\n scores_net = eye(scores.size(-1), device=scores.device)\\n return scores_net[idx]\",\n \"def get_scores(self):\\n hist = self.confusion_matrix\\n # hist = [TN,FP;FN,TP]\\n acc = np.diag(hist).sum() / hist.sum()\\n acc_cls = np.diag(hist) / hist.sum(axis=1)\\n acc_cls = np.nanmean(acc_cls)\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\\n # iou = iu.sum() / self.n_classes\\n mean_iou = np.nanmean(iu) # if classes = 2: iou = miou\\n freq = hist.sum(axis=1) / hist.sum()\\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\\n cls_iou = dict(zip(range(self.n_classes), iu))\\n\\n ##############################################\\n tn = hist[0, 0]\\n tp = np.diag(hist).sum() - tn\\n fp = np.triu(hist, 1).sum()\\n fn = np.tril(hist, -1).sum()\\n precision = tp / (tp + fp)\\n recall = tp / (tp + fn)\\n f1 = 2 * precision * recall / (precision + recall)\\n\\n # for medical img, img_seg \\\\in [0,1]\\n dice = 2 * tp / (tp + tp + fn + fp)\\n # dice = f1-score\\n dsc = 2 * tp / (tp + fn + fp)\\n # dsc = jaccard\\n # voe = 2 * abs(fp + fn) / (tp + tp + fn + fp)\\n # voe = 1 - dsc\\n\\n k2 = {\\n # \\\"Overall Acc: \\\\t\\\": acc,\\n 'Mean Acc': float(judge_nan(acc_cls)),\\n # \\\"FreqW Acc : \\\\t\\\": fwavacc,\\n 'Mean IoU': float(judge_nan(mean_iou)),\\n 'F1-score': float(judge_nan(f1)),\\n 'DSC': float(judge_nan(dsc)),\\n 'Precision': float(judge_nan(precision)),\\n 'Recall': float(judge_nan(recall)),\\n }\\n\\n return k2\",\n \"def forward(self, X, training=False):\\n pass\",\n \"def accuracy(self, data, class_loss_scores=False):\\n predicts = [self.feedforward(xy[0].T) for xy in data]\\n refs = [xy[1].T for xy in data]\\n if class_loss_scores:\\n # TODO NOTE that class loss function indicate an error not positive label,\\n # loss function inverse scores\\n predicts = [1.0 - self.cost.class_loss_scores(s) for s in predicts]\\n # threshold network score\\n pred_labs = [cf.step(x, self.threshold) for x in predicts]\\n return metrics.micro_f1(refs, pred_labs, False)\",\n \"def forward(self, input):\\n raise NotImplementedError\",\n \"def forward(self, input):\\n raise NotImplementedError\",\n \"def forward_train(self, *args, **kwargs):\\n pass\",\n \"def forward(self, inputs):\\n _, state = self.core(inputs)\\n return state\",\n \"def forward(self, input):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n assert input.shape[1] == self.n_neurons, \\\"The shape of the input tensor is not correct.\\\"\\n\\n bn_fct = CustomBatchNormManualFunction()\\n out = bn_fct.apply(input, self.gamma, self.beta, self.eps)\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return out\",\n \"def forward(self, inp):\\n if self.mode=='pre':\\n return self.pretrain_forward(inp)\\n elif self.mode=='meta':\\n data_shot, label_shot, data_query, val = inp\\n return self.meta_forward(data_shot, label_shot, data_query, val)\\n elif self.mode=='preval':\\n data_shot, label_shot, data_query = inp\\n return self.preval_forward(data_shot, label_shot, data_query)\\n else:\\n raise ValueError('Please set the correct mode.')\",\n \"def loss(self, X, y=None):\\n W1, b1 = self.params['W1'], self.params['b1']\\n W2, b2 = self.params['W2'], self.params['b2']\\n W3, b3 = self.params['W3'], self.params['b3']\\n \\n # pass conv_param to the forward pass for the convolutional layer\\n filter_size = W1.shape[2]\\n conv_param = {'stride': 1, 'pad': (filter_size - 1) / 2}\\n\\n # pass pool_param to the forward pass for the max-pooling layer\\n pool_param = {'pool_height': 2, 'pool_width': 2, 'stride': 2}\\n\\n ############################################################################\\n # TODO: Implement the forward pass for the three-layer convolutional net, #\\n # computing the class scores for X and storing them in the scores #\\n # variable. #\\n ############################################################################\\n \\n scores = None \\n cache = {}\\n # def conv_relu_pool_forward(x, w, b, conv_param, pool_param): return out, cache;\\n out, cache['layer1'] = layer_utils.conv_relu_pool_forward(X, W1, b1, conv_param, pool_param) \\n # def affine_relu_forward(x, w, b): return out, cache;\\n out, cache['layer2'] = layer_utils.affine_relu_forward(out, W2, b2)\\n # def affine_forward(x, w, b): return out, cache;\\n scores, cache['layer3'] = layers.affine_forward(out, W3, b3)\\n\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n if y is None:\\n return scores\\n \\n ############################################################################\\n # TODO: Implement the backward pass for the three-layer convolutional net, #\\n # storing the loss and gradients in the loss and grads variables. Compute #\\n # data loss using softmax, and make sure that grads[k] holds the gradients #\\n # for self.params[k]. Don't forget to add L2 regularization! #\\n ############################################################################\\n \\n loss, grads = 0, {}\\n\\n # def softmax_loss(x, y): return loss, dscore;\\n loss, dscores = layers.softmax_loss(scores, y)\\n loss += 0.5 * self.reg * (np.sum(W1 * W1) + np.sum(W2 * W2) + np.sum(W3 * W3))\\n\\n # def affine_backward(dout, cache): return dx, dw, db;\\n dout, dW3, db3 = layers.affine_backward(dscores, cache['layer3']) \\n # def affine_relu_backward(dout, cache): return dx, dw, db;\\n dout, dW2, db2 = layer_utils.affine_relu_backward(dout, cache['layer2'])\\n # def conv_relu_pool_backward(dout, cache): return dx, dw, db;\\n dout, dW1, db1 = layer_utils.conv_relu_pool_backward(dout, cache['layer1'])\\n\\n # reg\\n grads['W3'], grads['b3'] = dW3 + self.reg * W3, db3\\n grads['W2'], grads['b2'] = dW2 + self.reg * W2, db2\\n grads['W1'], grads['b1'] = dW1 + self.reg * W1, db1\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n return loss, grads\",\n \"def forwardPass(self, inputs):\\n #############################################################################\\n # TODO: Implement the forward phase of the model. It has two hidden layers \\n # and the output layer. The activation function of the two hidden layers is \\n # sigmoid function. The output layer activation function is the softmax function\\n # because we are working with multi-class classification. \\n #############################################################################\\n\\n # layer 1 \\n # compute the forward pass on the first hidden layer with the sigmoid function\\n\\n self.hidden1 = np.dot(inputs, self.weights1) #(9000, 785) (785, 5)\\n # self.hidden1 = self.sigmoid_fun(self.hidden1) #(9000, 5)\\n self.hidden1 = 1.0 / (1.0 + np.exp(-self.beta*self.hidden1))\\n self.hidden1 = np.concatenate((self.hidden1, -np.ones((np.shape(inputs)[0], 1))), axis=1) # (9000,6)\\n\\n\\n # layer 2\\n # compute the forward pass on the second hidden layer with the sigmoid function\\n self.hidden2 = np.dot(self.hidden1, self.weights2) # (9000,6) (6, 5)\\n self.hidden2 = self.sigmoid_fun(self.hidden2) # (9000,5)\\n self.hidden2 = np.concatenate((self.hidden2, -np.ones((np.shape(self.hidden1)[0], 1))), axis=1) # (9000,6)\\n\\n # output layer\\n # compute the forward pass on the output layer with softmax function\\n outputs = np.dot(self.hidden2, self.weights3) # (9000,6) (6, 10)\\n normalisers = np.sum(np.exp(outputs), axis=1)*np.ones((1, np.shape(outputs)[0]))\\n outputs = np.transpose(np.transpose(np.exp(outputs)) / normalisers)\\n # outputs = self.softmax_fun(outputs) # (9000,10)\\n # print(outputs)\\n #############################################################################\\n # END of YOUR CODE \\n #############################################################################\\n return outputs\",\n \"def forward(self, inp):\\n if self.mode=='train':\\n return self.pretrain_forward(inp)\\n elif self.mode=='meta':\\n data_shot, label_shot, data_query = inp\\n return self.meta_forward(data_shot, label_shot, data_query)\\n elif self.mode=='val':\\n data_shot, label_shot, data_query = inp\\n return self.preval_forward(data_shot, label_shot, data_query)\\n else:\\n raise ValueError('Please set the correct mode.')\",\n \"def preval_forward(self, data_shot, label_shot, data_query):\\n embedding_query = self.encoder(data_query)\\n embedding_shot = self.encoder(data_shot)\\n logits = self.base_learner(embedding_shot)\\n #loss = self.FL(logits, label_shot) + self.CD(logits,label_shot) + self.LS(logits,label_shot)\\n loss = self.CD(logits,label_shot)\\n grad = torch.autograd.grad(loss, self.base_learner.parameters())\\n fast_weights = list(map(lambda p: p[1] - 0.01 * p[0], zip(grad, self.base_learner.parameters())))\\n logits_q = self.base_learner(embedding_query, fast_weights)\\n\\n for _ in range(1, 100):\\n logits = self.base_learner(embedding_shot, fast_weights)\\n #loss = self.FL(logits, label_shot) + self.CD(logits,label_shot) + self.LS(logits,label_shot)\\n loss = self.CD(logits,label_shot)\\n grad = torch.autograd.grad(loss, fast_weights)\\n fast_weights = list(map(lambda p: p[1] - 0.01 * p[0], zip(grad, fast_weights)))\\n logits_q = self.base_learner(embedding_query, fast_weights) \\n return logits_q\",\n \"def forward(self, *inputs):\\n raise NotImplementedError\",\n \"def forward_single(self, x, scale):\\n cls_feat = x\\n reg_feat = x\\n for cls_conv in self.cls_convs:\\n cls_feat = cls_conv(cls_feat)\\n for reg_conv in self.reg_convs:\\n reg_feat = reg_conv(reg_feat)\\n cls_score = self.atss_cls(cls_feat)\\n # we just follow atss, not apply exp in bbox_pred\\n bbox_pred = scale(self.atss_reg(reg_feat)).float()\\n iou_pred = self.atss_iou(reg_feat)\\n return cls_score, bbox_pred, iou_pred\",\n \"def forward(self, x):\\n out = self.features(x)\\n out = out.view(out.size(0), -1)\\n out = self.classifier(out)\\n return out\",\n \"def forward(self, outputs):\\n if isinstance(outputs, (tuple, list)):\\n adv_loss = 0.0\\n for i, outputs_ in enumerate(outputs):\\n if isinstance(outputs_, (tuple, list)):\\n # case including feature maps\\n outputs_ = outputs_[-1]\\n adv_loss += self.criterion(outputs_)\\n if self.average_by_discriminators:\\n adv_loss /= i + 1\\n else:\\n adv_loss = self.criterion(outputs)\\n\\n return adv_loss\",\n \"def forward(self, input):\\n raise NotImplementedError()\",\n \"def forward(self, x):\\n # pylint: disable=arguments-differ\\n x = x.permute([0, 3, 1, 2, ])\\n x = self.power(x * 0.00392156885937 + 0.0, 1.0)\\n cat = self.conv1(x)\\n x = self.conv2(cat)\\n x = self.concat8((cat, x), 1)\\n conv_final = self.conv3(x)\\n conv_final_permute = conv_final.permute([0, 2, 3, 1])\\n loc_pred, obj_pred, cls_pred = torch.split(conv_final_permute, [64, 16, 64], 3)\\n # obj_perm = self.obj_pred(obj_perm) # sigmoid might lead to gradient losing.\\n #cls_reshape = torch.reshape(cls_perm, (-1, 4))\\n #cls_pred_prob = self.cls_pred_prob(cls_reshape)\\n #cls_pred = torch.reshape(cls_pred_prob, cls_perm.shape)\\n return obj_pred, cls_pred, loc_pred\",\n \"def forward(self, input_tokens, prev_scores, timestep, *inputs, src_tuple=None):\\n input_tokens = input_tokens.unsqueeze(1)\\n log_probs_per_model, attn_weights_per_model, state_outputs, beam_axis_per_state, possible_translation_tokens = self._get_decoder_outputs(input_tokens, prev_scores, timestep, *inputs, src_tuple=src_tuple)\\n average_log_probs = torch.mean(torch.cat(log_probs_per_model, dim=1), dim=1, keepdim=True)\\n if possible_translation_tokens is None:\\n word_rewards = self.word_rewards\\n else:\\n word_rewards = self.word_rewards.index_select(0, possible_translation_tokens)\\n word_rewards = word_rewards.unsqueeze(dim=0).unsqueeze(dim=0)\\n average_log_probs_with_rewards = average_log_probs + word_rewards\\n average_attn_weights = torch.mean(torch.cat(attn_weights_per_model, dim=1), dim=1, keepdim=True)\\n best_scores_k_by_k, best_tokens_k_by_k = torch.topk(average_log_probs_with_rewards.squeeze(1), k=self.beam_size)\\n prev_scores_k_by_k = prev_scores.view(-1, 1).expand(-1, self.beam_size)\\n total_scores_k_by_k = best_scores_k_by_k + prev_scores_k_by_k\\n total_scores_flat = total_scores_k_by_k.view(-1)\\n best_tokens_flat = best_tokens_k_by_k.view(-1)\\n best_scores, best_indices = torch.topk(total_scores_flat, k=self.beam_size)\\n best_tokens = best_tokens_flat.index_select(dim=0, index=best_indices).view(-1)\\n prev_hypos = best_indices // self.beam_size\\n attention_weights = average_attn_weights.index_select(dim=0, index=prev_hypos)\\n if possible_translation_tokens is not None:\\n best_tokens = possible_translation_tokens.index_select(dim=0, index=best_tokens)\\n self.input_names = ['prev_tokens', 'prev_scores', 'timestep']\\n for i in range(len(self.models)):\\n self.input_names.append(f'fixed_input_{i}')\\n if possible_translation_tokens is not None:\\n self.input_names.append('possible_translation_tokens')\\n attention_weights = attention_weights.squeeze(1)\\n outputs = [best_tokens, best_scores, prev_hypos, attention_weights]\\n self.output_names = ['best_tokens_indices', 'best_scores', 'prev_hypos_indices', 'attention_weights_average']\\n for i in range(len(self.models)):\\n self.output_names.append(f'fixed_input_{i}')\\n if self.tile_internal:\\n outputs.append(inputs[i].repeat(1, self.beam_size, 1))\\n else:\\n outputs.append(inputs[i])\\n if possible_translation_tokens is not None:\\n self.output_names.append('possible_translation_tokens')\\n outputs.append(possible_translation_tokens)\\n for i, state in enumerate(state_outputs):\\n beam_axis = beam_axis_per_state[i]\\n if beam_axis is None:\\n next_state = state\\n else:\\n next_state = state.index_select(dim=beam_axis, index=prev_hypos)\\n outputs.append(next_state)\\n self.output_names.append(f'state_output_{i}')\\n self.input_names.append(f'state_input_{i}')\\n return tuple(outputs)\",\n \"def forward(self, x):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n\\n x = self.pool1(F.relu(self.batch1(self.conv1(x))))\\n x = self.pool2(F.relu(self.batch2(self.conv2(x))))\\n x = F.relu(self.batch3a(self.conv3a(x)))\\n x = self.pool3(F.relu(self.batch3b(self.conv3b(x))))\\n x = F.relu(self.batch4a(self.conv4a(x)))\\n x = self.pool4(F.relu(self.batch4b(self.conv4b(x))))\\n x = F.relu(self.batch5a(self.conv5a(x)))\\n x = self.pool5(F.relu(self.batch5b(self.conv5b(x))))\\n x = self.avgpool(x)\\n x = x.reshape(x.shape[0], -1)\\n out = self.fc1(x)\\n\\n# raise NotImplementedError\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return out\",\n \"def fwd_pass( self, X, ls_emb, sp_emb, y, optimizer, loss_function, train=False, report=True):\\n if train:\\n self.zero_grad()\\n outputs = self(X, ls_emb, sp_emb)\\n loss = loss_function(outputs, y)\\n\\n if train:\\n loss.backward()\\n optimizer.step()\\n\\n if report:\\n tp = 0\\n tn = 0\\n fn = 0\\n fp = 0\\n for i,j in zip(outputs, y):\\n if torch.argmax(i) == torch.argmax(j):\\n if j.data.cpu().numpy()[0] == 1: #positive instance\\n tp += 1\\n else: \\n tn += 1\\n else:\\n if j.data.cpu().numpy()[0] == 1:\\n fn += 1\\n else:\\n fp += 1\\n\\n #matches = [torch.argmax(i) == torch.argmax(j) for i,j in zip(outputs, y)]\\n acc = (tp+tn)/(tp+tn+fp+fn)\\n conf = [tp, fp, fn, tn]\\n return acc, loss, conf\\n else:\\n return None,None\",\n \"def scoring(self):\\n pass\",\n \"def forward_propagation(self):\\n pred_y = argmax(self.model.predict(train_x), axis=1)\\n\\n accuracy_func = Accuracy()\\n accuracy_func.update_state(pred_y, train_y)\\n self.accuracy = accuracy_func.result().numpy()\",\n \"def forward(self, X):\\n features = self.get_conv_feats(X)\\n prediction = blah\\n return (prediction)\",\n \"def f1_score_model(self, model, X, y):\\n\\n prediction = model.predict_classes(X)\\n f1_macro = f1_score(y, prediction, average='macro')\\n f1_micro = f1_score(y, prediction, average='macro')\\n print(\\\"f1_macro: \\\", f1_score(y, prediction, average='macro'))\\n print(\\\"f1_micro: \\\", f1_score(y, prediction, average=\\\"micro\\\"))\\n print(\\\"f1_weighted: \\\", f1_score(y, prediction, average=\\\"weighted\\\"))\\n return f1_macro, f1_micro\",\n \"def cvWorker(epochs, theta, folds, trainFunc, testFunc, report, queue):\\n\\n # track how many correct predictions are made over all folds with current hyperparams\\n totalCorrect = 0;\\n totalAttempts = 0;\\n for (i,f) in enumerate(folds): \\n \\n testFold = f;\\n trainFold = reduce(operator.add, folds[:i] + folds[i+1:]); # flatten training fold \\n \\n # learn weights \\n w = trainFunc(trainFold, epochs, theta);\\n \\n # accumulate test accuracy\\n [correct, attempts] = testFunc(w, testFold);\\n totalCorrect += correct;\\n totalAttempts += attempts; \\n \\n # update based on results and post to queue\\n rate = totalCorrect / totalAttempts;\\n if not (report == None):\\n tabs = '\\\\t' * report;\\n print tabs, 'Cross validation accuracy=', rate, 'for theta=', theta;\\n results = (theta, rate); \\n queue.put(results)\\n \\n return;\",\n \"def forward_single(self, x):\\n cls_feat = x\\n reg_feat = x\\n for cls_conv in self.cls_convs:\\n cls_feat = cls_conv(cls_feat)\\n for reg_conv in self.reg_convs:\\n reg_feat = reg_conv(reg_feat)\\n cls_score = self.retina_cls(cls_feat)\\n bbox_pred = self.retina_reg(reg_feat)\\n return cls_score, bbox_pred\",\n \"def predict(self, X):\\r\\n \\r\\n # To speed up, we apply the scoring function to all the instances\\r\\n # at the same time.\\r\\n scores = X.dot(self.w)\\r\\n \\r\\n # Create the output array.\\r\\n # At the positions where the score is positive, this will contain\\r\\n # self.positive class, otherwise self.negative_class.\\r\\n out = numpy.select([scores>=0.0, scores<0.0], [self.positive_class, \\r\\n self.negative_class])\\r\\n return out\",\n \"def score(self, X, y):\\r\\n n_feature, _ = self.check_model()\\r\\n _, n_label = y.shape\\r\\n y = self.check_X_y_weights(X, y)\\r\\n\\r\\n if X.shape[1] == (n_feature + 1):\\r\\n X = X[:, 1:]\\r\\n\\r\\n assert (X.shape[1] == n_feature), \\\"X is of the wrong shape\\\"\\r\\n\\r\\n if self.scoring_func is None:\\r\\n y_pred = self.forward(X)\\r\\n\\r\\n loss = self.loss_func(torch.from_numpy(y_pred).float(),\\r\\n torch.from_numpy(y).float())\\r\\n loss = torch.mean(torch.sum(loss, 1)).numpy()\\r\\n\\r\\n return - loss\\r\\n else:\\r\\n y_pred = self.predict(X)\\r\\n return self.scoring_func(y_pred, y)\",\n \"def forward(self, inputs, target_oneHot):\\n\\n N = inputs.size()[0]\\n\\n # predicted probabilities for each pixel along channel\\n inputs = F.softmax(inputs, dim=1)\\n\\n # Numerator Product\\n inter = inputs * target_oneHot\\n # Sum over all pixels N x C x H x W => N x C\\n inter = inter.view(N, self.classes, -1).sum(2)\\n\\n # Denominator\\n union = inputs + target_oneHot - (inputs * target_oneHot)\\n # Sum over all pixels N x C x H x W => N x C\\n union = union.view(N, self.classes, -1).sum(2)\\n\\n loss = inter / union\\n\\n ## Return average loss over classes and batch\\n # return 1 - loss.mean()\\n return -(loss.mean() - 1.)\",\n \"def classification_score(self, x, y):\\t\\n\\t\\tpass\",\n \"def f1_score(self):\\n self.overall_f1_score = f1_score(\\n self.y_true, self.y_pred, average = self.average_type).round(self.digits_count_fp)\\n self.classes_f1_score = f1_score(\\n self.y_true, self.y_pred, average = None).round(self.digits_count_fp)\",\n \"def pre_step(x, y):\\r\\n feed_dict = {\\r\\n cnn.input_x: x,\\r\\n cnn.input_y: y,\\r\\n cnn.dropout_keep_prob: 1.0\\r\\n }\\r\\n scores = sess.run([cnn.scores], feed_dict)\\r\\n return scores\",\n \"def forward(self, y_pred, y_true):\\n if not isinstance(y_true, Tensor):\\n y_true = y_true.class_id\\n if not isinstance(y_pred, Tensor):\\n y_pred = y_pred.class_id\\n\\n pred_class = y_pred.argmax(dim=self.axis)\\n true_class = y_true.long()\\n correct_predictions = pred_class == true_class\\n loss = correct_predictions.float().mean(dim=self.axis)\\n if self.reduction == \\\"none\\\":\\n return loss\\n elif self.reduction == \\\"sum\\\":\\n return loss.sum()\\n elif self.reduction == \\\"mean\\\":\\n return loss.mean()\",\n \"def __call__(\\n self,\\n batch: PredictionBatch,\\n target: Target,\\n scores: torch.FloatTensor,\\n ) -> None:\\n raise NotImplementedError\",\n \"def forward(self, x: torch.Tensor) -> tuple:\\n \\n x_range_view = x[:, 2:]\\n \\n dla_out = self.dla(x_range_view)\\n\\n class_preds = self.classes(dla_out)\\n\\n return class_preds\",\n \"def forward(self, x, y):\\n x1 = x.clone()\\n x1[range(x1.size(0)), y] = -float(\\\"Inf\\\")\\n x_gt = x[range(x.size(0)), y].unsqueeze(1)\\n x_topk = torch.topk(x1, 15, dim=1)[0] # 15 Negative classes to focus on, its a hyperparameter\\n x_new = torch.cat([x_gt, x_topk], dim=1)\\n\\n return self.ce(x_new, torch.zeros(x_new.size(0)).cuda().long())\",\n \"def preval_forward(self, data_shot, label_shot, data_query):\\n embedding_query = self.encoder(data_query)\\n embedding_shot = self.encoder(data_shot)\\n logits = self.base_learner(embedding_shot)\\n loss = F.cross_entropy(logits, label_shot)\\n grad = torch.autograd.grad(loss, self.base_learner.parameters())\\n fast_weights = list(map(lambda p: p[1] - 0.01 * p[0], zip(grad, self.base_learner.parameters())))\\n logits_q = self.base_learner(embedding_query, fast_weights)\\n\\n for _ in range(1, 100):\\n logits = self.base_learner(embedding_shot, fast_weights)\\n loss = F.cross_entropy(logits, label_shot)\\n grad = torch.autograd.grad(loss, fast_weights)\\n fast_weights = list(map(lambda p: p[1] - 0.01 * p[0], zip(grad, fast_weights)))\\n logits_q = self.base_learner(embedding_query, fast_weights) \\n return logits_q\",\n \"def _forward(self, inputs):\\n if is_tf_available():\\n # TODO trace model\\n predictions = self.model(inputs)[0]\\n else:\\n import torch\\n with torch.no_grad():\\n predictions = self.model(**inputs)[0]\\n\\n return predictions.numpy()\",\n \"def forward(self, inputs):\\n coords = inputs['point'].to(self.device)\\n feat = inputs['feat'].to(self.device)\\n\\n out_features_list = []\\n for i in range(len(self.point_features)):\\n feat, _ = self.point_features[i]((feat, coords))\\n out_features_list.append(feat)\\n # feat: num_batches * 1024 * num_points -> num_batches * 1024 -> num_batches * 128\\n feat = self.cloud_features(feat.max(dim=-1, keepdim=False).values)\\n out_features_list.append(\\n feat.unsqueeze(-1).repeat([1, 1, coords.size(-1)]))\\n out = self.classifier(torch.cat(out_features_list, dim=1))\\n return out.transpose(1, 2)\",\n \"def feed_forward(self, inputs):\\n raise NotImplementedError()\",\n \"def forward(self, inputs, hx):\\n output_size = 2 * self._num_units\\n if self._use_gc_for_ru:\\n fn = self._gconv\\n else:\\n fn = self._fc\\n value = torch.sigmoid(fn(inputs, hx, output_size, bias_start=1.0))\\n value = torch.reshape(value, (-1, self._num_nodes, output_size))\\n r, u = torch.split(tensor=value, split_size_or_sections=self._num_units, dim=-1)\\n r = torch.reshape(r, (-1, self._num_nodes * self._num_units))\\n u = torch.reshape(u, (-1, self._num_nodes * self._num_units))\\n\\n c = self._gconv(inputs, r * hx, self._num_units)\\n if self._activation is not None:\\n c = self._activation(c)\\n\\n new_state = u * hx + (1.0 - u) * c\\n return new_state\",\n \"def _feed_forward(self, X):\\n # Add code to calculate a1 and probs\\n z1 = X.dot(self.Wxh) + self.bh\\n a1 = np.tanh(z1)\\n z2 = a1.dot(self.Why) + self.by\\n exp_scores = np.exp(z2)\\n probs = exp_scores/np.sum(exp_scores, axis=1, keepdims=True)\\n return a1, probs\",\n \"def scores(model,X_train,y_train, X_test,y_test,inside):\\r\\n \\r\\n model.best_apply(X_test,y_test)\\r\\n y_pred = model.forward(X_test).cpu()\\r\\n y_pred = np.asarray(torch.argmax(y_pred, dim = 1).squeeze())\\r\\n y_test_ = np.asarray(torch.argmax(y_test.cpu(), dim = 1))\\r\\n acc1 = accuracy_score(y_test_,y_pred)\\r\\n model.best_apply(X_train,y_train)\\r\\n y_pred = model.forward(X_train).cpu()\\r\\n y_pred = np.asarray(torch.argmax(y_pred, dim = 1).squeeze())\\r\\n y_train_ = np.asarray(torch.argmax(y_train.cpu(), dim = 1))\\r\\n acc2 = accuracy_score(y_train_,y_pred)\\r\\n if inside :\\r\\n print(\\\"###### Results ##########\\\")\\r\\n print(\\\"The Validation Acuuracy is : \\\",acc1)\\r\\n print(\\\"The Training Acuuracy is : \\\",acc2)\\r\\n return [acc1,acc2]\",\n \"def train(self, dataset): \\n dataset = dataset[dataset[:,-1].argsort()] # Sort the dataset by classes.\\n #print dataset\\n \\n ########\\n # Compute p(y=1) for all ys.\\n ########\\n label_counts = np.bincount(dataset[:,-1]) # Get the number of occurrences of each class, sorted. \\n self.p_ys = np.log(label_counts * 1.0 / len(dataset)) # Compute probs. \\n \\n ########\\n # Compute p(x|y) for all x,y.\\n ########\\n self.feature_count = len(dataset[0]) - 1 \\n self.class_count = len(label_counts)\\n \\n self.p_xi_given_ys = np.zeros((self.class_count, self.feature_count)) # Initialize matrix\\n start_index = 0\\n for i in range(self.class_count): # Loop over each class \\n end_index = start_index + label_counts[i] # end of this class index \\n class_word_counts = np.sum(dataset[start_index:end_index,:-1]) # sum all words of class i \\n denominator = class_word_counts + self.alpha * self.feature_count # Here we add the feature_count as Laplace smoothing\\n \\n for j in range(self.feature_count): # Loop over each feature\\n single_word_count = np.sum(dataset[start_index:end_index,j]) # sum number times word j appears in class i \\n numerator = single_word_count + self.alpha\\n self.p_xi_given_ys[i][j] = log(numerator * 1.0 / denominator) # Compute p(xi|y)\\n \\n start_index = end_index\",\n \"def train(self, dataset): \\n dataset = dataset[dataset[:,-1].argsort()] # Sort the dataset by classes.\\n #print dataset\\n \\n ########\\n # Compute p(y=1) for all ys.\\n ########\\n label_counts = np.bincount(dataset[:,-1]) # Get the number of occurrences of each class, sorted. \\n self.p_ys = label_counts * 1.0 / len(dataset) # Compute probs. \\n \\n ########\\n # Compute p(x|y) for all x,y.\\n ########\\n self.feature_count = len(dataset[0]) - 1 \\n self.class_count = len(label_counts)\\n \\n self.p_xi_given_ys = np.zeros((self.class_count, self.feature_count)) # Initialize matrix\\n start_index = 0\\n for i in range(self.class_count): # Loop over each class \\n end_index = start_index + label_counts[i] # end of this class index \\n denominator = label_counts[i] + 2.0 * self.alpha\\n \\n for j in range(self.feature_count): # Loop over each feature\\n numerator = np.sum(dataset[start_index:end_index,j]) + self.alpha # Sum number of times word j = 1 in class i\\n self.p_xi_given_ys[i][j] = numerator * 1.0 / denominator # Compute p(xi|y)\\n \\n start_index = end_index\",\n \"def forward(ctx, input, gamma, beta, eps=1e-5):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n\\n ####### Forward pass of batch normalization ######\\n\\n # In this section, we have to perform the forward pass of batch normalization\\n # with more intermediate steps, since we want to propagate error terms. \\n # To illustrate it better, we began from the bottom and follow our way to the top.\\n # In that way, we unfolded every function step by step.\\n\\n # Step 3.2.3: Calculate variance\\n var = input.var(dim=0, unbiased=False)\\n\\n # Step 3.2.2: add eps for numerical stability, then sqrt\\n sqrt_var = torch.sqrt(var + eps)\\n\\n # Step 3.2: ivert sqrtwar\\n inv_sqrt_var = 1./sqrt_var\\n\\n # Step 3.1.1: Calculate mean\\n mean = input.mean(dim=0)\\n\\n # Step 3.1: subtract mean vector of every trainings example\\n input_mean = input - mean\\n\\n # Step 3 - Execute normalization\\n input_norm = input_mean * inv_sqrt_var \\n\\n # Step 2: Nor the two transformation steps\\n scaled_input_norm = gamma * input_norm\\n\\n # Step 1: scale and shift\\n out = scaled_input_norm + beta\\n #################################################\\n # store tensors and non-tensorial constants\\n ctx.save_for_backward(gamma, inv_sqrt_var, mean, input)\\n ctx.foo = eps\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return out\",\n \"def forward(self, x):\\n vgg_out = self.vgg(x)\\n cls_out = self.classifier(vgg_out)\\n reg_out = self.regressor(vgg_out)\\n #out = torch.cat((cls_out, reg_out), 0) # might be the wrong dimension\\n \\n return cls_out,reg_out\",\n \"def forward(self, x):\\n # sources保存特征图，loc与conf保存所有PriorBox的位置与类别预测特征\\n sources = list()\\n loc = list()\\n conf = list()\\n\\n # 对输入图像卷积到conv4_3，将特征添加到sources中\\n for k in range(23):\\n x = self.vgg[k](x)\\n\\n s = self.L2Norm(x)\\n sources.append(s)\\n\\n # 继续卷积到conv7，将特征添加到sources中\\n for k in range(23, len(self.vgg)):\\n x = self.vgg[k](x)\\n sources.append(x)\\n\\n # 继续利用额外的卷积层计算，并将特征添加到sources中\\n for k, v in enumerate(self.extras):\\n x = F.relu(v(x), inplace=True)\\n if k % 2 == 1: # 间隔一层\\n sources.append(x)\\n\\n # 对sources中的特征图利用类别与位置网络进行卷积计算，并保存到loc与conf中\\n for (x, l, c) in zip(sources, self.loc, self.conf):\\n loc.append(l(x).permute(0, 2, 3, 1).contiguous())\\n conf.append(c(x).permute(0, 2, 3, 1).contiguous())\\n\\n loc = torch.cat([o.view(o.size(0), -1) for o in loc], 1)\\n conf = torch.cat([o.view(o.size(0), -1) for o in conf], 1)\\n\\n if self.phase == \\\"test\\\":\\n output = self.detect(\\n loc.view(loc.size(0), -1, 4), # loc preds\\n self.softmax(conf.view(conf.size(0), -1, self.num_classes)), # conf preds\\n self.priors.type(type(x.data)) # default boxes\\n )\\n else:\\n # 对于训练来说，output包括了loc与conf的预测值以及PriorBox的信息\\n output = (\\n loc.view(loc.size(0), -1, 4),\\n conf.view(conf.size(0), -1, self.num_classes),\\n self.priors\\n )\\n return output\",\n \"def forward(self, inputs, **kwargs):\\n x = self.ff_module1(inputs)\\n x = self.mha_module(x, **kwargs)\\n x = self.conv_module(x)\\n x = self.ff_module2(x)\\n\\n return x\",\n \"def forward(self, X, labels):\\n features = self.get_conv_feats(X)\\n W = self.W\\n T = self.T\\n log_prob = CRFautograd.apply(W, T, features, labels)\\n return log_prob\",\n \"def forward_pass(self):\\n # Compute the support set's mean and var and use these as the moments for\\n # batch norm on the query set.\\n train_embeddings = self.embedding_fn(self.episode.train_images,\\n self.is_training)\\n self.train_embeddings = train_embeddings['embeddings']\\n support_set_moments = None\\n if not self.transductive_batch_norm:\\n support_set_moments = train_embeddings['moments']\\n test_embeddings = self.embedding_fn(\\n self.episode.test_images,\\n self.is_training,\\n moments=support_set_moments,\\n backprop_through_moments=self.backprop_through_moments)\\n self.test_embeddings = test_embeddings['embeddings']\",\n \"def forward(self, *args, mode=\\\"train\\\", **kwargs):\\n raise NotImplementedError\",\n \"def fit(self):\\n accuracy = 0\\n no_improvement = 0\\n epochs = trange(self.args.epochs, desc=\\\"Accuracy\\\")\\n self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.args.learning_rate)\\n self.model.train()\\n for epoch in epochs:\\n self.optimizer.zero_grad()\\n prediction = self.model(self.propagation_matrix, self.features)\\n loss = torch.nn.functional.nll_loss(prediction[self.train_nodes], self.target[self.train_nodes])\\n loss = loss + self.args.lambd*torch.sum(self.model.page_rank_convolution_1.weight_matrix**2)\\n loss.backward()\\n self.optimizer.step()\\n new_accuracy = self.score(self.validation_nodes)\\n epochs.set_description(\\\"Validation Accuracy: %g\\\" % round(new_accuracy,4))\\n if new_accuracy < accuracy:\\n no_improvement = no_improvement + 1\\n if no_improvement == self.args.early_stopping:\\n epochs.close()\\n break\\n else:\\n no_improvement = 0\\n accuracy = new_accuracy \\n acc = self.score(self.test_nodes)\\n print(\\\"\\\\nTest accuracy: \\\" + str(round(acc,4)) )\",\n \"def calculate_scores(self):\\n # Prediction based scores\\n #self.report = classification_report(self.y_test, self.y_pred)\\n self.accuracy = accuracy_score(self.y_real, self.y_pred)\\n self.precision = precision_score(self.y_real, self.y_pred)\\n self.recall = recall_score(self.y_real, self.y_pred)\\n self.f1 = f1_score(self.y_real, self.y_pred)\\n \\n # Probability based scores\\n self.fpr, self.tpr, _ = roc_curve(self.y_real, self.y_proba)\\n self.average_precision = average_precision_score(self.y_real, self.y_proba)\\n self.brier_loss = brier_score_loss(self.y_real, self.y_proba)\\n self.roc_auc = roc_auc_score(self.y_real, self.y_proba)\\n self.prec_cur, self.recall_cur, _ = precision_recall_curve(self.y_real, self.y_proba)\",\n \"def train(self, input_scores: np.ndarray, true_labels: np.ndarray) -> None:\\n self.model.compile(\\n loss=\\\"categorical_crossentropy\\\", optimizer=\\\"adam\\\", metrics=[\\\"acc\\\"]\\n )\\n\\n input_scores = np.moveaxis(input_scores, 0, -1)\\n\\n train_data, val_data, train_labels, val_labels = train_test_split(\\n input_scores, true_labels, test_size=0.2, stratify=true_labels\\n )\\n\\n train_labels = keras.utils.to_categorical(\\n train_labels, num_classes=self.num_classes\\n )\\n val_labels = keras.utils.to_categorical(\\n val_labels, num_classes=self.num_classes\\n )\\n\\n self.model.fit(\\n x=train_data,\\n y=train_labels,\\n validation_data=(val_data, val_labels),\\n epochs=30,\\n callbacks=[\\n TerminateOnNaN(),\\n EarlyStopping(\\n patience=15, monitor=\\\"val_acc\\\", restore_best_weights=True\\n ),\\n ],\\n )\",\n \"def forward(self, images):\\n # assuming that the precomputed features are not already l2-normalized\\n x = l2norm(images.view( images.size(0), -1))\\n #print(images.shape, self.fc )\\n x = self.relu(self.fc1(x))\\n x = self.fc2(x)\\n #x = F.log_softmax(x) #no need of log softmax here if we use cross entropy as loss\\n #x = self.softmax(x)\\n # normalize in the joint embedding space\\n \\n\\n return x\",\n \"def loss(self, X, y=None):\\n\\n # In dev testing, the loss fnc stops at \\\"scores\\\" , unfollowed by \\\"softmax\\\" probability prediction.\\n # In real testing, \\\"self.predict()\\\" needs to be implemented in Solver() class.\\n \\n if y is None:\\n for bn_param in self.bn_params:\\n bn_param[\\\"mode\\\"] = \\\"test\\\"\\n\\n\\n W1, b1 = self.params['W1'], self.params['b1']\\n gamma1, beta1 = self.params[\\\"sbnGamma1\\\"], self.params[\\\"sbnBeta1\\\"]\\n bn_param1 = self.bn_params[0]\\n\\n W2, b2 = self.params['W2'], self.params['b2']\\n gamma2, beta2 = self.params[\\\"sbnGamma2\\\"], self.params[\\\"sbnBeta2\\\"]\\n bn_param2 = self.bn_params[1]\\n\\n W3, b3 = self.params['W3'], self.params['b3']\\n gamma3, beta3 = self.params[\\\"bnGamma3\\\"], self.params[\\\"bnBeta3\\\"]\\n bn_param3 = self.bn_params[2]\\n\\n W4, b4 = self.params['W4'], self.params['b4']\\n \\n # pass conv_param to the forward pass for the convolutional layer\\n conv_param = self.conv_param\\n\\n # pass pool_param to the forward pass for the max-pooling layer\\n pool_param = self.maxpool_params\\n\\n ############################################################################\\n # TODO: Implement the forward pass for the three-layer convolutional net, #\\n # computing the class scores for X and storing them in the scores #\\n # variable. #\\n ############################################################################\\n \\n scores = None \\n cache = {}\\n # def conv_sbn_relu_forward(x, w, b, gamma, beta, conv_param, bn_param): return out, cache;\\n out, cache[\\\"layer1\\\"] = layer_utils.conv_sbn_relu_forward(X, W1, b1, gamma1, beta1, conv_param, bn_param1) \\n out, cache[\\\"layer2\\\"] = layer_utils.conv_sbn_relu_forward(out, W2, b2, gamma2, beta2, conv_param, bn_param2)\\n\\n # def max_pool_forward_fast(x, pool_param): return out, cache;\\n out, cache[\\\"maxpool\\\"] = fast_layers.max_pool_forward_fast(out, pool_param)\\n\\n # def affine_bn_relu_forward(x, w, b, gamma, beta, bn_param): return out, cache;\\n \\n out, cache[\\\"layer3\\\"] = layer_utils.affine_bn_relu_forward(out, W3, b3, gamma3, beta3, bn_param3)\\n\\n # def affine_forward(x, w, b): return out, cache;\\n scores, cache[\\\"layer4\\\"] = layers.affine_forward(out, W4, b4)\\n\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n if y is None:\\n return scores\\n \\n ############################################################################\\n # TODO: Implement the backward pass for the three-layer convolutional net, #\\n # storing the loss and gradients in the loss and grads variables. Compute #\\n # data loss using softmax, and make sure that grads[k] holds the gradients #\\n # for self.params[k]. Don't forget to add L2 regularization! #\\n ############################################################################\\n \\n loss, grads = 0, {}\\n\\n # def softmax_loss(x, y): return loss, dscore;\\n loss, dscores = layers.softmax_loss(scores, y)\\n loss += 0.5 * self.reg * (np.sum(W1 * W1) + np.sum(W2 * W2) + np.sum(W3 * W3) + np.sum(W4 * W4))\\n\\n # def affine_backward(dout, cache): return dx, dw, db;\\n dout, dW4, db4 = layers.affine_backward(dscores, cache[\\\"layer4\\\"]) \\n\\n # def affine_bn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\\n dout, dW3, db3, dgamma3, dbeta3 = layer_utils.affine_bn_relu_backward(dout, cache[\\\"layer3\\\"])\\n\\n # print cache[\\\"layer3\\\"]\\n\\n # def max_pool_backward_fast(dout, cache): return max_pool_backward_im2col(dout, real_cache);\\n # def max_pool_backward_im2col(dout, cache): return dx;\\n dout = fast_layers.max_pool_backward_fast(dout, cache[\\\"maxpool\\\"])\\n\\n # def conv_sbn_relu_backward(dout, cache): return dx, dw, db, dgamma, dbeta;\\n dout, dW2, db2, dgamma2, dbeta2 = layer_utils.conv_sbn_relu_backward(dout, cache[\\\"layer2\\\"])\\n _, dW1, db1, dgamma1, dbeta1 = layer_utils.conv_sbn_relu_backward(dout, cache[\\\"layer1\\\"])\\n\\n # reg\\n grads['W4'], grads['b4'] = dW4 + self.reg * W4, db4\\n \\n grads['W3'], grads['b3'] = dW3 + self.reg * W3, db3\\n grads[\\\"bnGamma3\\\"], grads[\\\"bnBeta3\\\"] = dgamma3, dbeta3\\n\\n grads['W2'], grads['b2'] = dW2 + self.reg * W2, db2\\n grads[\\\"sbnGamma2\\\"], grads[\\\"sbnBeta2\\\"] = dgamma2, dbeta2\\n\\n grads['W1'], grads['b1'] = dW1 + self.reg * W1, db1\\n grads[\\\"sbnGamma1\\\"], grads[\\\"sbnBeta1\\\"] = dgamma1, dbeta1\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n \\n return loss, grads\",\n \"def compute_forward(self, batch, stage):\\n\\n # We first move the batch to the appropriate device.\\n batch = batch.to(self.device)\\n # Compute features, embeddings, and predictions\\n feats, lens = self.prepare_features(batch.sig, stage)\\n embeddings = self.modules.embedding_model(feats.cuda(), lens.cuda())\\n predictions = self.modules.classifier(embeddings)\\n return predictions\",\n \"def f1_score(self):\",\n \"def forward(self, train_imgs, test_imgs, train_bb, test_bb, test_win, test_bb_inwin, *args, **kwargs):\\n\\n assert train_imgs.dim() == 5 and test_imgs.dim() == 5, 'Expect 5 dimensional inputs'\\n # Extract backbone features, OrderedDict, layer2 [30, 512, 36, 36] layer3 [30, 1024, 18, 18]\\n train_feat = self.extract_backbone_features(train_imgs.reshape(-1, *train_imgs.shape[-3:]))\\n test_feat = self.extract_backbone_features(test_imgs.reshape(-1, *test_imgs.shape[-3:]))\\n\\n test_win = test_win.reshape(-1, 4)\\n\\n # Classification features\\n train_feat_clf = self.get_backbone_clf_feat(train_feat)\\n test_feat_clf = self.get_backbone_clf_feat(test_feat)\\n\\n # Run classifier module, train_skfeat.dim()=5, test_skfeat.dim()=5\\n target_scores, train_skfeat, test_skfeat, channel_importance = self.classifier(train_feat_clf, test_feat_clf,\\n train_bb, *args, **kwargs)\\n\\n train_feat_se, test_feat_se = self.adjust_skfeat(train_skfeat, test_skfeat, channel_importance)\\n # Using the same feature with the classifier to estimate the target state\\n bboxes, cls = self.state_estimator(train_feat_se, test_feat_se,\\n train_bb, test_win, test_bb_inwin, target_scores)\\n\\n return target_scores, bboxes, cls\",\n \"def forward(self, x):\\n out = self.pre_processing(x)\\n out = self.a3(out)\\n out = self.b3(out)\\n out = self.maxpool(out)\\n out = self.a4(out)\\n out = self.b4(out)\\n out = self.c4(out)\\n out = self.d4(out)\\n out = self.e4(out)\\n out = self.maxpool(out)\\n out = self.a5(out)\\n out = self.b5(out)\\n out = self.avgpool(out)\\n out = out.view(out.size(0), -1) # reshape the output tensor\\n out = self.linear(out)\\n\\n return out\",\n \"def _forward_alg(self, feats):\\n\\n init_alphas = torch.full((self.batch_size, 1, self.tagset_size), -10000.).to(self.device)\\n # START_TAG has all of the score.\\n init_alphas[:, 0, self.tag2idx[START_TAG]] = 0.\\n forward_var = init_alphas\\n\\n # Iterate through the sentence\\n for i in range(feats.shape[1]):\\n feat = feats[:,i,:]\\n\\n emit_score = feat.view(self.batch_size, self.tagset_size, 1)\\n next_tag_var = forward_var + self.transitions + emit_score\\n forward_var = torch.logsumexp(next_tag_var,dim=-1).view(self.batch_size, 1, self.tagset_size)\\n\\n terminal_var = forward_var + self.transitions[self.tag2idx[STOP_TAG]]\\n alpha = torch.logsumexp(terminal_var,dim=-1)\\n return alpha\",\n \"def classification(features, scores, n_classes, model_type=0, save_path='results/',\\n lr=.01, batch_size=10, n_epochs=20, test_size=.3,\\n verbose=False, save_results=False, normalize=True):\\n # features, scores = read_data_from_csv()\\n verbose_opc = 0\\n if verbose:\\n print(\\\"[INFO] Shuffle Data\\\")\\n verbose_opc = 1\\n\\n features, scores = shuffle(features, scores, random_state=0)\\n\\n if normalize:\\n if verbose:\\n print(\\\"[INFO] Normalizing Data\\\")\\n scaler = StandardScaler()\\n scaler.fit(features)\\n features = scaler.transform(features)\\n\\n if verbose:\\n print(\\\"[INFO] Splitting data into train and test sets\\\")\\n x_train, x_test, y_train, y_test = train_test_split(features, scores, test_size=test_size)\\n\\n\\n\\n if verbose:\\n print(\\\"[INFO] Creating the machine learning model\\\")\\n\\n model = None\\n if model_type == 0:\\n model = res_model(x_train.shape[1:], n_classes)\\n elif model_type == 1:\\n model = simple_model(x_train.shape[1:], n_classes)\\n elif model_type == 2:\\n model = sklearn.svm.SVC(gamma='auto')\\n elif model_type == 3:\\n model = RandomForestClassifier()\\n elif model_type == 4:\\n model = AdaBoostClassifier()\\n elif model_type == 5:\\n model = xgb.XGBClassifier(objective=\\\"multi:softprob\\\", random_state=42)\\n\\n h = None\\n if model_type >= 0 and model_type <= 1:\\n # classes 0.0 ,0.5, 1.0, 1.5, 2.0\\n y_cat_train = to_categorical(y_train, n_classes)\\n y_cat_test = to_categorical(y_test, n_classes)\\n\\n model.compile(loss=\\\"logcosh\\\",\\n #optimizer=keras.optimizers.SGD(lr=lr, momentum=.3),\\n optimizer=\\\"adamax\\\",\\n metrics=['accuracy'])\\n\\n h = model.fit(x_train, y_cat_train,\\n batch_size=batch_size,\\n epochs=n_epochs,\\n validation_data=(x_test, y_cat_test),\\n verbose=verbose_opc)\\n\\n evaluate_model(x_test, y_cat_test, batch_size, model, n_epochs, h, n_classes, folder_name=save_path,\\n save_results=save_results, is_rna=True)\\n else:\\n model.fit(x_train, y_train)\\n\\n evaluate_model(x_test, y_test, batch_size, model, n_epochs, h, n_classes, folder_name=save_path,\\n save_results=save_results)\\n\\n return model\",\n \"def training_step(self, x):\\n self.train()\\n rec_error, feat, y = self.forward(x)\\n # Reconstruction Loss\\n rec_loss = torch.mean(rec_error)\\n loss = rec_loss\\n\\n self.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n self.eval()\\n print('Rec Loss: {}'.format(rec_loss.cpu().data))\\n print()\\n return loss, feat, y\",\n \"def custom_scoring(y_te, y_pred):\\n #weights computed with training data set\\n w = np.array([0.02409584, 0.00787456, 0.03685528, 0.01760536, 0.04589969, 0.8483942 , 0.01724058, 0.00203449]);\\n \\n ## F1 SCORES\\n #evaluate F1 score, precision and recall for each label, \\n #along with custom proportionally weighted F1 score\\n #and built in weighted and macro F1 scores\\n F1_tab, Ptab, Rtab, pf1 = F1_score(y_te, y_pred, w)\\n f = F1Score(8, threshold = 0.5, average = 'weighted')\\n f.update_state(y_te, y_pred)\\n wf1 = f.result().numpy() #weighted f1 score\\n f.reset_states()\\n f = F1Score(8, threshold = 0.5, average = 'macro')\\n f.update_state(y_te, y_pred)\\n mf1 = f.result().numpy() #macro f1 score\\n f.reset_states()\\n\\n ##EDIT DISTANCE\\n #edit_dist_av = LevDistMultilabels(y_true, y_pred)\\n\\n ##ACCURACY\\n #evaluate accuracy per label\\n acc_tab = Acc(y_te, y_pred)\\n\\n return wf1, mf1, pf1, F1_tab, Ptab, Rtab, acc_tab\",\n \"def loss(self, X, y=None):\\n X = X.astype(self.dtype)\\n mode = 'test' if y is None else 'train'\\n\\n scores = None\\n ############################################################################\\n # Implementing the forward pass for the fully-connected net, computing #\\n # the class scores for X and storing them in the scores variable. #\\n ############################################################################\\n\\n l_input = X.copy()\\n out = []\\n cache = []\\n for i in range(self.num_layers - 1):\\n # layerwise compute the forward pass and store outputs in out list\\n key = ['W' + str(i+1), 'b' + str(i+1)]\\n lout, lcache = affine_sigmoid_forward(l_input, self.params[key[0]], self.params[key[1]])\\n out.append(lout)\\n cache.append(lcache)\\n l_input = lout\\n\\n key = ['W' + str(self.num_layers), 'b' + str(self.num_layers)]\\n scores, lcache = affine_forward(out[self.num_layers - 2], self.params[key[0]], self.params[key[1]])\\n cache.append(lcache)\\n \\n # regularization parameter compute by summing square of all weight vectors\\n R = 0\\n for i in range(1, self.num_layers + 1):\\n key = 'W' + str(i)\\n R += np.sum(np.power(self.params[key], 2))\\n\\n # If test mode return early\\n if mode == 'test':\\n return scores\\n\\n loss, grads = 0.0, {}\\n\\n ########################\\n # Backward pass to compute the loss and gradients\\n ########################\\n\\n loss, dscore = softmax_loss(scores, y)\\n # Apply regularization of the loss \\n loss = loss + 0.5 * self.reg * R\\n\\n key = ['W' + str(self.num_layers), 'b' + str(self.num_layers)]\\n dx, grads[key[0]], grads[key[1]] = affine_backward(dscore, cache[self.num_layers - 1])\\n grads[key[0]] += self.reg * self.params[key[0]] \\n\\n for i in range(self.num_layers - 1, 0, -1):\\n key = ['W' + str(i), 'b' + str(i)]\\n dx, grads[key[0]], grads[key[1]] = affine_sigmoid_backward(dx, cache[i-1])\\n # Apply regularization to the gradients\\n grads[key[0]] += self.reg * self.params[key[0]]\\n\\n return loss, grads\",\n \"def forward_prop(net, input_values, threshold_fn=stairstep):\\n raise NotImplementedError\",\n \"def forward(self, input):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n assert input.shape[1] == self.n_neurons, \\\"The shape of the input tensor is not correct.\\\"\\n\\n # compute mean\\n mean = input.mean(dim=0)\\n\\n # compute variance\\n var = input.var(dim=0, unbiased=False)\\n\\n # normalize\\n input_norm = (input-mean)/(torch.sqrt(var + self.eps))\\n\\n # scale and shift\\n out = self.gamma*input_norm + self.beta\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return out\",\n \"def score(self, X, y=...):\\n ...\",\n \"def calc_score(model, scorer, X, y_true):\\n\\n y_preds = model.predict(X)\\n score = scorer(y_true, y_preds)\\n\\n return score\",\n \"def on_iter_forward(self, runner):\\n # unpack features into features and targets\\n *features, target = runner.batch\\n # Forward features\\n runner.output = runner.model(*features)\\n # Ensure `targetL` and `outputL` are always in a list format.\\n targetL = [target] if not isinstance(target, (list, tuple)) else target\\n outputL = [runner.output] if not isinstance(runner.output, (list, tuple)) else runner.output\\n # Compute loss\\n runner.loss = runner.criterion(*outputL, *targetL)\\n runner.target = target\",\n \"def _prob_to_class(self, forward):\\n predict_pos = self.activation(forward)\\n predict_neg = 1 - predict_pos\\n\\n return torch.stack((predict_neg, predict_pos)).argmax(0).float()\",\n \"def forward(self, tokens, lprobs, rewards, sample, scr_scores, reduce=True, **kwargs):\\n\\n loss, sc_loss = self.compute_loss(tokens, lprobs, rewards)\\n try:\\n n_pos = rewards.ge(0.0).sum().div(rewards.size(1)).item()\\n except:\\n n_pos = rewards.ge(0.0).sum().floor_divide(rewards.size(1)).item()\\n\\n nsentences = tokens.size(0)\\n ntokens = tokens.ne(self.padding_idx).sum().item()\\n sample_size = nsentences if self.args.sentence_avg else ntokens\\n\\n logging_output = {\\n 'cider': np.sum(scr_scores) if reduce else scr_scores,\\n 'loss': utils.item(loss.data) if reduce else loss.data,\\n 'sc_loss': utils.item(sc_loss.data) if reduce else sc_loss.data,\\n 'n_positive': n_pos,\\n 'ntokens': ntokens,\\n 'nsentences': nsentences,\\n 'sample_size': sample_size,\\n }\\n return loss, sample_size, logging_output\",\n \"def __init__(self, num_class):\\n self.sum_hit_at_one = 0.0\\n self.sum_perr = 0.0\\n self.sum_f1score = 0.0\\n self.sum_f2score = 0.0\\n self.sum_loss = 0.0\\n self.num_examples = 0\",\n \"def feedforward(self, inputs):\\n processsum = 0\\n for i in range(len(inputs)):\\n processsum = processsum + inputs[i] * self.weights[i]\\n return self.activate(processsum)\",\n \"def forward(self, *args):\\r\\n _, (hn, _) = self.enc(*args)\\r\\n\\r\\n y_pred = self.mlp(hn)\\r\\n return y_pred\",\n \"def clf_scores(cm) -> float:\\n \\n # Number of correct elements of given class - diagonal\\n acc = cm.trace()/np.sum(cm)\\n \\n # Total number of elements with true class j - sum of column j\\n # Total number of elements with predicted class i - sum of row i\\n precision_class = cm.diagonal()/cm.sum(axis=1)\\n recall_class = cm.diagonal()/cm.sum(axis=0)\\n f1_class = 2*precision_class*recall_class/(precision_class + recall_class)\\n \\n return {\\n 'accuracy': acc, \\n 'precision': precision_class, \\n 'recall': recall_class, \\n 'F1': f1_class\\n }\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7152157","0.67411566","0.6440144","0.6402874","0.64024365","0.637545","0.62795955","0.6259711","0.62537515","0.62476677","0.6244945","0.62178695","0.62178695","0.62093914","0.61990786","0.6183218","0.6170751","0.61354846","0.61190605","0.61190605","0.611082","0.6085851","0.60497963","0.6049058","0.60409516","0.60409516","0.60231614","0.59983146","0.598851","0.5986047","0.59857136","0.5984705","0.59792733","0.59671974","0.5952651","0.59467006","0.5917962","0.59047085","0.5894981","0.58808327","0.58722484","0.5854804","0.584399","0.5828406","0.5819163","0.5813401","0.5806902","0.58026457","0.5802202","0.58012795","0.5792914","0.5786816","0.5784365","0.5780666","0.5776999","0.57735556","0.5773463","0.5769715","0.5762839","0.5761253","0.57587427","0.5755606","0.57482326","0.57477903","0.5740974","0.57255596","0.57209045","0.57208586","0.5717941","0.5716538","0.5710687","0.5708757","0.5703677","0.5701327","0.56974673","0.5695433","0.5685963","0.56787986","0.5670686","0.56678","0.5665779","0.56650954","0.56543595","0.565284","0.5649924","0.5643349","0.56370926","0.563447","0.5633331","0.56303066","0.5628152","0.5624974","0.5620179","0.56158763","0.56155217","0.56147695","0.5614246","0.5613388","0.5612979","0.5607601"],"string":"[\n \"0.7152157\",\n \"0.67411566\",\n \"0.6440144\",\n \"0.6402874\",\n \"0.64024365\",\n \"0.637545\",\n \"0.62795955\",\n \"0.6259711\",\n \"0.62537515\",\n \"0.62476677\",\n \"0.6244945\",\n \"0.62178695\",\n \"0.62178695\",\n \"0.62093914\",\n \"0.61990786\",\n \"0.6183218\",\n \"0.6170751\",\n \"0.61354846\",\n \"0.61190605\",\n \"0.61190605\",\n \"0.611082\",\n \"0.6085851\",\n \"0.60497963\",\n \"0.6049058\",\n \"0.60409516\",\n \"0.60409516\",\n \"0.60231614\",\n \"0.59983146\",\n \"0.598851\",\n \"0.5986047\",\n \"0.59857136\",\n \"0.5984705\",\n \"0.59792733\",\n \"0.59671974\",\n \"0.5952651\",\n \"0.59467006\",\n \"0.5917962\",\n \"0.59047085\",\n \"0.5894981\",\n \"0.58808327\",\n \"0.58722484\",\n \"0.5854804\",\n \"0.584399\",\n \"0.5828406\",\n \"0.5819163\",\n \"0.5813401\",\n \"0.5806902\",\n \"0.58026457\",\n \"0.5802202\",\n \"0.58012795\",\n \"0.5792914\",\n \"0.5786816\",\n \"0.5784365\",\n \"0.5780666\",\n \"0.5776999\",\n \"0.57735556\",\n \"0.5773463\",\n \"0.5769715\",\n \"0.5762839\",\n \"0.5761253\",\n \"0.57587427\",\n \"0.5755606\",\n \"0.57482326\",\n \"0.57477903\",\n \"0.5740974\",\n \"0.57255596\",\n \"0.57209045\",\n \"0.57208586\",\n \"0.5717941\",\n \"0.5716538\",\n \"0.5710687\",\n \"0.5708757\",\n \"0.5703677\",\n \"0.5701327\",\n \"0.56974673\",\n \"0.5695433\",\n \"0.5685963\",\n \"0.56787986\",\n \"0.5670686\",\n \"0.56678\",\n \"0.5665779\",\n \"0.56650954\",\n \"0.56543595\",\n \"0.565284\",\n \"0.5649924\",\n \"0.5643349\",\n \"0.56370926\",\n \"0.563447\",\n \"0.5633331\",\n \"0.56303066\",\n \"0.5628152\",\n \"0.5624974\",\n \"0.5620179\",\n \"0.56158763\",\n \"0.56155217\",\n \"0.56147695\",\n \"0.5614246\",\n \"0.5613388\",\n \"0.5612979\",\n \"0.5607601\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61028564"},"document_rank":{"kind":"string","value":"21"}}},{"rowIdx":12190,"cells":{"query":{"kind":"string","value":"This functions performs the backward pass which computes for the gradients of the loss with respect to every parameter."},"document":{"kind":"string","value":"def network_backward(self, dloss, cache_list):\n \n #############################################################################\n # TODO: Implement the backward pass. #\n #############################################################################\n grads = {}\n\n # Set Activation Function\n ActivationFunction_Backward = None\n if self.hidden_activation_fn == \"sigmoid\":\n ActivationFunction_Backward = lambda dx, cache: self.sigmoid_backward(dx, cache)\n elif self.hidden_activation_fn == \"tanh\":\n ActivationFunction_Backward = lambda dx, cache: self.tanh_backward(dx, cache)\n elif self.hidden_activation_fn == \"relu\":\n ActivationFunction_Backward = lambda dx, cache: self.relu_backward(dx, cache)\n\n # X1 => Result from X1\n # X1A => Result from X1 Activation\n X1, X1A, X2 = cache_list\n\n dX, grads[\"W2\"], grads[\"b2\"] = self.fully_connected_backward(dloss, X2)\n dX1A = ActivationFunction_Backward(dX, X1A)\n _, grads[\"W1\"], grads[\"b1\"] = self.fully_connected_backward(dX1A, X1)\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n return grads"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def backward(self, inputs, grad_loss_input):\n raise NotImplementedError","def backward_pass(architecture,gradient_layerwise,grad_weights,grad_bias):\n \n for layer in range(len(architecture)-1,-1,-1):\n X_input,X_output,weightsi,biasi,X_input_im2col,imi,output_shapei,kernel_shapei,stridei,operationi,imxi = architecture['layer{}'.format(layer+1)]\n# print(\"Operation is:{} and Layer is: {}\".format(operationi,layer+1))\n if operationi == 'softmax': # Last layer -> Dont apply softmax in any layer other than the last layer!\n # not taking gradients here because we need dz_dX(secondlastlayer) which is y_pred - y\n continue\n \n if operationi == 'conv_bn_relu' or operationi == 'conv_relu' or operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\n if operationi__1 == 'softmax':\n y_pred = architecture['layer{}'.format(layer+2)][1]\n y_pred = torch.reshape(y_pred,y.shape)\n dz_dXi = y_pred - y\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\n X_output = torch.reshape(X_output,dz_dXi.shape)\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n elif 'relu' in operationi:\n dz_dXi[X_output <= 0] = 0\n else:\n None\n \n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # .\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # .\n try:\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input_im2col)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\n except:\n dz_dweightsi = (dz_dXi).mm(X_input_im2col)\n \n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi #\n elif operationi__1 == 'maxpool': # need to do something here to fix the problem\n None\n\n elif 'flatten' in operationi__1:\n # we currently have dz_doutput of flatten -> we want dz_doutput of the conv_bn_relu before flatten\n \n weightsi__1 = architecture['layer{}'.format(layer+2)][2] # weights2\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput of flatten\n if len(dz_dXi__1.shape) == 3:\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\n imi__1 = architecture['layer{}'.format(layer+2)][5] # i\n try:\n dz_dXi = torch.t(weightsi__1).mm(dz_dXi__1)\n except:\n dz_dXi = weightsi__1.mm(dz_dXi__1)\n X_output = torch.reshape(X_output,dz_dXi.shape)\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n elif 'relu' in operationi:\n dz_dXi[X_output <= 0] = 0\n else:\n None\n\n dz_dXi = torch.reshape(dz_dXi,(output_shapei[1]*output_shapei[2],-1))\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\n dz_dweightsi = X_input_im2col.mm(dz_dXi)\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\n dz_dbi = dz_dXi\n \n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)# Can also set this to layer like in line ~800\n \n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi) # Can also set this to layer like in line ~800\n \n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi) # Can also set this to layer like in line ~800\n \n else:\n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dX2 -> backpropagated from maxpool\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\n if len(dz_dXi__1.shape) == 3:\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\n imi__1 = architecture['layer{}'.format(layer+2)][5]\n try:\n Y = weightsi__1.mm(dz_dXi__1)\n except:\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\n dz_dXi = torch.zeros(X_output.shape)\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\n for i in range(np.shape(X_output)[0]):\n for j in range(np.shape(X_output)[1]):\n for k in range(np.shape(X_output)[2]):\n idxs = getIndexes(imi__1,(i,j,k))\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\n \n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\n if 'sigmoid' in operationi__1: # ...\n X_output = torch.reshape(X_output,dz_dXi.shape)\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n elif 'relu' in operationi__1: # ...\n dz_dXi[X_output <= 0] = 0\n else:\n None\n \n dz_dXi = torch.reshape(dz_dXi,(output_shape_current_layer[1]*output_shape_current_layer[2],-1))\n dz_dbi = torch.reshape(dz_dXi,bias_current_layer.shape)\n dz_dweightsi = X_im2col_current_layer.mm(dz_dXi)\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\n \n if operationi == 'maxpool':\n \n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput -> backpropagated from maxpool\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\n \n if len(dz_dXi__1.shape) == 3:\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\n imi__1 = architecture['layer{}'.format(layer+2)][5]\n try:\n Y = weightsi__1.mm(dz_dXi__1)\n except:\n try:\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\n except:\n Y = torch.t(weightsi__1).mm(dz_dXi__1) # Ensuring valid matrix multiplication here\n \n dz_dXi = torch.zeros(X_output.shape)\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\n for i in range(np.shape(X_output)[0]):\n for j in range(np.shape(X_output)[1]):\n for k in range(np.shape(X_output)[2]):\n idxs = getIndexes(imi__1,(i,j,k))\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\n\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\n \n if operationi__1 == 'conv_sigmoid' or operationi__1 == 'conv_bn_sigmoid': # ...\n X_output = torch.reshape(X_output,dz_dXi.shape)\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n else:\n dz_dXi[X_output <= 0] = 0\n\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\n \n dz_dXinput = torch.zeros((X_input.shape))\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+1)][0] # output = output of maxpool\n\n dz_dXoutput = torch.reshape(dz_dXoutput,(output_shapei[0],X_input_im2col.shape[2]))\n \n for i in range(output_shapei[0]):\n for j in range(X_input_im2col.shape[2]):\n Xi2ci = X_im2col_current_layer[i,:,:]\n idx = torch.argmax(Xi2ci[:,j]).item()\n value = imxi[i][(idx,j)]\n dz_dXinput[value[0],value[1],value[2]] += float(dz_dXoutput[i,j])\n\n# dz_dXinput = torch.reshape(dz_dXinput,output_shapei)\n \n X_prev_im2col = architecture['layer{}'.format(layer)][4]\n X_output_prev = architecture['layer{}'.format(layer)][1]\n X_output_prev = torch.reshape(X_output_prev,dz_dXinput.shape)\n X_input_prev = architecture['layer{}'.format(layer)][0]\n prev_bias = architecture['layer{}'.format(layer)][3]\n output_shape_prev = architecture['layer{}'.format(layer)][6]\n prev_operation = architecture['layer{}'.format(layer)][9]\n \n if prev_operation == 'conv_sigmoid' or prev_operation == 'conv_bn_sigmoid':\n dz_dXinput *= sigmoid(X_output_prev)*(1-sigmoid(X_output_prev)) # Taking the derivative of the sigmoid function\n else:\n dz_dXinput[X_output_prev <= 0] = 0\n \n if len(dz_dXinput.shape) == 3:\n dz_dXinput = torch.reshape(dz_dXinput,(-1,output_shape_prev[0]))\n \n dz_dbi = torch.reshape(dz_dXinput,prev_bias.shape)\n dz_dweightsi = X_prev_im2col.mm(dz_dXinput)\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0\n \n gradient_layerwise['layer{}'.format(layer)][2] = torch.Tensor(dz_dbi)\n gradient_layerwise['layer{}'.format(layer)][1] = torch.Tensor(dz_dweightsi)\n gradient_layerwise['layer{}'.format(layer)][0] = torch.Tensor(dz_dXinput) # ...\n \n if 'flatten_dense' in operationi:\n \n operationi__1 = architecture['layer{}'.format(layer+2)][9]\n \n if operationi__1 == 'softmax':\n \n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\n X_output = torch.reshape(X_output,(-1,1))\n y_pred = architecture['layer{}'.format(layer+2)][1]\n y_pred = torch.reshape(y_pred,y.shape)\n dz_dXi = y_pred - y\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\n X_output = torch.reshape(X_output,dz_dXi.shape)\n if 'sigmoid' in operationi:\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n elif 'relu' in operationi:\n dz_dXi[X_output <= 0] = 0\n else:\n None\n \n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\n try:\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\n except:\n dz_dweightsi = (dz_dXi).mm(X_input)\n \n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0\n \n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # Can also set this to layer like in line ~800\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi # Can also set this to layer like in line ~800\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # Can also set this to layer like in line ~800\n \n else:\n # Have to modify and test this before implementation -> Specifically\n # the backprop implementation is not consistent with the ones above\n #\n X_output = torch.reshape(X_output,(-1,1))\n weights__i = architecture['layer{}'.format(layer+2)][2]\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+2)][0]\n dz_dXoutput = torch.reshape(torch.Tensor(dz_dXoutput),X_output.shape)\n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\n\n if 'relu' in operationi:\n dz_dXoutput[X_output<0] = 0\n try:\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\n except:\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\n try:\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\n except:\n dz_dweightsi = dz_dXoutput.mm(X_input)\n dz_dbi = dz_dXoutput\n if 'sigmoid' in operationi:\n dz_dXoutput*= sigmoid(X_output)*(1-sigmoid(X_output))\n try:\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\n except:\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\n try:\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\n except:\n dz_dweightsi = dz_dXoutput.mm(X_input)\n dz_dbi = dz_dXoutput\n else:\n try:\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\n except:\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\n try:\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\n except:\n dz_dweightsi = dz_dXoutput.mm(X_input)\n dz_dbi = dz_dXoutput\n \n unflattened_Xinput = architecture['layer{}'.format(layer+1)][0]\n dz_dXinput = torch.reshape(dz_dXinput,unflattened_Xinput.shape)\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXinput)\n \n if gradient_layerwise['layer{}'.format(layer+1)][1] is not None:\n try:\n grad_weights['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][1]\n except:\n grad_weights['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][1])\n if gradient_layerwise['layer{}'.format(layer+1)][2] is not None:\n try:\n grad_bias['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][2]\n except:\n grad_bias['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][2])\n \n gc.collect()\n return","def backward(self, gradient):\n raise NotImplementedError()","def backward(self, i):\n \n #Compute gradient for w1, w2, w3\n w1_grad = np.zeros((2, 3))\n w2_grad = np.zeros((3, 3))\n w3_grad = np.zeros((3, 1))\n \n \n w3_backward_pass = np.zeros((1, 1))\n w2_backward_pass = np.zeros((1, 3))\n \n #print(\"self.error shape\",self.error.shape)\n #Compute w3 gradient\n for i, w in enumerate(w3_grad): # 3 x 1 \n w3_forward_pass = self.a2[0][i]\n w3_backward_pass = self.error * der_sigmoid(self.y)\n w3_grad[i] = w3_forward_pass * w3_backward_pass\n \n #Compute w2 gradient\n for i, w_row in enumerate(w2_grad): # 3 x 3 \n for j, w in enumerate(w2_grad[i]):# 1 x 3 \n w2_forward_pass = self.a1[0][i]\n w2_backward_pass[0][i] = der_sigmoid(self.a2[0][i]) * self.w3[i][0] * w3_backward_pass\n w2_grad[i][j] = w2_forward_pass * w2_backward_pass[0][i]\n \n \n #Compute w1 gradient \n for i, w_rol in enumerate(w1_grad): # 2 x 3\n for j, w in enumerate(w1_grad[i]): # 1 x 3\n w1_forward_pass = self.input[0][i]\n w1_backward_pass = der_sigmoid(self.a1[0][i]) * self.w2[i][j] * w2_backward_pass[0][i]\n w1_grad[i][j] = w1_forward_pass * w1_backward_pass\n \n \n #Update \n for i, w in enumerate(w3_grad): \n self.w3[i] -= self.learning_rate * w3_grad[i]\n \n for i, w_row in enumerate(w2_grad): # 3 x 3 \n for j, w in enumerate(w2_grad[i]):# 1 x 3 \n self.w2[i][j] -= self.learning_rate * w2_grad[i][j]\n \n for i, w_rol in enumerate(w1_grad): # 2 x 3\n for j, w in enumerate(w1_grad[i]): # 1 x 3\n self.w1[i][j] -= self.learning_rate * w1_grad[i][j]\n \n #print(\"w3 grad : \", w3_grad)\n #print(\"w3.shape :\", self.w3.shape)","def backward_pass(self, loss):\n\n self.optimizer.zero_grad()\n self.optimizer.backward(loss)\n self.optimizer.step()","def backward_step(activations, targets, layers):\n param_grads = collections.deque() # List of parameter gradients for each layer\n output_grad = None # The error gradient at the output of the current layer\n # Propagate the error backwards through all the layers.\n # Use reversed to iterate backwards over the list of layers.\n for i, layer in enumerate(reversed(layers)):\n cur_layer_idx = len(layers) - i - 1\n if cur_layer_idx <= NUM_LAYERS_SKIP:\n # implement short circuit here\n if layer.is_fc_layer:\n grads = [0.0 for _ in range(layer.W.shape[0]*layer.W.shape[1]+layer.W.shape[1])]\n else:\n # normal gradient computation \n Y = activations.pop() # Get the activations of the last layer on the stack\n # Compute the error at the output layer.\n # The output layer error is calculated different then hidden layer error.\n if output_grad is None:\n input_grad = layer.get_input_grad(Y, targets)\n else: # output_grad is not None (layer is not output layer)\n input_grad = layer.get_input_grad(Y, output_grad)\n # Get the input of this layer (activations of the previous layer)\n X = activations[-1]\n # Compute the layer parameter gradients used to update the parameters\n grads = layer.get_params_grad(X, output_grad)\n param_grads.appendleft(grads)\n # Compute gradient at output of previous layer (input of current layer):\n output_grad = input_grad\n return list(param_grads) # Return the parameter gradients","def backward(ctx, grad_output):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n # Retrieve saved tensors and constants\n gamma, ivar, mean, input = ctx.saved_tensors\n eps = ctx.saved_tensors\n\n # Check which inputs need gradients\n input_needs_grad, gamma_needs_grad, beta_needs_grad = ctx.needs_input_grad\n\n # Get the batch size (=N)\n N, _ = grad_output.shape\n\n # reconstruct the input_norm\n input_norm = (input - mean) * ivar\n grand_input_norm = grad_output * gamma\n\n ##### Gradient wrt beta #####\n grad_beta = grad_output.sum(dim=0) if beta_needs_grad else None\n\n #### Gradient wrt gamma ####\n grad_gamma = (input_norm*grad_output).sum(dim=0) if gamma_needs_grad else None\n \n #### Gradient wrt input ####\n term1 = N*grand_input_norm \n term2 = torch.sum(grand_input_norm, dim=0)\n term3 = input_norm*torch.sum(grand_input_norm*input_norm, dim=0)\n grad_input = (1. / N) * ivar * (term1 - term2 - term3) if input_needs_grad else None\n\n ########################\n # END OF YOUR CODE #\n #######################\n\n # return gradients of the three tensor inputs and None for the constant eps\n return grad_input, grad_gamma, grad_beta, None","def backward(self, gradient):\n #TODO\n pass","def backward(self, gradient):\n #TODO\n pass","def forward_backward_prop(data, labels, params, dimensions):\n\n ### Unpack network parameters (do not modify)\n ofs = 0\n Dx, H, Dy = (dimensions[0], dimensions[1], dimensions[2])\n\n activation = []\n\n W1 = np.reshape(params[ofs:ofs+ Dx * H], (Dx, H))\n ofs += Dx * H\n b1 = np.reshape(params[ofs:ofs + H], (1, H))\n ofs += H\n W2 = np.reshape(params[ofs:ofs + H * Dy], (H, Dy))\n ofs += H * Dy\n b2 = np.reshape(params[ofs:ofs + Dy], (1, Dy))\n\n ### Forward propagation\n activation.append(data)\n\n # Hidden layer inputs: (N, Dx) * (Dx, H) -> N x H\n z = np.dot(activation[-1], W1) + b1 \n # Activations, inputs to the final layer. \n activation.append(sigmoid(z)) # output of the hidden layer, activation\n # Final layer outputs: ( N x H ) * ( H, Dy) -> (N, Dy)\n z = np.dot(activation[-1], W2) + b2\n activation.append( softmax(z) )\n\n # Cross-entropy cost\n\n y_p = activation[-1]\n activation = activation[:-1] # remove activation data (output)\n\n cost = -np.sum(labels * np.log(y_p))\n \n error = []\n \n ### backward propagation\n sigma = (y_p - labels)\n error.append(sigma)\n\n gradb2 = np.sum(error[-1], axis=0)\n gradW2 = np.dot(activation[-1].T, error[-1])\n\n #\n sigma = np.dot(W2, error[-1].T)\n sigma = sigma.T * sigmoid_grad(activation[-1])\n activation = activation[:-1] # remove activation data ( hidden layer )\n\n error.append(sigma)\n\n gradb1 = np.sum(error[-1], axis=0)\n gradW1 = np.dot(activation[-1].T, error[-1])\n\n\n ### Stack gradients (do not modify)\n grad = np.concatenate((gradW1.flatten(), gradb1.flatten(), \n gradW2.flatten(), gradb2.flatten()))\n \n return cost, grad","def backward_pass(self):\r\n # the gradient of cross-entropy on top of softmax is (t-y)\r\n back_output = (self.targets - self.y) / self.y.shape[0]\r\n\r\n for layer in reversed(self.layers):\r\n back_output = layer.backward_pass(back_output)","def backward(ctx, G):\n backend = ctx.backend\n aliases = ctx.aliases\n formula = ctx.formula\n signature = ctx.signature\n sum_index = ctx.sum_index\n args = ctx.saved_tensors # Unwrap the saved variables\n\n # number of arguments (including parameters)\n nvars = 0;\n for sig in signature[1:]:\n nvars += 1\n\n # If formula takes 5 variables (numbered from 0 to 4), then the gradient\n # wrt. the output, G, should be given as a 6-th variable (numbered 5),\n # with the same dim-cat as the formula's output.\n eta = \"Var(\" + str(nvars) + \",\" + str(signature[0][0]) + \",\" + str(signature[0][1]) + \")\"\n grads = [] # list of gradients wrt. args;\n arg_ind = 5 # current arg index (4 since backend, ... are in front of the tensors); \n var_ind = 0 # current Variable index;\n\n for sig in signature[1:]: # Run through the actual parameters, given in *args in the forward.\n if not ctx.needs_input_grad[arg_ind]: # If the current gradient is to be discarded immediatly...\n grads.append(None) # Don't waste time computing it.\n else: # Otherwise, the current gradient is really needed by the user:\n # adding new aliases is waaaaay too dangerous if we want to compute\n # second derivatives, etc. So we make explicit references to Var<ind,dim,cat> instead.\n var = \"Var(\" + str(var_ind) + \",\" + str(sig[0]) + \",\" + str(sig[1]) + \")\" # V\n formula_g = \"Grad(\" + formula + \",\" + var + \",\" + eta + \")\" # Grad<F,V,G>\n args_g = args + (G,) # Don't forget the gradient to backprop !\n \n # N.B.: if I understand PyTorch's doc, we should redefine this function every time we use it?\n genconv = GenericSum().apply\n\n if sig[1] == 2: # we're referring to a parameter, so we'll have to sum both wrt 'i' and 'j'\n sumindex_g = 1 # The first sum will be done wrt 'i'\n signature_g = [ [sig[0],1] ] + signature[1:] + signature[:1]\n grad = genconv(backend, aliases, formula_g, signature_g, sumindex_g, *args_g)\n # Then, sum 'grad' wrt 'j' :\n # I think that \".sum\"'s backward introduces non-contiguous arrays,\n # and is thus non-compatible with GenericSum:\n # grad = grad.sum(0) \n # We replace it with a \"handmade hack\" :\n grad = Variable(torch.ones(1, grad.shape[0]).type_as(grad.data)) @ grad\n grad = grad.view(-1)\n else :\n # sumindex is \"the index that stays in the end\", not \"the one in the sum\"\n # (It's ambiguous, I know... But it's the convention chosen by Joan, which makes\n # sense if we were to expand our model to 3D tensors or whatever.)\n sumindex_g = sig[1] # The sum will be \"eventually indexed just like V\".\n signature_g = [sig] + signature[1:] + signature[:1]\n grad = genconv(backend, aliases, formula_g, signature_g, sumindex_g, *args_g)\n grads.append(grad)\n\n # increment the Variable counts\n arg_ind += 1 ; var_ind += 1 \n\n # Grads wrt. backend, aliases, formula, signature, sum_index, *args\n return (None, None, None, None, None, *grads)","def _backward(loss):\n\n loss.backward()","def backward(self, gradient: Tensor) -> Tensor:\n self.b_grad = np.sum(gradient, axis=0)\n self.w_grad = self.inputs.T @ gradient\n return gradient @ self.w.T","def backward(self, input_train, input_train_label):\n batchSize = len(input_train) #liczba obrazow podawanych na wejscie w trakcie jednej iteracji\n weights = self.Weights\n biases = self.Biases\n delta_W = self.delta_W\n delta_B = self.delta_B\n poolParams = self.poolParams\n dW_list = []\n dB_list = []\n dW4 = np.zeros(weights[4].shape)\n dB4 = np.zeros(biases[4].shape)\n dW3 = np.zeros(weights[3].shape)\n dB3 = np.zeros(biases[3].shape)\n dW2 = np.zeros(weights[2].shape)\n dB2 = np.zeros(biases[2].shape)\n dW1 = np.zeros(weights[1].shape)\n dB1 = np.zeros(biases[1].shape)\n dW0 = np.zeros(weights[0].shape)\n dB0 = np.zeros(biases[0].shape)\n loss = 0\n for image in range(batchSize):\n\n X_data = input_train[image]\n X_label = input_train_label[image]\n output_forward, cache = self.forward(X_data) \n loss += -1*sum(X_label - np.log(output_forward)) #obliczenie wartosci funkcji straty [cross entropy]\n\n #Propagacja wsteczna gradientu\n dy = -1*(X_label - output_forward)/2\n #print(\"X_label = {} \\t layer7 = {} \\t dy = {}\".format(X_label, output_forward, dy))\n\n [dy, dW, dB ] = fullycon_b(cache[6], np.asarray([dy]).transpose() , weights[4])\n dW4 += dW\n dB4 += dB.flatten() #wektoryzacja macierzy\n dy = act.relu_b(dy.transpose(), cache[6])\n\n [dy, dW, dB ] = fullycon_b(cache[5][:,0], dy, weights[3])\n dW3 += dW\n dB3 += dB.flatten()\n dy = act.relu_b(dy.transpose(), cache[5][:,0]) \n \n [dy, dW, dB ] = convolution_b(cache[4], dy, weights[2])\n dW2 += dW\n dB2 += dB.flatten()\n \n dy = maxpool_b(cache[3], dy)\n dy = act.relu_b(dy, cache[3])\n\n [dy, dW, dB ] = convolution_b(cache[2], dy, weights[1])\n dW1 += dW\n dB1 += dB.flatten()\n \n dy = maxpool_b(cache[1], dy)\n dy = act.relu_b(dy, cache[1]) \n\n [dy, dW, dB ] = convolution_b(np.asarray([cache[0]]), dy, weights[0])\n dW0 += dW\n dB0 += dB.flatten()\n\t\t\t\n dW_list.append(dW4)\n dB_list.append(dB4)\n dW_list.append(dW3)\n dB_list.append(dB3)\n dW_list.append(dW2)\n dB_list.append(dB2)\n dW_list.append(dW1)\n dB_list.append(dB1)\n dW_list.append(dW0)\n dB_list.append(dB0)\n dW_list = dW_list[::-1]\n dB_list = dB_list[::-1]\n \n #Aktualizacja parametrow kazdej z warstw (o ile takie posiada)\n #uczenie z metoda momentum: learning rate = const; alpha = const\n for x in range(len(dW_list)):\n delta_W[x] = alpha*delta_W[x] - eta*dW_list[x]/batchSize\n weights[x] += delta_W[x]\n delta_B[x] = alpha*delta_B[x] - eta*dB_list[x]/batchSize\n biases[x] += delta_B[x]\n #przypisanie nowych wag po aktualiacji wszystkich parametrow\n self.Weights = weights\n self.Biases = biases\n\n #zwrocenie stosunku wartosci f-cji straty do rozmiaru batch'u\n return loss/batchSize","def backward_pass(self, delta):\n\n a = config['learning_rate']\n y = config['momentum_gamma']\n m = config['momentum']\n l = config['L2_penalty']\n\n # print(\"shape of delta incoming: \", delta.shape, \"shape of x: \", self.x.shape)\n self.d_x = delta.T @ self.x\n # print(\"SHAPE OF GRADIENT: \", self.d_x.shape)\n\n # gradient momentum\n self.w_inc = (a * self.d_x.T) + (y * self.d_v) - l * self.w\n \n # saving \n if m:\n self.d_v = self.w_inc\n else:\n self.d_v = np.zeros(self.w.shape)\n\n # backprop for bias weights\n x_0 = np.ones([len(delta), 1])\n\n self.d_b = delta.T @ x_0\n\n # print(\"shape of BIAS GRAD: \", self.d_b.shape)\n\n self.d_w = delta @ self.w.T\n # print(\"shape of w.T: \", self.w.T.shape, \"shape of RETURN delta: \", self.d_w.shape)\n #print(self.w.shape)\n return self.d_w","def backward(self, inputs, gradients, **kwargs):\n grad_relu = inputs > 0\n return gradients * grad_relu","def backward_and_step(self, loss):\n self.opt.zero_grad()\n loss.backward()\n self.opt.step()","def backward_step(activations, targets, layers):\n param_grads = collections.deque() # List of parameter gradients for each layer\n output_grad = None # The error gradient at the output of the current layer\n # Propagate the error backwards through all the layers.\n # Use reversed to iterate backwards over the list of layers.\n for layer in reversed(layers): \n Y = activations.pop() # Get the activations of the last layer on the stack\n # Compute the error at the output layer.\n # The output layer error is calculated different then hidden layer error.\n if output_grad is None:\n input_grad = layer.get_input_grad(Y, targets)\n else: # output_grad is not None (layer is not output layer)\n input_grad = layer.get_input_grad(Y, output_grad)\n # Get the input of this layer (activations of the previous layer)\n X = activations[-1]\n # Compute the layer parameter gradients used to update the parameters\n grads = layer.get_params_grad(X, output_grad)\n param_grads.appendleft(grads)\n # Compute gradient at output of previous layer (input of current layer):\n output_grad = input_grad\n return list(param_grads) # Return the parameter gradients","def backward(ctx, grad_output):\n\n # This is a pattern that is very convenient - at the top of backward\n # unpack saved_tensors and initialize all gradients w.r.t. inputs to\n # None. Thanks to the fact that additional trailing Nones are\n # ignored, the return statement is simple even when the function has\n # optional inputs.\n # input, weight, bias = ctx.saved_variables\n\n return grad_output","def forward_backward_prop(data, labels, params, dimensions):\n\n ### Unpack network parameters (do not modify)\n ofs = 0\n Dx, H, Dy = (dimensions[0], dimensions[1], dimensions[2])\n\n W1 = np.reshape(params[ofs:ofs+ Dx * H], (Dx, H))\n ofs += Dx * H\n b1 = np.reshape(params[ofs:ofs + H], (1, H))\n ofs += H\n W2 = np.reshape(params[ofs:ofs + H * Dy], (H, Dy))\n ofs += H * Dy\n b2 = np.reshape(params[ofs:ofs + Dy], (1, Dy))\n\n ### YOUR CODE HERE: forward propagation\n affine_1 = np.dot(data, W1) + b1\n sigmoid_1 = sigmoid(affine_1)\n affine_2 = np.dot(sigmoid_1, W2) + b2\n scores = sigmoid(affine_2)\n cost = - np.sum(np.multiply(np.log(softmax(scores)), labels))\n ### END YOUR CODE\n \n ### YOUR CODE HERE: backward propagation\n cross_entropy_grad_ = cross_entropy_grad(scores, labels)\n sigmoid_2_grads = sigmoid_input_grad(cross_entropy_grad_, scores)\n x_2_grad, gradW2, gradb2 = affine_grads(sigmoid_2_grads, sigmoid_1, W2, b2)\n sigmoid_1_grads = sigmoid_input_grad(x_2_grad, sigmoid_1)\n x_1_grad, gradW1, gradb1 = affine_grads(sigmoid_1_grads, data, W1, b1)\n ### END YOUR CODE\n \n ### Stack gradients (do not modify)\n grad = np.concatenate((gradW1.flatten(), gradb1.flatten(), \n gradW2.flatten(), gradb2.flatten()))\n return cost, grad","def backward_gradient(\n self, input: np.ndarray, head_gradients: Dict[str, np.ndarray]\n ) -> np.ndarray:\n raise NotImplementedError","def backprop(x, y, biases, weights, cost, num_layers):\n # initial zero list for store gradient of biases and weights\n nabla_b = [np.zeros(b.shape) for b in biases]\n nabla_w = [np.zeros(w.shape) for w in weights]\n activations = [np.zeros(w.shape) for w in biases]\n\n ### Implement here\n # feedforward\n # Here you need to store all the activations of all the units\n # by feedforward pass\n ###\n activations.insert(0,x)\n for layer in range(1,num_layers):\n activations[layer]=sigmoid(np.dot(weights[layer-1],activations[layer-1])+biases[layer-1])\n\n # compute the gradient of error respect to output\n # activations[-1] is the list of activations of the output layer\n delta = (cost).delta(activations[-1], y) \n \n ### Implement here\n # backward pass\n # Here you need to implement the backward pass to compute the\n # gradient for each weight and bias\n ###\n for k in range(num_layers,1,-1):\n delta=delta*sigmoid_prime(activations[k-1])\n nabla_b[k-2]=delta\n nabla_w[k-2]=np.dot(delta,activations[k-2].T)\n delta=np.dot(weights[k-2].T,delta)\n \n\n return (nabla_b, nabla_w)","def backward(self, inGradient, lr=0.001): # batchSize = 1\n wGradient = np.dot(inGradient.T, self.data)\n bGradient = np.sum(inGradient, axis=0)\n outGradient = np.dot(inGradient, self.weights)\n\n self.weights = self.weights - lr * wGradient\n self.bias = self.bias - lr * bGradient\n self.wGradient = wGradient\n self.bGradient = bGradient\n\n #print \"weight gradient \", wGradient\n #print \"bias gradient \", bGradient\n\n return outGradient","def backward(self, grad_out):\n\n # *********************************************\n # check this with torch.autograd.gradcheck !!!!\n # *********************************************\n\n k, a, m, y, targets = self.saved_tensors\n b = 1.0 - a\n\n features = y.numpy()\n labels = targets.numpy()\n\n loss, counts, centers, l_intra, inter_indices, l_inter, d = self.compute_loss(features, labels, k.numpy(), a.numpy(), b.numpy(), m.numpy())\n\n grad_inter = torch.FloatTensor(y.size())\n grad_intra = torch.FloatTensor(y.size())\n\n idx1 = inter_indices[0]\n idx2 = inter_indices[1]\n grad_inter[idx1] = torch.from_numpy(0.5 / (counts[idx1]) * np.abs(centers[idx1] - centers[idx2]))\n grad_inter[idx2] = torch.from_numpy(0.5 / (counts[idx2]) * np.abs(centers[idx2] - centers[idx1]))\n\n # compute intra class gradients with respect to xi, xj\n # only nonzero for these two values\n\n # *********************************************************\n # HOW TO COMPUTE GRADIENTS WITH RESPECT TO MULTIPLE SAMPLES\n # WHEN LOSS IS JUST COMPUTED OVERALL????\n # *********************************************************\n\n for idx in range(y.size()[1]):\n denom = np.array([np.power(d[idx,0]*np.sum(d[idx,:]),2)])\n grad = 2*k.double() / torch.from_numpy(denom)\n for entry in range(y.size()[0]):\n grad_intra[entry, idx] = grad[0]\n\n # compute inter class gradients with respect to xq, xr\n # only nonzero for these two values\n\n # ****************************************\n # SOMEHOW THE GRADIENT IS WAY TOO BIG ****\n # ****************************************\n grad_in = a*grad_intra + b*grad_inter\n print(grad_in)\n return grad_in, torch.DoubleTensor([0]), torch.DoubleTensor([0]), torch.DoubleTensor([0]), torch.DoubleTensor([0])","def backward_G(self):\n # Calculate regularzation loss to make transformed feature and target image feature in the same latent space\n self.loss_reg_gen = self.loss_reg * self.opt.lambda_regularization\n\n # Calculate l1 loss \n loss_app_gen = self.L1loss(self.img_gen, self.input_P2)\n self.loss_app_gen = loss_app_gen * self.opt.lambda_rec \n \n # parsing loss\n label_P2 = self.label_P2.squeeze(1).long()\n #print(self.input_SPL2.min(), self.input_SPL2.max(), self.parsav.min(), self.parsav.max())\n self.loss_par = self.parLoss(self.parsav,label_P2)# * 20. \n self.loss_par1 = self.L1loss(self.parsav, self.input_SPL2) * 100 \n\n # Calculate GAN loss\n base_function._freeze(self.net_D)\n D_fake = self.net_D(self.img_gen)\n self.loss_ad_gen = self.GANloss(D_fake, True, False) * self.opt.lambda_g\n\n # Calculate perceptual loss\n loss_content_gen, loss_style_gen = self.Vggloss(self.img_gen, self.input_P2) \n self.loss_style_gen = loss_style_gen*self.opt.lambda_style\n self.loss_content_gen = loss_content_gen*self.opt.lambda_content\n\n total_loss = 0\n\n for name in self.loss_names:\n if name != 'dis_img_gen':\n #print(getattr(self, \"loss_\" + name))\n total_loss += getattr(self, \"loss_\" + name)\n total_loss.backward()","def backward(self):\n gradient = blah\n return gradient","def backward(self):\n gradient = blah\n return gradient","def backward(self):\n #initiate the gradients\n #print('')\n \n #print('node {} grad {}'.format(self.id, self.gradient))\n #print('node {} times visited : {}/{}'.format(self.id, self.times_visited, self.times_used))\n\n if self.gradient is None:\n self.gradient=np.eye(self.output_dim)\n self.times_visited+=1\n\n \n \n if self.childrens==[]:\n return(self.gradient)\n else:\n self.backward()\n \n else: \n if self.childrens!=[]:\n #we can still going deeper in backprop\n #print(len(self.childrens), ' childrens', str([self.childrens[i]['node'].id for i in range(len(self.childrens))]))\n for child in self.childrens:\n node,jacobian=child['node'], child['jacobian']\n \n new_grad = np.dot(self.gradient, jacobian)\n #print(node.gradient)\n #print(new_grad)\n \n if node.gradient is None:\n node.gradient = new_grad\n else: \n node.gradient += new_grad\n \n node.times_visited+=1\n #print('looking at node {} \\ngradient {}'.format(node.id, node.gradient))\n\n \n if node.times_used ==node.times_visited: \n #print(node.gradient)\n node.backward() \n else:\n #still some computations to perform upwards before going deeped\n #print('node {} visits : {}/{}'.format(node.id, node.times_visited, node.times_used))\n pass","def backward_pass(total_loss):\n\n # Get the tensor that keeps track of step in this graph or create one if not there\n global_step = tf.train.get_or_create_global_step()\n\n # Print summary of total loss\n tf.summary.scalar('Total_Loss', total_loss)\n\n # Decay the learning rate\n dk_steps = int((FLAGS.epoch_size / FLAGS.batch_size) * 75)\n lr_decayed = tf.train.cosine_decay_restarts(FLAGS.learning_rate, global_step, dk_steps)\n\n # Compute the gradients. NAdam optimizer came in tensorflow 1.2\n opt = tf.contrib.opt.NadamOptimizer(learning_rate=lr_decayed, beta1=FLAGS.beta1,\n beta2=FLAGS.beta2, epsilon=0.1)\n\n # Compute the gradients\n gradients = opt.compute_gradients(total_loss)\n\n # Apply the gradients\n train_op = opt.apply_gradients(gradients, global_step, name='train')\n\n # Add histograms for the trainable variables. i.e. the collection of variables created with Trainable=True\n for var in tf.trainable_variables():\n tf.summary.histogram(var.op.name, var)\n\n # Maintain average weights to smooth out training\n variable_averages = tf.train.ExponentialMovingAverage(FLAGS.moving_avg_decay, global_step)\n\n # Applies the average to the variables in the trainable ops collection\n variable_averages_op = variable_averages.apply(tf.trainable_variables())\n\n with tf.control_dependencies([train_op, variable_averages_op]): # Wait until we apply the gradients\n dummy_op = tf.no_op(name='train') # Does nothing. placeholder to control the execution of the graph\n\n return dummy_op","def backward(ctx, grad_L):\n A, T = ctx.saved_tensors\n\n grad_A = None\n grad_T = None\n\n B = A.shape[0]\n\n # We only need to compute gradients for tensors that are flagged to\n # require gradients!\n if ctx.needs_input_grad[0]:\n grad_A = (A - T) / B\n\n if ctx.needs_input_grad[1]:\n grad_T = (T - A) / B\n\n return grad_A, grad_T","def backward(self, d_out):\n # TODO: Implement backward pass\n # Compute both gradient with respect to input\n # and gradients with respect to W and B\n # Add gradients of W and B to their `grad` attribute\n\n # It should be pretty similar to linear classifier from\n # the previous assignment\n \n dW = np.dot(self.X.T, d_out);\n dB = np.dot(np.ones((1, d_out.shape[0])), d_out);\n \n d_input = np.dot(d_out, self.W.value.T);\n #print(\"self.X = \", self.X);\n #print(\"self.W.grad.T = \", self.W.grad.T);\n #print(\"dW.T = \", dW.T);\n \n self.W.grad += dW;\n self.B.grad += dB;\n \n return d_input;","def backward(\n self, X: np.ndarray, y: np.ndarray, lr: float, reg: float = 0.0\n ) -> float:\n y_hat = self.forward(X)\n\n y_one_hot = self.one_hot_encode(y)\n loss = CrossEntropy.forward(y_one_hot, y_hat)\n\n d_layer = CrossEntropy.backward(y, y_hat)\n\n w_grads = []\n b_grads = []\n\n for idx, layer in reversed(list(enumerate(self.layers))):\n # Not output layer\n if (idx + 1) < len(self.layers):\n next_layer = self.layers[idx + 1]\n\n d_layer = d_layer.dot(next_layer.w.T)\n d_layer = layer.activation_func.backward(d_layer, layer.activated_out)\n\n d_w = layer.linear_in.T.dot(d_layer) + 2 * reg * layer.w\n d_b = np.sum(d_layer, axis=0)\n\n w_grads.insert(0, d_w)\n b_grads.insert(0, d_b)\n\n self.optimizer.step(self.layers, w_grads, b_grads, lr)\n\n if self.norm_weights:\n w_norm = max(np.linalg.norm(l.w) for l in self.layers) / len(self.layers)\n b_norm = max(np.linalg.norm(l.w) for l in self.layers) / len(self.layers)\n for layer in self.layers:\n layer.w /= w_norm\n layer.b /= b_norm\n\n return loss","def backward(self, out_grad, input):\n raise NotImplementedError","def compute_loss_and_gradients(self, X, y):\n # Before running forward and backward pass through the model,\n # clear parameter gradients aggregated from the previous pass\n # TODO Set parameter gradient to zeros\n # Hint: using self.params() might be useful!\n self.fulllayer1.W.grad = np.zeros_like(self.fulllayer1.W.grad)\n self.fulllayer1.B.grad = np.zeros_like(self.fulllayer1.B.grad)\n self.fulllayer2.W.grad = np.zeros_like(self.fulllayer2.W.grad)\n self.fulllayer2.B.grad = np.zeros_like(self.fulllayer2.B.grad)\n\n\n # TODO Compute loss and fill param gradients\n # by running forward and backward passes through the model\n res = self.fulllayer1.forward(X)\n res2 = self.reglayer1.forward(res)\n res3 = self.fulllayer2.forward(res2)\n\n loss, grad = softmax_with_cross_entropy(res3, y)\n\n back3 = self.fulllayer2.backward(grad)\n back2 = self.reglayer1.backward(back3)\n back = self.fulllayer1.backward(back2)\n \n # After that, implement l2 regularization on all params\n # Hint: self.params() is useful again!\n\n for params in self.params().keys():\n # print(params)\n # print(self.params()[params].value)\n loc_loss, loc_grad = l2_regularization(self.params()[params].value, self.reg)\n loss += loc_loss\n self.params()[params].grad += loc_grad\n\n return loss","def backward(self, lhs: Tensor, rhs: Tensor, acc_grad: np.ndarray):\n raise NotImplementedError","def backward(self, grad, **kwargs):\n if not self._iszero:\n self._product = grad * reduce(lambda x, y: x*y, (var.data for n, var in enumerate(self.variables)))\n else:\n self._product = None\n\n for index, var in enumerate(self.variables):\n if not var.constant:\n self.backward_var(grad, index)","def backward_step_matrix_version(activations, targets, layers):\n param_grads = collections.deque() # List of parameter gradients for each layer\n \n output_grad = None # The error gradient at the output of the current layer\n # Propagate the error backwards through all the layers.\n # Use reversed to iterate backwards over the list of layers.\n for i, layer in enumerate(reversed(layers)):\n cur_layer_idx = len(layers) - i - 1\n if cur_layer_idx <= NUM_LAYERS_SKIP:\n # implement short circuit here\n if layer.is_fc_layer:\n grads = [0.0 for _ in range(layer.W.shape[0]*layer.W.shape[1]+layer.W.shape[1])]\n else:\n # normal gradient computation \n Y = activations.pop() # Get the activations of the last layer on the stack\n # Compute the error at the output layer.\n # The output layer error is calculated different then hidden layer error.\n if output_grad is None:\n input_grad = layer.get_input_grad(Y, targets)\n else: # output_grad is not None (layer is not output layer)\n input_grad = layer.get_input_grad(Y, output_grad)\n # Get the input of this layer (activations of the previous layer)\n X = activations[-1]\n # Compute the layer parameter gradients used to update the parameters\n grads = layer.get_params_grad(X, output_grad)\n # we do one extra gradient reshape step here:\n if layer.is_fc_layer:\n grads_new = np.array(grads).reshape((layer.get_shape[0]+1, layer.get_shape[1]))\n param_grads.appendleft(grads_new)\n else:\n param_grads.appendleft(grads)\n # Compute gradient at output of previous layer (input of current layer):\n output_grad = input_grad\n return list(param_grads) # in this way, `param_grads` will be a list which contains grads of numpy ndarray","def backward_D(self):\n self.loss_D.backward()","def backward(self, loss):\n global_timer.my_timer.start_profile(\"BWD\")\n mgr = PatrickStarManager()\n mgr.set_training_stage(TrainingStage.BWD)\n\n for param_fp16 in self.client.chunk_based_param_fp16:\n param_fp16.ps_attr.bwd_used_cnt = 0\n\n self.optimizer.zero_grad()\n if self.loss_scaler:\n self.loss_scaler.backward(loss)\n else:\n loss.backward()\n mgr.update_margin_mem()\n global_timer.my_timer.finish_profile(\"BWD\")","def backward(ctx, grad_output):\n if PROFILE:\n batch_tic = time.time()\n tic = time.time()\n timings = defaultdict(float)\n\n feats1, feats2, xxyy, batch_grid_u, params, pow = ctx.saved_tensors\n\n \"\"\"We needed to store the integers as part of a tensor, so the\n unpacking code here is a little convoluted.\"\"\"\n B, C, H, W, stride, norm = [x.item() for x in params]\n h, w = H, W\n pow = pow.item()\n\n \"\"\"This is a pattern that is very convenient - at the top of backward\n unpack saved_tensors and initialize all gradients w.r.t. inputs to\n None. Thanks to the fact that additional trailing Nones are\n ignored, the return statement is simple even when the function has\n optional inputs.\"\"\"\n grad_feats1 = grad_feats2 = grad_xxyy = grad_batch_u = None\n grad_stride = grad_norm = grad_pow = None\n\n \"\"\"Returning gradients for inputs that don't require it is\n not an error.\"\"\"\n assert ctx.needs_input_grad[0], \"expected feats1 to need grad\"\n assert ctx.needs_input_grad[1], \"expected feats2 to need grad\"\n assert not ctx.needs_input_grad[2], \"expected xxyy does not need grad\"\n assert not ctx.needs_input_grad[3], \"expected batch_grid_u does not need grad\"\n assert not ctx.needs_input_grad[4], \"expected stride does not need grad\"\n\n if PROFILE:\n timings[\"back-init\"] = time.time() - tic\n tic = time.time()\n\n with torch.no_grad():\n\n if feats1.is_cuda:\n # TODO: clean up types here\n if feats1.dtype == torch.float32:\n grad_feats1 = torch.cuda.FloatTensor(B, C, H, W).fill_(0)\n grad_feats2 = torch.cuda.FloatTensor(B, C, h, w).fill_(0)\n elif feats1.dtype == torch.float16:\n grad_feats1 = torch.cuda.HalfTensor(B, C, H, W).fill_(0)\n grad_feats2 = torch.cuda.HalfTensor(B, C, h, w).fill_(0)\n else:\n grad_feats1 = torch.zeros((B, C, H, W), dtype=feats1.dtype)\n grad_feats2 = torch.zeros((B, C, h, w), dtype=feats2.dtype)\n\n grad_loss = grad_output / (H * W * B)\n\n if PROFILE:\n timings[\"data transfer\"] = time.time() - batch_tic\n\n for b in range(B):\n\n if PROFILE:\n tic = time.time()\n\n with torch.no_grad():\n diff = batch_grid_u[b, :, :, None, None, :] - \\\n xxyy[None, None, ::stride, ::stride, :]\n diff = (diff * diff).sum(4).sqrt()\n diff = diff.pow(pow)\n\n if PROFILE:\n timings[\"diff-grid\"] += time.time() - tic\n tic = time.time()\n\n # loss gradient for the current minibatch element (expand to tensor)\n grad_loss_b = grad_loss\n grad_smcorr2 = grad_loss_b * diff\n\n if LOCAL_CHECKS:\n ones = torch.ones(diff.shape, dtype=diff.dtype)\n grad_loss_b_ = ones * grad_loss\n smcorr_ = torch.randn(\n diff.shape,\n dtype=torch.double,\n requires_grad=True)\n with torch.autograd.enable_grad():\n L_ = diff * smcorr_\n d_smcorr = torch.autograd.grad(\n outputs=L_,\n inputs=smcorr_,\n grad_outputs=grad_loss_b_,\n )\n rel_diff(grad_smcorr2, d_smcorr[0], \"smax\")\n if torch.any(torch.isnan(grad_smcorr2[0])):\n import ipdb; ipdb.set_trace()\n\n\n if PROFILE:\n timings[\"scale-feats\"] += time.time() - tic\n tic = time.time()\n\n # Re-compute intermediate values\n grad_smcorr2 = grad_smcorr2.view(H, W, -1)\n f1_ = feats1[b].view(C, H * W)\n f2_ = feats2[b].view(C, h * w)\n fa_ = feats1[(b + 1) % B].reshape(C, h * w) # auxiliary\n\n if norm:\n f1_norm = F.normalize(f1_, p=2, dim=0) * JDT_FACTOR\n f2_norm = F.normalize(f2_, p=2, dim=0) * JDT_FACTOR\n fa_norm = F.normalize(fa_, p=2, dim=0) * JDT_FACTOR\n else:\n f1_norm = f1_.clone()\n f2_norm = f2_.clone()\n fa_norm = fa_.clone()\n\n if PROFILE:\n timings[\"fwd-norm\"] += time.time() - tic\n tic = time.time()\n\n # Match the source features against the auxiliaries\n corr = torch.matmul(f1_norm.t(), fa_norm)\n corr = corr.reshape(H, W, h, w)\n\n if PROFILE:\n timings[\"f1-aux-correlation\"] += time.time() - tic\n tic = time.time()\n\n smcorr = F.softmax(corr.view(H, W, -1), dim=2)\n smcorr = smcorr.view(corr.shape)\n if LOCAL_CHECKS:\n # cache a copy of the mega tensor for numerical checks\n smcorr_fa = smcorr[None, ...] * fa_norm.view(-1, 1, 1, h, w)\n f1_via_fa = smcorr_fa.sum((3, 4))\n else:\n \"\"\"This is one of the largest tensors.....\"\"\"\n f1_via_fa = (smcorr[None, ...] *\n fa_norm.view(-1, 1, 1, h, w)).sum((3, 4))\n\n f1_via_fa = f1_via_fa.view(C, H * W)\n\n # Main correlation computation\n corr2 = torch.matmul(f1_via_fa.t(), f2_norm).view(corr.shape)\n\n # Direct backward pass for second softmax\n smcorr2 = F.softmax(corr2.view(H, W, -1), dim=2)\n sum_term = torch.sum(grad_smcorr2 * smcorr2, dim=2, keepdim=True)\n grad_corr2 = smcorr2 * (grad_smcorr2 - sum_term)\n\n if not LOCAL_CHECKS:\n del smcorr2\n\n if PROFILE:\n timings[\"softmax\"] += time.time() - tic\n tic = time.time()\n\n # safety checks\n if LOCAL_CHECKS:\n with torch.enable_grad():\n corr2_num = corr2.clone().requires_grad_()\n corr2_num = corr2_num.reshape(H, W, -1)\n smcorr2_num = F.softmax(corr2_num, dim=2)\n grad_corr2_num = torch.autograd.grad(\n outputs=smcorr2_num,\n inputs=(corr2_num,),\n grad_outputs=grad_smcorr2,\n )\n rel_diff(grad_corr2, grad_corr2_num[0], \"smax-corr2\")\n\n \"\"\"Derivatives through the main correlation correlation\"\"\"\n grad_corr2 = grad_corr2.view(H * W, H * W)\n grad_f1_via_fa = torch.matmul(grad_corr2, f2_norm.t()).t()\n grad_f2_norm = torch.matmul(f1_via_fa, grad_corr2)\n\n if not LOCAL_CHECKS:\n del grad_corr2\n\n if PROFILE:\n timings[\"corr-back\"] += time.time() - tic\n tic = time.time()\n\n if LOCAL_CHECKS:\n with torch.enable_grad():\n f1_via_fa_num = f1_via_fa.clone().requires_grad_()\n f2_norm_num = f2_norm.clone().requires_grad_()\n corr2_num = torch.matmul(f1_via_fa_num.t(), f2_norm_num)\n grad_f1_via_fa_num, grad_f2_norm_num = torch.autograd.grad(\n outputs=corr2_num,\n inputs=(f1_via_fa_num, f2_norm_num),\n grad_outputs=grad_corr2,\n )\n rel_diff(grad_f1_via_fa, grad_f1_via_fa_num,\n \"corr-f1-via-fa\")\n rel_diff(grad_f2_norm, grad_f2_norm_num,\n \"corr->f2-norm\")\n\n if OLD_METHOD:\n # (may be able to collapse all this later)\n grad_f1_via_fa = grad_f1_via_fa.view(-1, H, W, 1, 1)\n\n # This tensor is crashing the GPU\n grad_smcorr_fa = grad_f1_via_fa.repeat(1, 1, 1, h, w)\n\n # safety checks over the summation\n if LOCAL_CHECKS:\n with torch.enable_grad():\n\n smcorr_fa_num = smcorr_fa.clone().requires_grad_()\n f1_via_fa_num = smcorr_fa_num.sum((3, 4))\n # f1_via_fa_num = f1_via_fa_num.view(C, H * W)\n\n grad_smcorr_fa_num = torch.autograd.grad(\n outputs=f1_via_fa_num,\n inputs=(smcorr_fa_num,),\n grad_outputs=grad_f1_via_fa.view(-1, H, w),\n )\n rel_diff(grad_smcorr_fa, grad_smcorr_fa_num[0],\n \"summation of grad_smcorr-fa\")\n\n # smcorr_fa = smcorr[None, ...] * fa_.view(-1, 1, 1, h, w)\n grad_smcorr = (grad_smcorr_fa * fa_norm.view(-1, 1, 1, h, w)).sum(0)\n grad_fa_ = (grad_smcorr_fa * smcorr[None, ...]).sum(1).sum(1)\n grad_fa_ = grad_fa_.reshape(C, h * w)\n\n # safety checks over the weighted sum\n if LOCAL_CHECKS:\n with torch.enable_grad():\n\n smcorr_num = smcorr.clone().requires_grad_()\n fa_norm_num = fa_norm.clone().requires_grad_()\n smcorr_fa_num = smcorr_num[None, ...] \\\n * fa_norm_num.view(-1, 1, 1, h, w)\n\n (grad_smcorr_num, grad_fa_num) = torch.autograd.grad(\n outputs=smcorr_fa_num,\n inputs=(smcorr_num, fa_norm_num),\n grad_outputs=grad_smcorr_fa,\n )\n rel_diff(grad_fa_, grad_fa_num,\n \"product of grad_fa_\")\n rel_diff(grad_smcorr, grad_smcorr_num,\n \"product of grad_smcor\")\n else:\n # -------------------------------------------------------\n # Collapsed summation method\n # -------------------------------------------------------\n # Fwd ops ->\n # smcorr_fa = smcorr[None, ...] * fa.reshape(-1, 1, 1, h, w)\n # f1_via_fa = smcorr_fa.sum((3, 4)).reshape(C, H * w)\n\n # Given gradient ->\n # (grad_f1_via_fa)\n\n # Desired gradients ->\n # (grad_fa_, grad_smcorr)\n\n grad_f1_via_fa = grad_f1_via_fa.view(-1, H, W, 1, 1)\n\n # safety checks over the summation\n if LOCAL_CHECKS:\n # This tensor is crashing the GPU, so should only be\n # used for numerical checks\n grad_smcorr_fa = grad_f1_via_fa.repeat(1, 1, 1, h, w)\n with torch.enable_grad():\n\n smcorr_fa_num = smcorr_fa.clone().requires_grad_()\n f1_via_fa_num = smcorr_fa_num.sum((3, 4))\n # f1_via_fa_num = f1_via_fa_num.view(C, H * W)\n\n grad_smcorr_fa_num = torch.autograd.grad(\n outputs=f1_via_fa_num,\n inputs=(smcorr_fa_num,),\n grad_outputs=grad_f1_via_fa.view(-1, H, w),\n )\n rel_diff(grad_smcorr_fa, grad_smcorr_fa_num[0],\n \"summation of grad_smcorr-fa\")\n\n # Use for-loop over EVC dimension to avoid memory issues\n if feats1.is_cuda:\n if grad_f1_via_fa.dtype == torch.float64:\n grad_smcorr = torch.cuda.DoubleTensor(H, W, h, w).fill_(0)\n grad_fa_ = torch.cuda.DoubleTensor(C, h, w).fill_(0)\n else:\n grad_smcorr = torch.cuda.FloatTensor(H, W, h, w).fill_(0)\n grad_fa_ = torch.cuda.FloatTensor(C, h, w).fill_(0)\n else:\n grad_smcorr = torch.zeros((H, W, h, w), dtype=feats1.dtype)\n grad_fa_ = torch.zeros((C, h, w), dtype=feats1.dtype)\n\n for cc in range(C):\n grad_smcorr += (grad_f1_via_fa[cc] * fa_norm[cc].view(1, 1, h, w))\n grad_fa_[cc] = (grad_f1_via_fa[cc] * smcorr).sum((0, 1))\n grad_fa_ = grad_fa_.reshape(C, h * w)\n\n # safety checks over the weighted sum\n if LOCAL_CHECKS:\n with torch.enable_grad():\n\n smcorr_num = smcorr.clone().requires_grad_()\n fa_norm_num = fa_norm.clone().requires_grad_()\n smcorr_fa_num = smcorr_num[None, ...] \\\n * fa_norm_num.view(-1, 1, 1, h, w)\n\n (grad_smcorr_num, grad_fa_num) = torch.autograd.grad(\n outputs=smcorr_fa_num,\n inputs=(smcorr_num, fa_norm_num),\n grad_outputs=grad_smcorr_fa,\n )\n rel_diff(grad_fa_, grad_fa_num,\n \"product of grad_fa_\")\n rel_diff(grad_smcorr, grad_smcorr_num,\n \"product of grad_smcor\")\n\n if PRINT_MEM:\n key = None\n val = None\n shape_mems = {}\n for key, val in locals().items():\n if hasattr(val, \"shape\"):\n shape_mems[key] = estimate_mem(val)\n\n sorted_mems = sorted(shape_mems.items(), key=lambda kv: -kv[1])\n for key, val in sorted_mems:\n print(\"{}: {:.4f} GiB\".format(key, val))\n\n # Direct backward pass for first softmax\n # smcorr = F.softmax(corr.view(H, W, -1), dim=2)\n grad_smcorr = grad_smcorr.view(H, W, -1)\n smcorr = smcorr.view(H, W, -1)\n sum_term = torch.sum(grad_smcorr * smcorr, dim=2, keepdim=True)\n grad_corr = smcorr * (grad_smcorr - sum_term)\n\n if not LOCAL_CHECKS:\n del grad_smcorr\n del grad_smcorr2\n del smcorr\n del corr\n\n if LOCAL_CHECKS:\n with torch.enable_grad():\n corr_num = corr.clone().requires_grad_()\n smcorr_num = F.softmax(corr_num.view(H, W, -1), dim=2)\n smcorr_num = smcorr_num.reshape(corr_num.shape)\n grad_corr_num = torch.autograd.grad(\n outputs=smcorr_num,\n inputs=(corr_num,),\n grad_outputs=grad_smcorr.view(H, W, h, w),\n )\n rel_diff(grad_corr, grad_corr_num[0].view(H, W, -1),\n \"smax-corr\")\n\n # Back through the first correlation\n # [Fwd op] -> `corr = torch.matmul(f1_norm.t(), fa_norm)`\n grad_corr = grad_corr.view(H * W, h * w)\n grad_f1_norm = torch.matmul(grad_corr, fa_norm.t()).t()\n grad_fa_norm = torch.matmul(f1_norm, grad_corr)\n\n if not LOCAL_CHECKS:\n del grad_corr\n\n\n if LOCAL_CHECKS:\n with torch.enable_grad():\n f1_norm_num = f1_norm.clone().requires_grad_()\n fa_norm_num = fa_norm.clone().requires_grad_()\n corr_num = torch.matmul(f1_norm_num.t(), fa_norm_num)\n grad_f1_norm_num, grad_fa_norm_num = torch.autograd.grad(\n outputs=corr_num,\n inputs=(f1_norm_num, fa_norm_num),\n grad_outputs=grad_corr,\n )\n rel_diff(grad_f1_norm, grad_f1_norm_num, \"corr->f1n-orm\")\n rel_diff(grad_fa_norm, grad_fa_norm_num, \"corr->fa-norm\")\n\n # Combine gradients for two ops using aux features\n grad_fa_norm = grad_fa_norm + grad_fa_\n\n # Back through the norms\n # [Fwd op] -> `f1_norm = F.normalize(f1_, p=2, dim=0) * JDT_FACTOR`\n # [Fwd op] -> `f2_norm = F.normalize(f2_, p=2, dim=0) * JDT_FACTOR`\n # [Fwd op] -> `fa_norm = F.normalize(fa_, p=2, dim=0) * JDT_FACTOR`\n # xNorm = sqrt(sum(x.*x, 3) + opts.epsilon) ;\n\n if norm:\n f1_norm_val = torch.norm(f1_, p=2, dim=0).clamp(min=EPS)\n f2_norm_val = torch.norm(f2_, p=2, dim=0).clamp(min=EPS)\n fa_norm_val = torch.norm(fa_, p=2, dim=0).clamp(min=EPS)\n\n max_val_f1 = torch.max(f1_norm_val)\n max_val_f2 = torch.max(f2_norm_val)\n max_val_fa = torch.max(fa_norm_val)\n if max_val_f1 + max_val_f2 + max_val_fa > 1E8:\n import ipdb; ipdb.set_trace()\n\n grad_f1_norm_ = grad_f1_norm / f1_norm_val\n grad_f1 = JDT_FACTOR * (grad_f1_norm_ -\n (grad_f1_norm_ * f1_).sum(0) * (f1_ / (f1_norm_val ** 2)))\n\n grad_f2_norm_ = grad_f2_norm / f2_norm_val\n grad_f2 = JDT_FACTOR * (grad_f2_norm_ -\n (grad_f2_norm_ * f2_).sum(0) * (f2_ / (f2_norm_val ** 2)))\n\n grad_fa_norm_ = grad_fa_norm / fa_norm_val\n grad_fa = JDT_FACTOR * (grad_fa_norm_ -\n (grad_fa_norm_ * fa_).sum(0) * (fa_ / (fa_norm_val ** 2)))\n\n if LOCAL_CHECKS:\n with torch.enable_grad():\n f1_num = f1_.clone().requires_grad_()\n f2_num = f2_.clone().requires_grad_()\n fa_num = fa_.clone().requires_grad_()\n\n f1_norm_num = F.normalize(f1_num, p=2, dim=0) * JDT_FACTOR\n f2_norm_num = F.normalize(f2_num, p=2, dim=0) * JDT_FACTOR\n fa_norm_num = F.normalize(fa_num, p=2, dim=0) * JDT_FACTOR\n\n grad_f1_num = torch.autograd.grad(\n outputs=f1_norm_num,\n inputs=(f1_num,),\n grad_outputs=grad_f1_norm,\n )\n grad_f2_num = torch.autograd.grad(\n outputs=f2_norm_num,\n inputs=(f2_num,),\n grad_outputs=grad_f2_norm,\n )\n grad_fa_num = torch.autograd.grad(\n outputs=fa_norm_num,\n inputs=(fa_num,),\n grad_outputs=grad_fa_norm,\n )\n rel_diff(grad_f1, grad_f1_num[0], \"norm-f1\")\n rel_diff(grad_f2, grad_f2_num[0], \"norm-f2\")\n rel_diff(grad_fa, grad_fa_num[0], \"norm-fa\")\n else:\n grad_f1 = grad_f1_norm\n grad_f2 = grad_f2_norm\n grad_fa = grad_fa_norm\n\n\n if PRINT_MEM:\n key = None\n val = None\n shape_mems = {}\n print(\"=======================\")\n for key, val in locals().items():\n if hasattr(val, \"shape\"):\n shape_mems[key] = estimate_mem(val)\n\n sorted_mems = sorted(shape_mems.items(), key=lambda kv: -kv[1])\n for key, val in sorted_mems:\n print(\"{}: {:.4f} GiB\".format(key, val))\n import ipdb; ipdb.set_trace()\n\n\n # safety checks over the whole inner loop\n if LOCAL_CHECKS:\n with torch.enable_grad():\n\n f1_num = feats1[b].clone().detach().requires_grad_().reshape(C, H * W)\n f2_num = feats2[b].clone().detach().requires_grad_().reshape(C, h * w)\n fa_num = feats1[(b + 1) % B].clone().detach().requires_grad_().reshape(C, h * w)\n\n if norm:\n f1_norm_num = F.normalize(f1_num, p=2, dim=0) * JDT_FACTOR\n f2_norm_num = F.normalize(f2_num, p=2, dim=0) * JDT_FACTOR\n fa_norm_num = F.normalize(fa_num, p=2, dim=0) * JDT_FACTOR\n else:\n f1_norm_num = f1_num\n f2_norm_num = f2_num\n fa_norm_num = fa_num\n\n # BLock 1 ------------------------------------------\n corr_num = torch.matmul(f1_norm_num.t(), fa_norm_num)\n corr_num = corr_num.reshape(H, W, H, W)\n smcorr_num = F.softmax(corr_num.reshape(H, W, -1), dim=2)\n smcorr_num = smcorr_num.reshape(corr_num.shape)\n # BLock 1 ------------------------------------------\n\n\n # BLock 2 ------------------------------------------\n smcorr_fa_num = smcorr_num[None, ...] * \\\n fa_norm_num.reshape(-1, 1, 1, h, w)\n # BLock 2 ------------------------------------------\n\n\n # BLock 3 ------------------------------------------\n f1_via_fa_num = smcorr_fa_num.sum((3, 4)).reshape(C, H * W)\n # BLock 3 ------------------------------------------\n\n # BLock 4 ------------------------------------------\n corr2_num = torch.matmul(f1_via_fa_num.t(), f2_norm_num)\n corr2_num = corr2_num.reshape(corr_num.shape)\n smcorr2_num = F.softmax(corr2_num.reshape(H, W, -1), dim=2)\n smcorr2_num = smcorr2_num.reshape(corr_num.shape)\n # BLock 4 ------------------------------------------\n\n grad_f1_num, grad_fa_num, grad_f2_num = torch.autograd.grad(\n outputs=(smcorr2_num,),\n inputs=(f1_num, fa_num, f2_num),\n grad_outputs=(grad_smcorr2.view(corr_num.shape)),\n )\n\n rel_diff(grad_f1, grad_f1_num, \"df1_\")\n rel_diff(grad_f2, grad_f2_num, \"df2_\")\n rel_diff(grad_fa, grad_fa_num, \"dfa_\")\n\n \"\"\"Distribute the gradients back among the input tensor\n features that require them.\"\"\"\n grad_feats1[b] += grad_f1.reshape((C, H, W))\n grad_feats1[(b + 1) % B] += grad_fa.reshape((C, h, w))\n grad_feats2[b] += grad_f2.reshape((C, h, w))\n\n if PROFILE:\n timings[\"feat-assign\"] += time.time() - tic\n\n\n if LOCAL_CHECKS_INNER_LOOP:\n with torch.enable_grad():\n loss = 0.\n grad_loss_ = grad_loss * (H * W * B) # unscale\n for b in range(B):\n f1 = feats1[b].reshape(C, H * W) # source\n f2 = feats2[b].reshape(C, h * w) # target\n fa = feats1[(b + 1) % B].reshape(C, h * w) # auxiliary\n\n if norm:\n f1 = F.normalize(f1, p=2, dim=0) * JDT_FACTOR\n f2 = F.normalize(f2, p=2, dim=0) * JDT_FACTOR\n fa = F.normalize(fa, p=2, dim=0) * JDT_FACTOR\n\n corr = torch.matmul(f1.t(), fa)\n corr = corr.reshape(H, W, h, w)\n smcorr = F.softmax(corr.reshape(H, W, -1), dim=2).reshape(corr.shape)\n smcorr_fa = smcorr[None, ...] * fa.reshape(-1, 1, 1, h, w)\n # del smcorr\n\n f1_via_fa = smcorr_fa.sum((3, 4)).reshape(C, H * w)\n # del smcorr_fa\n\n corr2 = torch.matmul(f1_via_fa.t(), f2).reshape(corr.shape)\n smcorr2 = F.softmax(corr2.reshape(H, W, -1), dim=2).reshape(corr.shape)\n # del corr2\n\n with torch.no_grad():\n diff = batch_grid_u[b, :, :, None, None, :] - \\\n xxyy[None, None, ::stride, ::stride, :]\n diff = (diff * diff).sum(4).sqrt()\n diff = diff.pow(pow)\n L = diff * smcorr2\n loss += L.float().sum()\n\n loss = loss / (H * W * B)\n grad_f1_num, grad_f2_num = torch.autograd.grad(\n outputs=loss,\n inputs=(feats1, feats2),\n grad_outputs=grad_loss_,\n )\n\n rel_diff(grad_feats1, grad_f1_num, \"full-loop f2\")\n rel_diff(grad_feats2, grad_f2_num, \"full-loop f2\")\n\n if PROFILE:\n tic = time.time()\n\n if PRINT_MEM:\n key = None\n val = None\n shape_mems = {}\n for key, val in locals().items():\n if hasattr(val, \"shape\"):\n shape_mems[key] = estimate_mem(val)\n\n sorted_mems = sorted(shape_mems.items(), key=lambda kv: -kv[1])\n for key, val in sorted_mems:\n print(\"{}: {:.4f} GiB\".format(key, val))\n\n if PROFILE:\n timings[\"cleanup\"] += time.time() - tic\n\n if PROFILE:\n timings[\"minibatch\"] = time.time() - batch_tic\n print(\"==============\")\n total_ratios = 0\n for key in timings:\n ratio = 100 * timings[key] / timings[\"minibatch\"]\n msg = \"{:.3f} ({:.2f}%) >>> {}\"\n print(msg.format(timings[key], ratio, key))\n total_ratios += ratio\n msg = \"{:.3f}s >>> ratio total {}\"\n print(msg.format(timings[\"minibatch\"], total_ratios - 100))\n print(\"==============\")\n\n return (grad_feats1, grad_feats2, grad_xxyy, grad_batch_u,\n grad_stride, grad_norm, grad_pow)","def on_iter_backward(self, runner):\n runner.optimizer.zero_grad()\n runner.loss.backward()\n runner.optimizer.step()","def _backprop(self, y_train, X_train, A_hidden, Z_hidden, A_out, Z_out, batch_idx):\n\n # This is the derivative assuming our costfunction is 0.5*two_norm(A_out - y)**2\n # This results in different backpropagation \n \n error_out = A_out - y_train[batch_idx].reshape(len(y_train[batch_idx]), 1)\n \n # Since we are in the regression case with a linear ouput funct.\n act_derivative_out = 1\n\n delta_out = error_out*act_derivative_out\n\n grad_w_out = np.dot(A_hidden[-1].T, delta_out)\n grad_b_out = np.sum(delta_out, axis=0)\n\n # Updating the output weights \n self.W_out = self.W_out - self.eta * grad_w_out\n self.b_out = self.b_out - self.eta * grad_b_out\n \n \n # Looping over all the hidden layers except one\n # If the layer only have one layer it doesn't go into this while loop \n \n i = 0\n while (i < self.n_hidden_layers-1):\n # Index moving backward in the layers.\n #print(\"this should only be one loop\")\n layer_ind = self.n_hidden_layers - 1 - i\n #print(\"layer_ind: : \", layer_ind)\n act_derivative_h = self.activate(Z_hidden[layer_ind], self.activation, deriv=True)\n \n if (i == 0):\n error_prev = np.dot(delta_out, self.W_out.T) * act_derivative_h\n else:\n #print(\"np.shape(error_prev)\", np.shape(error_prev))\n error_prev = np.dot(error_prev, self.W_h[layer_ind+1].T) * act_derivative_h\n \n grad_w_h = np.dot(A_hidden[layer_ind - 1].T, error_prev)\n grad_b_h = np.sum(error_prev, axis=0)\n \n self.W_h[layer_ind] = self.W_h[layer_ind] - self.eta * grad_w_h\n self.b_h[layer_ind] = self.b_h[layer_ind] - self.eta * grad_b_h\n i += 1\n \n \n act_derivative_h = self.activate(Z_hidden[0], self.activation, deriv=True) \n \n # Case with one hidden layer doesn't enter the while loop.\n if( self.n_hidden_layers == 1):\n error_last = np.dot(delta_out, self.W_out.T) * act_derivative_h\n else:\n error_last = np.dot(error_prev, self.W_h[layer_ind].T) * act_derivative_h\n\n grad_w_h = np.dot(X_train[batch_idx].T, error_last)\n grad_b_h = np.sum(error_last, axis = 0)\n\n self.W_h[0] = self.W_h[0] - self.eta * grad_w_h\n self.b_h[0] = self.b_h[0] - self.eta * grad_b_h\n\n return None","def backward_pass(self, grad):\n pass","def compute_loss_and_gradients(self, X, y):\n # TODO Compute loss and fill param gradients\n # by running forward and backward passes through the model","def backward_G(self):\n self.loss_G.backward()","def backward(ctx, grad_output):\n loss, reg, u, lbda = ctx.saved_tensors\n\n device = u.device\n\n # do clever computations\n eps = 1e-10\n grad, = torch.autograd.grad(loss, u, only_inputs=True,\n retain_graph=True)\n x = (u - eps * grad).data\n lbda = lbda.data\n\n prox_x = check_tensor(\n np.array([prox_tv.tv1_1d(xx, eps * lbda) for xx in x]),\n device=device,\n )\n grad_u = (u - prox_x) / eps\n grad_lbda = reg.clone()\n return (torch.ones(0), grad_u, grad_lbda)","def backward(self, grad):\n self.grads[\"w\"] = np.matmul(self.input_data.T, grad)\n self.grads[\"b\"] = np.sum(grad, axis=0)\n return np.matmul(self.input_data.T, grad)","def backwards(delta,params,name='',activation_deriv=sigmoid_deriv):\n # everything you may need for this layer\n W = params['W' + name]\n b = params['b' + name]\n X, pre_act, post_act = params['cache_' + name]\n # your code here\n # do the derivative through activation first\n # then compute the derivative W,b, and X\n \n delta_pre = activation_deriv(post_act) * delta\n # (in_dim, out_dim) = (in_dim, examples) @ (examples, out_dim)\n grad_W = X.transpose() @ delta_pre\n grad_b = np.sum(delta_pre, axis=0, keepdims=True) # (1, out_dim)\n # (examples, in_dim) = (examples, out_dim) @ (out_dim, in_dim)\n grad_X = delta_pre @ W.transpose()\n\n # store the gradients\n params['grad_W' + name] = grad_W\n params['grad_b' + name] = grad_b\n return grad_X","def backward(ctx, grad_A):\n Z, = ctx.saved_tensors\n\n grad_Z = None\n\n # We only need to compute gradients for tensors that are flagged to\n # require gradients!\n if ctx.needs_input_grad[0]:\n sigmoid = 1. / (1. + torch.exp(-Z))\n grad_Z = grad_A * sigmoid * (1. - sigmoid)\n\n return grad_Z","def backward(self, accum_grad):\n\n W = self.W\n\n grad_w = self.layer_input.T.dot(accum_grad)\n grad_b = np.sum(accum_grad, axis=0, keepdims=True)\n\n # Update the layer weights\n self.W = self.W_optimizer.update(self.W, grad_w)\n self.b = self.b_optimizer.update(self.b, grad_b)\n\n accum_grad = accum_grad.dot(W.T)\n return accum_grad","def backward(self, d_out):\n # TODO: Implement backward pass\n # Compute both gradient with respect to input\n # and gradients with respect to W and B\n # Add gradients of W and B to their `grad` attribute\n\n # It should be pretty similar to linear classifier from\n # the previous assignment\n\n d_input = np.dot(d_out, self.W.value.T)\n self.W.grad = np.dot(self.X.T, d_out)\n self.B.grad = np.sum(d_out, axis=0, keepdims=True)\n\n return d_input","def unrolled_backward(self, trn_X, trn_y, val_X, val_y, lr, w_optim, amended: bool = False):\n # do virtual step (calc w`)\n self.virtual_step(trn_X, trn_y, lr, w_optim)\n\n # calc unrolled loss\n normal_alphas, reduce_alphas = self.v_net.alpha_weights()\n loss = self.v_net.loss(val_X, val_y) # L_val(w`)\n\n # Loss += SUM[ none - mean(others) ]\n loss += self.normal_none_penalty * sum([(alpha[:, -1] - alpha[:, :-1].mean()).sum() for alpha in normal_alphas])\n loss += self.reduce_none_penalty * sum([(alpha[:, -1] - alpha[:, :-1].mean()).sum() for alpha in reduce_alphas])\n\n # compute gradient\n v_alphas = tuple(self.v_net.alphas())\n v_weights = tuple(self.v_net.weights())\n v_grads = torch.autograd.grad(loss, v_alphas + v_weights)\n dalpha = v_grads[:len(v_alphas)]\n dw = v_grads[len(v_alphas):]\n\n hessian = self.amended_gradient(dw, trn_X, trn_y) if amended else self.compute_hessian(dw, trn_X, trn_y)\n\n # update final gradient = dalpha - lr*hessian\n with torch.no_grad():\n for alpha, da, h in zip(self.net.alphas(), dalpha, hessian):\n alpha.grad = da - lr * h","def L_model_backward(AL, Y, caches):\n grads = {}\n L = len(caches) # the number of layers\n m = AL.shape[1]\n Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL\n\n dAL = -(np.divide(Y,AL)-np.divide(1-Y,1-AL))\n \"\"\"\n cache = caches[-1]\n grads[\"dA\"+str(L)],grads[\"dW\"+str(L)],grads[\"db\"+str(L)] = linear_activation_backward(dAL,cache,activation = 'sigmoid')\n\n for i in reversed(range(L-1)):\n grads[\"dA\"+str(i+1)],grads[\"dW\"+str(i+1)],grads[\"db\"+str(i+1)] = linear_activation_backward(grads[\"dA\"+str(i+2)],caches[i],activation = 'relu')\n \"\"\"\n\n current_cache = caches[-1]\n grads[\"dA\" + str(L)], grads[\"dW\" + str(L)], grads[\"db\" + str(L)] = linear_backward(sigmoid_backward(dAL, current_cache[1]),current_cache[0])\n\n for l in reversed(range(L - 1)):\n # lth layer: (RELU -> LINEAR) gradients.\n # Inputs: \"grads[\"dA\" + str(l + 2)], caches\". Outputs: \"grads[\"dA\" + str(l + 1)] , grads[\"dW\" + str(l + 1)] , grads[\"db\" + str(l + 1)]\n ### START CODE HERE ### (approx. 5 lines)\n current_cache = caches[l]\n dA_prev_temp, dW_temp, db_temp = linear_backward(sigmoid_backward(dAL, current_cache[1]), current_cache[0])\n grads[\"dA\" + str(l + 1)] = dA_prev_temp\n grads[\"dW\" + str(l + 1)] = dW_temp\n grads[\"db\" + str(l + 1)] = db_temp\n ### END CODE HERE ###\n\n return grads","def backward(self, loss, update_hp_grads=True, clear_lp_grads=False, **bwd_kwargs):\n self.clear_lp_grads()\n loss.backward(**bwd_kwargs)\n\n if update_hp_grads:\n self.update_hp_grads(clear_lp_grads=clear_lp_grads)","def forward_backward_prop(data, labels, params, dimensions):\n\n ### Unpack network parameters (do not modify)\n ofs = 0\n Dx, H, Dy = (dimensions[0], dimensions[1], dimensions[2])\n\n W1 = np.reshape(params[ofs:ofs+ Dx * H], (Dx, H))\n ofs += Dx * H\n b1 = np.reshape(params[ofs:ofs + H], (1, H))\n ofs += H\n W2 = np.reshape(params[ofs:ofs + H * Dy], (H, Dy))\n ofs += H * Dy\n b2 = np.reshape(params[ofs:ofs + Dy], (1, Dy))\n\n #print W2.shape, b2.shape\n\n #print len(W1), data[0], b1, len(data)\n\n ### YOUR CODE HERE: forward propagation\n #Eg, find the cost function. Save some intermediate stuff though, seems like it'd be useful\n #h = sigmoid(x * w1 + b1)\n # y = (softmax( h * w2 + b2)\n # hence the cost function will be labels * log(y) and then sum it all up\n\n z_1 = np.matrix(data) * W1 + b1\n h = sigmoid(z_1)\n y_prime = softmax(h * W2 + b2)\n logs = np.log(y_prime)\n\n #print y_prime.shape\n\n #print np.array(logs) * labels\n\n cost = - np.sum(np.array(logs) * labels, axis = 1)\n cost = np.sum(cost) # lets add up each instance fo the cost for now and see what happens\n\n # My question is then do we just sum up the costs of each function\n #print cost #somethign is printing so I'm gonan say i'm a genius right here duh\n\n #Cost(y, y') = -sum of (y * log Y')\n ### END YOUR CODE\n\n ### YOUR CODE HERE: backward propagation\n\n # you'll need gradients for each parameter except for the input vectors. Right now this isn't even a word2vec\n delta_1 = y_prime - labels\n delta_2 = delta_1 * W2.T\n #print sigmoid_grad(h).shape\n delta_3 = np.array(delta_2) * sigmoid_grad(h)\n\n gradW2 = np.array(h.T * delta_1) # i dunno or its reverse OMG I HASTE EVERYONE why is it that np.array fixes everything. Sigh\n gradb2 = np.array(np.sum(delta_1, axis=0)) # main issue is that this is a 20 x 5 vector when it should be a 1 x 5\n gradW1 = data.T.dot(delta_3)\n gradb1 = np.sum(delta_3, axis=0) # this should be 1 x10 not 20 x 5\n\n\n\n ### END YOUR CODE\n\n #print gradW1, gradW1.flatten()\n # print 'jee'\n\n ### Stack gradients (do not modify)\n grad = np.concatenate((\n gradW1.flatten(),\n gradb1.flatten(),\n gradW2.flatten(),\n gradb2.flatten())\n )\n #print grad\n #print cost\n return cost, grad","def backward(self, d_out):\n # TODO: Implement backward pass\n # Compute both gradient with respect to input\n # and gradients with respect to W and B\n # Add gradients of W and B to their `grad` attribute\n\n # It should be pretty similar to linear classifier from\n # the previous assignment\n self.W.grad += np.dot(self.X.T, d_out)\n self.B.grad += np.sum(d_out, axis=0)[np.newaxis, :]\n return np.dot(d_out, self.W.value.T)","def backward(self, grad_output):\n raise NotImplementedError","def backward(self, grad=None):\n if not self.requires_grad:\n raise RuntimeError(\"This tensor did not require grad!\")\n grad = self._to_tensor(grad) if grad else Tensor(np.ones_like(self.data, dtype=np.float))\n self.grad.data += grad.data\n for node in self.nodes:\n node.tensor.backward(Tensor(data=node.df(grad.data)))","def backward(self, grad_z):\n\t\t#######################################################################\n\t\t# ** START OF YOUR CODE **\n\t\t#######################################################################\n\n\t\tgradient = self._layers[-1].backward(grad_z)\n\t\tfor i in range(len(self._layers) - 2, -1, -1):\n\t\t\tgradient = self._layers[i].backward(gradient)\n\t\treturn gradient\n\n\t\t#######################################################################\n\t\t# ** END OF YOUR CODE **\n\t\t#######################################################################","def backward(self, y_grad):\n self.b_grad = y_grad.sum(axis=0)\n dim = len(self.b_grad)\n self.b_grad = self.b_grad.reshape((1, dim))\n self.W_grad = (np.dot(np.transpose(y_grad), self.x))\n\n return y_grad.dot(self.W)","def backward(ctx, grad_output_var):\n xmin = 0\n xmax = 1\n grad_output = grad_output_var.data\n gamma_mu,kappa,uTx,x = ctx.saved_tensors\n n = kappa.size()[0]\n nx = grad_output.size()[2]\n u = 1/nx**2*torch.linspace(1,nx,nx)\n norm_u = torch.norm(u)**2\n torch_u = u.view(1,1,-1)+torch.zeros(n,1,nx)#broadcast\n denom = (xmin-kappa)*(xmax-kappa)\\\n -(kappa-uTx)*(xmin+xmax-2*kappa)\\\n -2*gamma_mu*norm_u \n #\n idx = (denom.abs()>1e-7)\n ind = (denom.abs()>1e-7)+ torch.zeros(n,1,nx)#broadcasting\n ind = ind>0\n denom[~idx] = denom[~idx]+1\n grad_input_gamma_mu = (2*kappa-(xmin+xmax))/denom*torch_u\n coeff = (xmax-kappa)*(xmin-kappa)/denom - 1\n grad_input_u = torch.eye(nx) \\\n +coeff*torch.matmul(torch_u.view(1,1,-1,1),u.view(1,-1))/norm_u\n # if denom is very small, it means that gamma_mu is very small and u is very close to one of the bounds,\n # there is a discontinuity when gamma_mu tends to zero, if 0<u<1 the derivative wrt x is approximately equal to \n # 1 and the derivative wrt gamma_mu is approximated by 10^3 times the error 2kappa-xmin-xmax\n grad_input_gamma_mu[~ind] = 0*grad_input_gamma_mu[~ind]+1e3*(2*kappa[~idx]-(xmin+xmax))\n grad_input_u[~ind] = 0*grad_input_u[~ind]+1\n \n grad_input_gamma_mu = grad_input_gamma_mu*grad_output#.sum(1).sum(1).unsqueeze(1).unsqueeze(2)\n grad_input_u = grad_input_u*grad_output\n \n # safety check for numerical instabilities\n if (grad_input_gamma_mu!=grad_input_gamma_mu).any():\n print('there is a nan in grad_input_gamma_mu')\n if (x!=x).any():\n print('there is a nan in x')\n sys.exit()\n if (grad_input_u!=grad_input_u).any():\n print('there is a nan in grad_input_u')\n sys.exit()\n \n grad_input_gamma_mu = Variable(grad_input_gamma_mu,requires_grad=True)\n grad_input_u = Variable(grad_input_u,requires_grad=True)\n \n return grad_input_gamma_mu, grad_input_u, None","def backprop(model, loss_function, optimizer, batch, device):\n model.train()\n model.to(device)\n optimizer.zero_grad()\n\n inputs, targets = batch[0], batch[1]\n\n inputs = inputs.to(device)\n targets = targets.to(device)\n\n outputs = model(inputs)\n loss = loss_function(outputs, targets)\n loss.backward()\n optimizer.step()","def backward(self,y_out, y_truth):\n gradient = None\n ###########################################################################\n # TODO: #\n # Implement the backward pass. Return the gradient wrt y_out #\n # hint: you may use np.where here. #\n ###########################################################################\n\n gradient = np.where(not np.all(y_out==0), 0, 1.e-18)\n\n ###########################################################################\n # END OF YOUR CODE #\n ########################################################################### \n return gradient","def backward(ctx, grad_output):\n batch_size, n_dim = grad_output.shape\n sign_z, = ctx.saved_tensors\n device = grad_output.device\n S = sign_z != 0\n S[:, 0] = True\n sign_z[:, 0] = 0\n # XXX do clever computations\n L = torch.triu(torch.ones((n_dim, n_dim), dtype=torch.float64,\n device=device))\n\n grad_x, grad_lbda = [], []\n for i in range(batch_size):\n L_S = L[:, S[i]] # n_dim x |S|\n grad_u = grad_output[i].matmul(L_S) # 1 x |S|\n H_S = torch.inverse(L_S.t().matmul(L_S))\n grad_x.append(grad_u.matmul(H_S.matmul(L_S.t())))\n grad_lbda.append(grad_u.matmul(H_S.matmul(-sign_z[i][S[i]])))\n grad_x = torch.stack(grad_x)\n grad_lbda = torch.stack(grad_lbda)\n return (grad_x, grad_lbda)","def backward(self, outputs, labels):\n # Layers & shape\n depth = len(self.layer_dimensions) - 1\n # num_classes, batch_size = outputs.shape\n batch_size, num_classes = outputs.shape\n coefficient = 1 / batch_size\n # 1/ First case : last layer -> output\n layer_a = \"a_\" + str(depth - 1)\n a = self._cache[layer_a]\n Jz = outputs - labels\n # Weights gradients\n dw = coefficient * np.dot(a.T, Jz)\n db = coefficient * np.sum(Jz, axis=0)\n self._grad[\"dw_\" + str(depth)] = dw\n self._grad[\"db_\" + str(depth)] = db\n # 2/ Second case : inside the layers\n for i in range(depth - 1, 0, -1):\n # Get the weights and biases\n layer_w = \"w_\" + str(i + 1)\n layer_a = \"a_\" + str(i - 1)\n layer_z = \"z_\" + str(i)\n w = self._parameters[layer_w]\n a = self._cache[layer_a]\n z = self._cache[layer_z]\n # Gradients\n Jz = self.activation_hidden.backward(z) * np.dot(Jz, w.T)\n db = coefficient * np.sum(Jz, axis=0)\n dw = coefficient * np.dot(a.T, Jz)\n self._grad[\"dw_\" + str(i)] = dw\n self._grad[\"db_\" + str(i)] = db","def backward(self,y_out, y_truth):\n gradient = None\n\n ###########################################################################\n # TODO: #\n # Implement the backward pass. Return the gradient wrt y_out #\n ###########################################################################\n\n gradient = -1 * (np.multiply(y_truth, np.divide(1, y_out)) - np.multiply((1 - y_truth), np.divide(1, (1 - y_out))))\n \n ###########################################################################\n # END OF YOUR CODE #\n ########################################################################### \n return gradient","def backward(self, residuals):\n in_channel, out_channel, kernel_size, a = self.weights.shape\n dw = np.zeros_like(self.weights) \n \n for i in range(in_channel):\n for o in range(out_channel):\n dw[i, o] += inv_conv2(self.in_val[:,:,i], \n residuals[:,:,o], \n self.stride)\n\n self.db += residuals.sum(axis=1).sum(axis=0)\n self.dw += dw \n gradient_x = np.zeros_like(self.in_val)\n \n for i in range(in_channel):\n for o in range(out_channel):\n gradient_x[:,:,i] += conv_delta(residuals[:,:,o] \n , self.weights[i][o]\n , self.stride\n , self.in_val.shape[0])\n \n return gradient_x","def backward(self, index, gradOutput):\n self.gradInput = np.dot(gradOutput, self.weight.T)\n if index != -1:\n self.gradWeight[index] += gradOutput #the gradients wrt. the params are accumulated\n self.gradBias += gradOutput\n return self.gradInput","def backward(self, upstream_grad):\n\n # derivative of Cost w.r.t W\n self.dW = np.dot(upstream_grad, self.A_prev.T)\n\n # derivative of Cost w.r.t b, sum across rows\n self.db = np.sum(upstream_grad, axis=1, keepdims=True)\n\n # derivative of Cost w.r.t A_prev\n self.dA_prev = np.dot(self.params['W'].T, upstream_grad)","def backward(self,y_out, y_truth):\n gradient = None\n ###########################################################################\n # TODO: #\n # Implement the backward pass. Return the gradient wrt y_out #\n ###########################################################################\n\n gradient = np.multiply(2, np.subtract(y_out, y_truth))\n\n ###########################################################################\n # END OF YOUR CODE #\n ########################################################################### \n return gradient","def backward(self, X, Y, P, H, lmd):\n G = - (Y - P)\n _, Npts = P.shape\n n_layers = len(self.hidden_units)\n\n gradients_W = []\n gradients_b = []\n\n for i in range(n_layers, -1, -1):\n\n if i == 0:\n grad_W = G @ X.T * (1/Npts) + 2 * lmd * self.W[i]\n grad_b = G @ np.ones((Npts, 1)) * (1/Npts)\n\n else:\n\n h = H[i - 1]\n w = self.W[i]\n grad_W = G @ h.T * (1/Npts) + 2 * lmd * w\n grad_b = G @ np.ones((Npts, 1)) * (1/Npts)\n\n G = w.T @ G\n G = G * np.where(h > 0, 1, 0)\n\n gradients_W.append(grad_W)\n gradients_b.append(grad_b)\n\n return gradients_W, gradients_b","def backward(self, inputs): \n self.error = self.error * sigmoid(self.output, der=True) # because the activation function of last layer must be sigmoid\n delta3_weights = np.dot(self.z2.T, self.error)\n\n self.error = np.dot(self.error, self.output3_weights.T) * self.af(self.z2, der=True) \n delta2_weights = np.dot(self.z1.T, self.error)\n\n self.error = np.dot(self.error, self.hidden2_weights.T) * self.af(self.z1, der=True)\n delta1_weights = np.dot(inputs.T, self.error)\n\n self.hidden1_weights -= self.lr * delta1_weights\n self.hidden2_weights -= self.lr * delta2_weights\n self.output3_weights -= self.lr * delta3_weights","def compute_grad(*, model: nn.Module, loss: Tensor) -> None:\n grad_list = torch.autograd.grad(loss, tuple(model.parameters()), retain_graph=True)\n\n for param, grad in zip(model.parameters(), grad_list):\n param.grad = grad","def backward(ctx, grad_output):\n input, = ctx.saved_tensors\n\n sp = F.softplus(input)\n grad_sp = -torch.expm1(sp)\n\n tsp = F.tanh(sp)\n grad_tsp = (1 - tsp * tsp) * grad_sp\n grad = input * grad_tsp + tsp\n return grad","def back_propagate(self,y):\n if y.ndim > 1: #case of multioutput prediction\n m = np.shape(y)[0] #number of samples\n n = np.shape(y)[1] #number of output elements\n \n #calculating gradients for each layer\n for layer, activation in zip(reversed(range(len(self.architecture))), self.activations[::-1]):\n \n if layer == len(self.architecture)-1: #identifies output layer and does output layer specific calculations\n dCda_L = self.derivatives(function='mse', y_pred = self.all_data[f'A{layer}'], y= y)\n da_LdZ_L = self.derivatives(np.sum(self.all_data[f'Z{layer}'], axis=0)*(1/m),activation)\n delta_L = np.multiply(dCda_L,da_LdZ_L)\n self.all_data[f'dCda_{layer}'] = dCda_L\n self.all_data[f'da_{layer}dZ_{layer}'] = da_LdZ_L\n self.all_data[f'delta_{layer}'] = delta_L\n else: #for other layers\n da_LdZ_l = self.derivatives(np.sum(self.all_data[f'Z{layer}'], axis=0)*(1/m),activation)\n self.all_data[f'da_{layer}dZ_{layer}'] = da_LdZ_l\n delta_l = np.multiply(np.dot(self.all_data[f'delta_{layer+1}'], (self.weights_and_biases[f'W{layer+1}']).T), da_LdZ_l) \n self.all_data[f'delta_{layer}'] = delta_l\n \n dCdW_l = np.outer(np.sum(self.all_data[f'A{layer-1}'],axis=0)*(1/m),self.all_data[f'delta_{layer}'])\n dCdb_l = self.all_data[f'delta_{layer}']\n\n ##saving calculated data\n self.all_data[f'dCdW{layer}'] = dCdW_l\n self.all_data[f'dCdb{layer}'] = dCdb_l\n self.parameter_gradients[f'dCdW{layer}'] = dCdW_l\n self.parameter_gradients[f'dCdb{layer}'] = dCdb_l\n \n else: #calculations for single dataset(eg for SGD)\n m = 1\n n = len(y)\n\n ##calculating gradients for each layer\n for layer, activation in zip(reversed(range(len(self.architecture))), self.activations[::-1]):\n \n if layer == len(self.architecture)-1:\n #dCda_L = (self.all_data[f'A{layer}'] - y)*(1/(m*n))*2\n dCda_L = self.derivatives(function='mse', y_pred = self.all_data[f'A{layer}'], y=y)\n da_LdZ_L = self.derivatives(self.all_data[f'Z{layer}'],activation)\n delta_L = np.multiply(dCda_L,da_LdZ_L)\n self.all_data[f'dCda_{layer}'] = dCda_L\n self.all_data[f'da_{layer}dZ_{layer}'] = da_LdZ_L\n self.all_data[f'delta_{layer}'] = delta_L\n else:\n da_LdZ_l = self.derivatives(self.all_data[f'Z{layer}'],activation)\n self.all_data[f'da_{layer}dZ_{layer}'] = da_LdZ_l\n delta_l = np.multiply(np.dot(self.all_data[f'delta_{layer+1}'], (self.weights_and_biases[f'W{layer+1}']).T), da_LdZ_l) \n self.all_data[f'delta_{layer}'] = delta_l\n\n dCdW_l = np.outer(self.all_data[f'A{layer-1}'],self.all_data[f'delta_{layer}'])\n dCdb_l = self.all_data[f'delta_{layer}']\n\n #saving data\n self.all_data[f'dCdW{layer}'] = dCdW_l\n self.all_data[f'dCdb{layer}'] = dCdb_l\n self.parameter_gradients[f'dCdW{layer}'] = dCdW_l\n self.parameter_gradients[f'dCdb{layer}'] = dCdb_l","def gradient_descent(data_x, data_y, parameters, learn_rate, nb_iterations):\n\n # Cost history\n cost_tracking = np.zeros(nb_iterations)\n\n for _i in range(nb_iterations):\n parameters -= learn_rate * gradient(data_x, data_y, parameters)\n # recording the cost for each iteration\n cost_tracking[_i] = cost_function(data_x, data_y, parameters)\n\n return parameters, cost_tracking","def backprop(self, grad):\n # TODO: look into exploiting the symmetry of the result here\n # to speed up the calculation\n assert self.out is not None, 'must run forward() before running reverse()'\n\n grad = grad.reshape(self.work_shape)\n\n # first step is to compute the dot product between the activation levels\n # and the input gradient\n tmp = _multi_dot(grad, self.out)\n # tmp will be of shape (K,) for an (N, K) work shape\n tmp = np.broadcast_to(tmp[:, np.newaxis], self.work_shape)\n\n tmp2 = grad - tmp\n gout = self.out*tmp2\n return gout.reshape(self.in_shape)","def __backpropagation(self, X, y, alpha):\n # perform forward pass\n y_pred = self.__feed_forward(X)\n # loop over the layers backward\n for i in reversed(range(len(self.__layers))):\n layer = self.__layers[i]\n\n # output layer\n if layer == self.__layers[-1]:\n layer.error = 2 * (y_pred - y)\n # other layers\n else:\n next_layer = self.__layers[i + 1]\n layer.error = next_layer.error * next_layer.d_act_f(next_layer.p) @ next_layer.weights \n\n # update the weights\n for i in range(len(self.__layers)):\n layer = self.__layers[i]\n input_to_use = np.atleast_2d(X if i == 0 else self.__layers[i - 1].z)\n grad = (layer.error * layer.d_act_f(layer.p) * input_to_use.T)\n if layer.weights.shape[1] != grad.shape[1]: grad = grad.T\n layer.weights -= alpha * grad","def compute_gradients(self, inputs, targets, hprev):\n n = len(inputs)\n loss = 0\n\n # Dictionaries for storing values during the forward pass\n aa, xx, hh, oo, pp = {}, {}, {}, {}, {}\n hh[-1] = np.copy(hprev)\n\n # Forward pass\n for t in range(n):\n xx[t] = np.zeros((self.vocab_len, 1))\n xx[t][inputs[t]] = 1 # 1-hot-encoding\n\n aa[t], hh[t], oo[t], pp[t] = self.evaluate_classifier(hh[t-1], xx[t])\n\n loss += -np.log(pp[t][targets[t]][0]) # update the loss\n\n # Dictionary for storing the gradients\n grads = {\"W\": np.zeros_like(self.W), \"U\": np.zeros_like(self.U),\n \"V\": np.zeros_like(self.V), \"b\": np.zeros_like(self.b),\n \"c\": np.zeros_like(self.c), \"o\": np.zeros_like(pp[0]),\n \"h\": np.zeros_like(hh[0]), \"h_next\": np.zeros_like(hh[0]),\n \"a\": np.zeros_like(aa[0])}\n\n # Backward pass\n for t in reversed(range(n)):\n grads[\"o\"] = np.copy(pp[t])\n grads[\"o\"][targets[t]] -= 1\n\n grads[\"V\"] += grads[\"o\"]@hh[t].T\n grads[\"c\"] += grads[\"o\"]\n\n grads[\"h\"] = np.matmul(self.V.T , grads[\"o\"] )+ grads[\"h_next\"]\n grads[\"a\"] = np.multiply(grads[\"h\"], (1 - np.square(hh[t])))\n\n grads[\"U\"] += np.matmul(grads[\"a\"], xx[t].T)\n grads[\"W\"] += np.matmul(grads[\"a\"], hh[t-1].T)\n grads[\"b\"] += grads[\"a\"]\n\n grads[\"h_next\"] = np.matmul(self.W.T, grads[\"a\"])\n\n # Drop redundant gradients\n grads = {k: grads[k] for k in grads if k not in [\"o\", \"h\", \"h_next\", \"a\"]}\n\n # Clip the gradients\n for grad in grads:\n grads[grad] = np.clip(grads[grad], -5, 5)\n\n # Update the hidden state sequence\n h = hh[n-1]\n\n return grads, loss, h","def test_multiple_gradient_descent_with_backprop():\n layer_list = [7, 7, 7, 2]\n print(\"test\", \"layer_list\", layer_list)\n\n X, W, B = initialize_parameters_for_layers(layer_list, 5)\n\n alpha = 0.01\n num_iterations = 2000\n num_layers = len(layer_list) - 1\n\n Y = np.arange(10).reshape(2, 5)\n W, B, yhat = gradient_descent_for_n_layers(num_layers, W, B, X, Y, alpha, num_iterations)\n\n print(\"test done.\") # final W and B are\", W, \"and\", B)\n print(\"final yhat\", yhat)","def _poputil_recompute_backward(op, grads):\n return grads","def optimize(self, loss):\n loss.backward()\n self.optimizer.step()\n self.optimizer.zero_grad()","def optimize(self,gradients):\n\n for k in range(self.size):\n delta_weight = self.learningRate * gradients[k]\n full_change = delta_weight + self.momentum*self.last_change[k]\n self.weights[k] -= full_change\n self.last_change[k] = 1*gradients[k] #copy gradient mat","def backward(model, xs, h1s, h2s, errs):\n # errs is the gradients of output layer for the minibatch\n # dW4 = (np.dot(h3s.T, errs))/xs.shape[0]\n\n # # Get gradient of hidden layer\n # dh_3 = np.dot(errs, model['W4'].T)\n # dh_3[h3s <= 0] = 0\n \n # # The bias \"neuron\" is the constant 1, we don't need to backpropagate its gradient\n # # since it has no inputs, so we just remove its column from the gradient\n # dh_3 = dh_3[:, :-1]\n \n # Gradient for weights H1 -> H2\n dW3 = (np.dot(h2s.T, errs)) / xs.shape[0]\n\n dh_2 = np.dot(errs, model['W3'].T)\n dh_2[h2s <= 0] = 0\n \n # The bias \"neuron\" is the constant 1, we don't need to backpropagate its gradient\n # since it has no inputs, so we just remove its column from the gradient\n dh_2 = dh_2[:, :-1]\n \n # Gradient for weights H1 -> H2\n dW2 = (np.dot(h1s.T, dh_2)) / xs.shape[0]\n \n # Gradient of h1\n dh_1 = np.dot(dh_2, model['W2'].T)\n dh_1[h1s <= 0] = 0\n\n # Again, drop the bias column\n dh_1 = dh_1[:, :-1]\n \n # Add the 1 to the data, to compute the gradient of W1\n ones = np.ones((xs.shape[0], 1))\n xs = np.hstack([xs, ones])\n\n dW1 = (np.dot(xs.T, dh_1))/xs.shape[0]\n\n return dict(W1=dW1, W2=dW2, W3=dW3)","def backward(self, grad_output=None):\n # Compute dL/dP_j\n self.loss.backward(grad_output)\n dLdP = self.preds_enc.grad\n\n # Turn batched vector into batched matrix for matmul\n dLdP = dLdP.unsqueeze(-1)\n\n # Compute Jacobians wrt model weights\n if self.rank == self.feature_src:\n jacobians = self._compute_model_jacobians()\n\n # Populate parameter grad fields using Jacobians\n params = torch.nn.utils.parameters_to_vector(self.model.parameters())\n if self.rank == self.feature_src:\n jacobian = torch.cat(\n [jacobians[param] for param in self.model.parameters()], dim=0\n )\n else:\n jacobian_size = (params.numel(), dLdP.size(-2))\n jacobian = torch.empty(jacobian_size)\n\n jacobian = crypten.cryptensor(jacobian, src=self.feature_src)\n\n # Compute gradeints wrt each param\n while jacobian.dim() < dLdP.dim():\n jacobian = jacobian.unsqueeze(0)\n grad = jacobian.matmul(dLdP)\n grad = grad.view(-1, *(params.size()))\n\n # Compute DP noise\n if not self.rr_prob:\n # Determine noise generation function\n generate_noise = (\n self._generate_noise_from_src\n if self.noise_src\n else self._generate_noise_no_src\n )\n noise = generate_noise(params.size())\n grad += noise\n\n # Sum over batch dimension\n while grad.size() != params.size():\n grad = grad.sum(0)\n\n # Decrypt dL/dP_j * dP_j/dW_i with Differential Privacy\n grads = grad.flatten().get_plain_text(dst=self.feature_src)\n\n # Populate grad fields of parameters:\n if self.rank == self.feature_src:\n ind = 0\n for param in self.model.parameters():\n numel = param.numel()\n param.grad = grads[ind : ind + numel].view(param.size())\n ind += numel","def backward(self, delta):\n if self.activation_type == \"sigmoid\":\n grad = self.grad_sigmoid()\n\n elif self.activation_type == \"tanh\":\n grad = self.grad_tanh()\n\n elif self.activation_type == \"ReLU\":\n grad = self.grad_ReLU()\n\n return grad * delta","def back_prop_through_time(self, da, caches, batch_size, parameters):\n\n # Retrieve values from the caches\n (caches, x) = caches\n \n # Retrieve important dimensions\n n_x, n_a = self.nx, self.UNITS\n \n # initialize the gradients with the right sizes, to zeroes \n da0 = np.zeros((n_a, batch_size))\n dc_prevt = np.zeros(da0.shape)\n dWf = np.zeros((n_a, n_a + n_x))\n dWi = np.zeros(dWf.shape)\n dWc = np.zeros(dWf.shape)\n dWo = np.zeros(dWf.shape)\n dbf = np.zeros((n_a, 1))\n dbi = np.zeros(dbf.shape)\n dbc = np.zeros(dbf.shape)\n dbo = np.zeros(dbf.shape)\n \n #from the previous layer\n da_prevt = da \n\n # loop back over the whole sequence\n for t in reversed(range(self.T_x)):\n # Compute all gradients using lstm_cell_backward\n gradients = self.lstm_cell_backward(da_prevt, dc_prevt, caches[t], parameters)\n # Store or add the gradient to the parameters' previous step's gradient\n da_prevt = gradients[\"da_prev\"]\n dc_prevt = gradients[\"dc_prev\"]\n #sum up the gradients\n dWf += gradients[\"dWf\"]\n dWi += gradients[\"dWi\"]\n dWc += gradients[\"dWc\"]\n dWo += gradients[\"dWo\"]\n dbf += gradients[\"dbf\"]\n dbi += gradients[\"dbi\"]\n dbc += gradients[\"dbc\"]\n dbo += gradients[\"dbo\"]\n \n # Store the gradients in a python dictionary\n gradients = {\"dWf\": dWf,\"dbf\": dbf, \"dWi\": dWi,\"dbi\": dbi,\"dWc\": dWc,\"dbc\": dbc, \"dWo\": dWo, \"dbo\": dbo}\n\n return gradients","def compute_gradients(self):\n wlist = self._neural_net.weights()\n blist = self._neural_net.biases()\n\n nmatrices = len(wlist)\n weight_grad = []\n bias_grad = []\n\n cost_function = self._cost_function\n weight_der = WeightDerivative(neural_net=self._neural_net,\n data_src=self._data_src,\n cost_function=cost_function)\n biase_der = BiasDerivative(neural_net=self._neural_net,\n data_src=self._data_src,\n cost_function=cost_function)\n for layer in range(nmatrices):\n weight_grad.append(np.zeros(wlist[layer].shape))\n bias_grad.append(np.zeros(blist[layer].shape))\n\n rows, cols = wlist[layer].shape\n for i in range(rows):\n for j in range(cols):\n loc = ParameterLocation(layer=layer, row=i, column=j)\n weight_grad[layer][i][j] = weight_der.partial_derivative(loc)\n\n for row in range(rows):\n loc = ParameterLocation(layer=layer, row=row, column=0)\n bias_grad[layer][row] = biase_der.partial_derivative(loc)\n\n return weight_grad, bias_grad","def _update_parameters(self, loss):\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()","def backward(last_layer: str) -> Callable:\n\n def closure() -> Tuple[Optional[torch.Tensor], torch.Tensor]:\n optimizer.zero_grad()\n output = model(data)\n if last_layer == \"output\":\n output.backward(torch.ones_like(target))\n return None, output\n elif last_layer == 'loss':\n loss = compute_loss(output - target)\n loss.backward()\n return loss, output\n else:\n assert False, 'last layer must be \"output\" or \"loss\"'\n\n return closure","def backward(last_layer: str) -> Callable:\n\n def closure() -> Tuple[Optional[torch.Tensor], torch.Tensor]:\n optimizer.zero_grad()\n output = model(data)\n if last_layer == \"output\":\n output.backward(torch.ones_like(target))\n return None, output\n elif last_layer == 'loss':\n loss = compute_loss(output - target)\n loss.backward()\n return loss, output\n else:\n assert False, 'last layer must be \"output\" or \"loss\"'\n\n return closure","def backward(self, grad_of_output=None):\n if grad_of_output is None:\n grad_of_output = Tensor.ones(self.shape)\n\n if grad_of_output.shape != self.shape:\n # this block will be executed only when graient is supplied\n raise Exception('The shape of gradient and variable must match')\n\n if self.grad_fn is None:\n raise Exception('backward should not be called on tensors '\n + 'without grad_fn')\n\n return autograd.backward(self.grad_fn, grad_of_output)","def backward_linear(Data):\n\n # data\n graph = tf.Graph()\n X = Data[0]\n Y_ = Data[1]\n\n if X.shape[0] != Y_.shape[0]:\n raise Exception(\"The quantity of Input X and Compare Y_ are not same!\")\n\n Loss = []\n with graph.as_default():\n print(\"This is the process of all the Dose!\")\n print(\"There are %d data in this process.\" % X.shape[0])\n print(\"Features of X: %d\" % X.shape[1])\n print(\"Learning rate is: %f\" % learning_rate)\n # Init all the parameters\n global_step = tf.Variable(0, trainable=False)\n\n STEPS = int(Epoch * X.shape[0] / BATCH_SIZE) + 1\n epoch = 0\n\n with tf.name_scope('inputs'):\n x = tf.placeholder(tf.float32, [None, Forward.INPUT_NODE], name='x_Input')\n y_ = tf.placeholder(tf.float32, [None, Forward.OUTPUT_NODE], name='y_Exact')\n y = Forward.forward_linear(x, regularizer=None)\n\n # lost function\n with tf.name_scope('loss'):\n loss_mse = tf.reduce_mean(tf.square(y - y_))\n loss = loss_mse + tf.add_n(tf.get_collection(\"losses\"))\n tf.summary.scalar('loss', loss)\n\n # Todo\n # LM algorithm\n\n # learning_rate = tf.train.exponential_decay(\n # LEARNING_RATE_BASE,\n # global_step,\n # X.shape[0] / BATCH_SIZE,\n # LEARNING_RATE_DECAY,\n # staircase=True\n # )\n\n with tf.name_scope('train'):\n # train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step)\n # train_step = tf.train.MomentumOptimizer(learning_rate, momentum=0.9).minimize(loss, global_step)\n train_step = tf.train.AdamOptimizer(learning_rate, beta1=0.9, beta2=0.99).minimize(loss, global_step)\n\n # EMA algorithm\n ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)\n ema_op = ema.apply(tf.trainable_variables())\n with tf.control_dependencies([train_step, ema_op]):\n train_op = tf.no_op(name='train')\n\n # ready for storing the model\n saver = tf.train.Saver()\n\n with tf.Session() as sess:\n init_op = tf.global_variables_initializer()\n sess.run(init_op)\n\n # Get the check point\n ckpt = tf.train.get_checkpoint_state(MODEL_SAVE_PATH_LINEAR)\n if ckpt and ckpt.model_checkpoint_path:\n saver.restore(sess, ckpt.model_checkpoint_path)\n\n # begin multi threads\n coord = tf.train.Coordinator()\n threads = tf.train.start_queue_runners(sess, coord)\n print(\"Begin the multi threads!\")\n\n # Graph\n merged = tf.summary.merge_all()\n writer = tf.summary.FileWriter(\"./logs_linear/\", sess.graph)\n\n # Training\n for i in range(STEPS):\n start = (i * BATCH_SIZE) % int(X.shape[0])\n end = start + BATCH_SIZE\n # if finish all the data\n if end >= X.shape[0]:\n end = X.shape[0]\n\n _, loss_value, step = sess.run([train_op, loss, global_step],\n feed_dict={x: X[start:end], y_: Y_[start:end]})\n\n if i % 4000 == 0:\n print(\"Steps are: %d , loss is: %g.\" % (step, loss_value))\n rs = sess.run(merged, feed_dict={x: X[start:end], y_: Y_[start:end]})\n writer.add_summary(rs, i)\n saver.save(sess, os.path.join(MODEL_SAVE_PATH_LINEAR, MODEL_NAME), global_step)\n\n # a round\n if end == X.shape[0]:\n # get the results\n epoch += 1\n loss_total = sess.run(loss, feed_dict={x: X, y_: Y_})\n\n Loss.append(loss_total)\n # Loss.append(loss_total*10000)\n print(\"After %d epoch(s), steps are: %d, loss total is: %g.\\n\" % (epoch, step, loss_total))\n saver.save(sess, os.path.join(MODEL_SAVE_PATH_LINEAR, MODEL_NAME), global_step)\n\n # close the multi threads\n coord.request_stop()\n coord.join(threads)\n print(\"Close the multi threads!\")\n\n return Loss","def learning_by_gradient_descent(y, tx, w, gamma):\n loss = calculate_loss(y,tx,w)\n grad = calculate_gradient(y,tx,w)\n w_new = w - gamma*grad\n #grad is for debugging purpose\n return loss, w_new,grad","def backward_D(self):\n base_function._unfreeze(self.net_D)\n #print(self.input_P2.shape, self.img_gen.shape)\n self.loss_dis_img_gen = self.backward_D_basic(self.net_D, self.input_P2, self.img_gen)","def backpropagate(self, error, learning_rate):\n #assert isinstance(error, np.ndarray)\n #assert isinstance(self._prev_layer._outputs, np.ndarray)\n #assert isinstance(self._outputs, np.ndarray) \n\n # Compute deltas. \n deltas = np.dot(error, self._activation_function.derivative_given_y(self._outputs))\n \n # Compute gradient.\n synapse = np.dot(np.dot(error, self._prev_layer._outputs), learning_rate)\n \n # Adjust weights.\n self._weights = np.add(self._weights, synapse)\n \n # Adjust bias weights.\n if self._use_bias:\n self._bias = np.add(self._bias, synapse)\n \n return deltas","def backward(self, previous_grad, learning_rate):\n conv_grad = np.zeros(self.conv_filter.shape)\n for patch, i, j in self.image_patch(self.current_image):\n for k in range(self.num_filters):\n conv_grad[k] += patch*previous_grad[i,j,k]\n \n self.conv_filter -= learning_rate*conv_grad\n return conv_grad","def __backprop(self, X, Y_hat, Y):\n m = Y.shape[1]\n Y = Y.reshape(Y_hat.shape.eval())\n\n # Compute the gradient of the output layer\n dA = - ((Y / Y_hat) - ((1 - Y) / (1 - Y_hat)))\n i = len(self.layers) - 1\n while i >= 0:\n\n # Get activation of the previous layer\n A_prev = None\n if i == 0:\n A_prev = X\n else:\n A_prev = self.layers[i-1].A\n \n # Compute gradient for the next layer down\n dA = self.layers[i]._Dense__backward(dA, A_prev)\n i -= 1","def backprop(self, grad):\n self.a.backprop(self.partial_a() * grad) # backprop: dF/d(op)*d(op)/da -> dF/da\n self.b.backprop(self.partial_b() * grad)"],"string":"[\n \"def backward(self, inputs, grad_loss_input):\\n raise NotImplementedError\",\n \"def backward_pass(architecture,gradient_layerwise,grad_weights,grad_bias):\\n \\n for layer in range(len(architecture)-1,-1,-1):\\n X_input,X_output,weightsi,biasi,X_input_im2col,imi,output_shapei,kernel_shapei,stridei,operationi,imxi = architecture['layer{}'.format(layer+1)]\\n# print(\\\"Operation is:{} and Layer is: {}\\\".format(operationi,layer+1))\\n if operationi == 'softmax': # Last layer -> Dont apply softmax in any layer other than the last layer!\\n # not taking gradients here because we need dz_dX(secondlastlayer) which is y_pred - y\\n continue\\n \\n if operationi == 'conv_bn_relu' or operationi == 'conv_relu' or operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n if operationi__1 == 'softmax':\\n y_pred = architecture['layer{}'.format(layer+2)][1]\\n y_pred = torch.reshape(y_pred,y.shape)\\n dz_dXi = y_pred - y\\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi:\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n \\n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # .\\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # .\\n try:\\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input_im2col)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\\n except:\\n dz_dweightsi = (dz_dXi).mm(X_input_im2col)\\n \\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0\\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi #\\n elif operationi__1 == 'maxpool': # need to do something here to fix the problem\\n None\\n\\n elif 'flatten' in operationi__1:\\n # we currently have dz_doutput of flatten -> we want dz_doutput of the conv_bn_relu before flatten\\n \\n weightsi__1 = architecture['layer{}'.format(layer+2)][2] # weights2\\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput of flatten\\n if len(dz_dXi__1.shape) == 3:\\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\\n imi__1 = architecture['layer{}'.format(layer+2)][5] # i\\n try:\\n dz_dXi = torch.t(weightsi__1).mm(dz_dXi__1)\\n except:\\n dz_dXi = weightsi__1.mm(dz_dXi__1)\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi:\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n\\n dz_dXi = torch.reshape(dz_dXi,(output_shapei[1]*output_shapei[2],-1))\\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\\n dz_dweightsi = X_input_im2col.mm(dz_dXi)\\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\\n dz_dbi = dz_dXi\\n \\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)# Can also set this to layer like in line ~800\\n \\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi) # Can also set this to layer like in line ~800\\n \\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi) # Can also set this to layer like in line ~800\\n \\n else:\\n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dX2 -> backpropagated from maxpool\\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\\n if len(dz_dXi__1.shape) == 3:\\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\\n imi__1 = architecture['layer{}'.format(layer+2)][5]\\n try:\\n Y = weightsi__1.mm(dz_dXi__1)\\n except:\\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\\n dz_dXi = torch.zeros(X_output.shape)\\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\\n for i in range(np.shape(X_output)[0]):\\n for j in range(np.shape(X_output)[1]):\\n for k in range(np.shape(X_output)[2]):\\n idxs = getIndexes(imi__1,(i,j,k))\\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\\n \\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n if 'sigmoid' in operationi__1: # ...\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi__1: # ...\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n \\n dz_dXi = torch.reshape(dz_dXi,(output_shape_current_layer[1]*output_shape_current_layer[2],-1))\\n dz_dbi = torch.reshape(dz_dXi,bias_current_layer.shape)\\n dz_dweightsi = X_im2col_current_layer.mm(dz_dXi)\\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\\n \\n if operationi == 'maxpool':\\n \\n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput -> backpropagated from maxpool\\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\\n \\n if len(dz_dXi__1.shape) == 3:\\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\\n imi__1 = architecture['layer{}'.format(layer+2)][5]\\n try:\\n Y = weightsi__1.mm(dz_dXi__1)\\n except:\\n try:\\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\\n except:\\n Y = torch.t(weightsi__1).mm(dz_dXi__1) # Ensuring valid matrix multiplication here\\n \\n dz_dXi = torch.zeros(X_output.shape)\\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\\n for i in range(np.shape(X_output)[0]):\\n for j in range(np.shape(X_output)[1]):\\n for k in range(np.shape(X_output)[2]):\\n idxs = getIndexes(imi__1,(i,j,k))\\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\\n\\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n \\n if operationi__1 == 'conv_sigmoid' or operationi__1 == 'conv_bn_sigmoid': # ...\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n else:\\n dz_dXi[X_output <= 0] = 0\\n\\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\\n \\n dz_dXinput = torch.zeros((X_input.shape))\\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+1)][0] # output = output of maxpool\\n\\n dz_dXoutput = torch.reshape(dz_dXoutput,(output_shapei[0],X_input_im2col.shape[2]))\\n \\n for i in range(output_shapei[0]):\\n for j in range(X_input_im2col.shape[2]):\\n Xi2ci = X_im2col_current_layer[i,:,:]\\n idx = torch.argmax(Xi2ci[:,j]).item()\\n value = imxi[i][(idx,j)]\\n dz_dXinput[value[0],value[1],value[2]] += float(dz_dXoutput[i,j])\\n\\n# dz_dXinput = torch.reshape(dz_dXinput,output_shapei)\\n \\n X_prev_im2col = architecture['layer{}'.format(layer)][4]\\n X_output_prev = architecture['layer{}'.format(layer)][1]\\n X_output_prev = torch.reshape(X_output_prev,dz_dXinput.shape)\\n X_input_prev = architecture['layer{}'.format(layer)][0]\\n prev_bias = architecture['layer{}'.format(layer)][3]\\n output_shape_prev = architecture['layer{}'.format(layer)][6]\\n prev_operation = architecture['layer{}'.format(layer)][9]\\n \\n if prev_operation == 'conv_sigmoid' or prev_operation == 'conv_bn_sigmoid':\\n dz_dXinput *= sigmoid(X_output_prev)*(1-sigmoid(X_output_prev)) # Taking the derivative of the sigmoid function\\n else:\\n dz_dXinput[X_output_prev <= 0] = 0\\n \\n if len(dz_dXinput.shape) == 3:\\n dz_dXinput = torch.reshape(dz_dXinput,(-1,output_shape_prev[0]))\\n \\n dz_dbi = torch.reshape(dz_dXinput,prev_bias.shape)\\n dz_dweightsi = X_prev_im2col.mm(dz_dXinput)\\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0\\n \\n gradient_layerwise['layer{}'.format(layer)][2] = torch.Tensor(dz_dbi)\\n gradient_layerwise['layer{}'.format(layer)][1] = torch.Tensor(dz_dweightsi)\\n gradient_layerwise['layer{}'.format(layer)][0] = torch.Tensor(dz_dXinput) # ...\\n \\n if 'flatten_dense' in operationi:\\n \\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n \\n if operationi__1 == 'softmax':\\n \\n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\\n X_output = torch.reshape(X_output,(-1,1))\\n y_pred = architecture['layer{}'.format(layer+2)][1]\\n y_pred = torch.reshape(y_pred,y.shape)\\n dz_dXi = y_pred - y\\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n if 'sigmoid' in operationi:\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi:\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n \\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\\n try:\\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\\n except:\\n dz_dweightsi = (dz_dXi).mm(X_input)\\n \\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0\\n \\n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # Can also set this to layer like in line ~800\\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi # Can also set this to layer like in line ~800\\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # Can also set this to layer like in line ~800\\n \\n else:\\n # Have to modify and test this before implementation -> Specifically\\n # the backprop implementation is not consistent with the ones above\\n #\\n X_output = torch.reshape(X_output,(-1,1))\\n weights__i = architecture['layer{}'.format(layer+2)][2]\\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+2)][0]\\n dz_dXoutput = torch.reshape(torch.Tensor(dz_dXoutput),X_output.shape)\\n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\\n\\n if 'relu' in operationi:\\n dz_dXoutput[X_output<0] = 0\\n try:\\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\\n except:\\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\\n try:\\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\\n except:\\n dz_dweightsi = dz_dXoutput.mm(X_input)\\n dz_dbi = dz_dXoutput\\n if 'sigmoid' in operationi:\\n dz_dXoutput*= sigmoid(X_output)*(1-sigmoid(X_output))\\n try:\\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\\n except:\\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\\n try:\\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\\n except:\\n dz_dweightsi = dz_dXoutput.mm(X_input)\\n dz_dbi = dz_dXoutput\\n else:\\n try:\\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\\n except:\\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\\n try:\\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\\n except:\\n dz_dweightsi = dz_dXoutput.mm(X_input)\\n dz_dbi = dz_dXoutput\\n \\n unflattened_Xinput = architecture['layer{}'.format(layer+1)][0]\\n dz_dXinput = torch.reshape(dz_dXinput,unflattened_Xinput.shape)\\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXinput)\\n \\n if gradient_layerwise['layer{}'.format(layer+1)][1] is not None:\\n try:\\n grad_weights['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][1]\\n except:\\n grad_weights['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][1])\\n if gradient_layerwise['layer{}'.format(layer+1)][2] is not None:\\n try:\\n grad_bias['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][2]\\n except:\\n grad_bias['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][2])\\n \\n gc.collect()\\n return\",\n \"def backward(self, gradient):\\n raise NotImplementedError()\",\n \"def backward(self, i):\\n \\n #Compute gradient for w1, w2, w3\\n w1_grad = np.zeros((2, 3))\\n w2_grad = np.zeros((3, 3))\\n w3_grad = np.zeros((3, 1))\\n \\n \\n w3_backward_pass = np.zeros((1, 1))\\n w2_backward_pass = np.zeros((1, 3))\\n \\n #print(\\\"self.error shape\\\",self.error.shape)\\n #Compute w3 gradient\\n for i, w in enumerate(w3_grad): # 3 x 1 \\n w3_forward_pass = self.a2[0][i]\\n w3_backward_pass = self.error * der_sigmoid(self.y)\\n w3_grad[i] = w3_forward_pass * w3_backward_pass\\n \\n #Compute w2 gradient\\n for i, w_row in enumerate(w2_grad): # 3 x 3 \\n for j, w in enumerate(w2_grad[i]):# 1 x 3 \\n w2_forward_pass = self.a1[0][i]\\n w2_backward_pass[0][i] = der_sigmoid(self.a2[0][i]) * self.w3[i][0] * w3_backward_pass\\n w2_grad[i][j] = w2_forward_pass * w2_backward_pass[0][i]\\n \\n \\n #Compute w1 gradient \\n for i, w_rol in enumerate(w1_grad): # 2 x 3\\n for j, w in enumerate(w1_grad[i]): # 1 x 3\\n w1_forward_pass = self.input[0][i]\\n w1_backward_pass = der_sigmoid(self.a1[0][i]) * self.w2[i][j] * w2_backward_pass[0][i]\\n w1_grad[i][j] = w1_forward_pass * w1_backward_pass\\n \\n \\n #Update \\n for i, w in enumerate(w3_grad): \\n self.w3[i] -= self.learning_rate * w3_grad[i]\\n \\n for i, w_row in enumerate(w2_grad): # 3 x 3 \\n for j, w in enumerate(w2_grad[i]):# 1 x 3 \\n self.w2[i][j] -= self.learning_rate * w2_grad[i][j]\\n \\n for i, w_rol in enumerate(w1_grad): # 2 x 3\\n for j, w in enumerate(w1_grad[i]): # 1 x 3\\n self.w1[i][j] -= self.learning_rate * w1_grad[i][j]\\n \\n #print(\\\"w3 grad : \\\", w3_grad)\\n #print(\\\"w3.shape :\\\", self.w3.shape)\",\n \"def backward_pass(self, loss):\\n\\n self.optimizer.zero_grad()\\n self.optimizer.backward(loss)\\n self.optimizer.step()\",\n \"def backward_step(activations, targets, layers):\\n param_grads = collections.deque() # List of parameter gradients for each layer\\n output_grad = None # The error gradient at the output of the current layer\\n # Propagate the error backwards through all the layers.\\n # Use reversed to iterate backwards over the list of layers.\\n for i, layer in enumerate(reversed(layers)):\\n cur_layer_idx = len(layers) - i - 1\\n if cur_layer_idx <= NUM_LAYERS_SKIP:\\n # implement short circuit here\\n if layer.is_fc_layer:\\n grads = [0.0 for _ in range(layer.W.shape[0]*layer.W.shape[1]+layer.W.shape[1])]\\n else:\\n # normal gradient computation \\n Y = activations.pop() # Get the activations of the last layer on the stack\\n # Compute the error at the output layer.\\n # The output layer error is calculated different then hidden layer error.\\n if output_grad is None:\\n input_grad = layer.get_input_grad(Y, targets)\\n else: # output_grad is not None (layer is not output layer)\\n input_grad = layer.get_input_grad(Y, output_grad)\\n # Get the input of this layer (activations of the previous layer)\\n X = activations[-1]\\n # Compute the layer parameter gradients used to update the parameters\\n grads = layer.get_params_grad(X, output_grad)\\n param_grads.appendleft(grads)\\n # Compute gradient at output of previous layer (input of current layer):\\n output_grad = input_grad\\n return list(param_grads) # Return the parameter gradients\",\n \"def backward(ctx, grad_output):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n # Retrieve saved tensors and constants\\n gamma, ivar, mean, input = ctx.saved_tensors\\n eps = ctx.saved_tensors\\n\\n # Check which inputs need gradients\\n input_needs_grad, gamma_needs_grad, beta_needs_grad = ctx.needs_input_grad\\n\\n # Get the batch size (=N)\\n N, _ = grad_output.shape\\n\\n # reconstruct the input_norm\\n input_norm = (input - mean) * ivar\\n grand_input_norm = grad_output * gamma\\n\\n ##### Gradient wrt beta #####\\n grad_beta = grad_output.sum(dim=0) if beta_needs_grad else None\\n\\n #### Gradient wrt gamma ####\\n grad_gamma = (input_norm*grad_output).sum(dim=0) if gamma_needs_grad else None\\n \\n #### Gradient wrt input ####\\n term1 = N*grand_input_norm \\n term2 = torch.sum(grand_input_norm, dim=0)\\n term3 = input_norm*torch.sum(grand_input_norm*input_norm, dim=0)\\n grad_input = (1. / N) * ivar * (term1 - term2 - term3) if input_needs_grad else None\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n # return gradients of the three tensor inputs and None for the constant eps\\n return grad_input, grad_gamma, grad_beta, None\",\n \"def backward(self, gradient):\\n #TODO\\n pass\",\n \"def backward(self, gradient):\\n #TODO\\n pass\",\n \"def forward_backward_prop(data, labels, params, dimensions):\\n\\n ### Unpack network parameters (do not modify)\\n ofs = 0\\n Dx, H, Dy = (dimensions[0], dimensions[1], dimensions[2])\\n\\n activation = []\\n\\n W1 = np.reshape(params[ofs:ofs+ Dx * H], (Dx, H))\\n ofs += Dx * H\\n b1 = np.reshape(params[ofs:ofs + H], (1, H))\\n ofs += H\\n W2 = np.reshape(params[ofs:ofs + H * Dy], (H, Dy))\\n ofs += H * Dy\\n b2 = np.reshape(params[ofs:ofs + Dy], (1, Dy))\\n\\n ### Forward propagation\\n activation.append(data)\\n\\n # Hidden layer inputs: (N, Dx) * (Dx, H) -> N x H\\n z = np.dot(activation[-1], W1) + b1 \\n # Activations, inputs to the final layer. \\n activation.append(sigmoid(z)) # output of the hidden layer, activation\\n # Final layer outputs: ( N x H ) * ( H, Dy) -> (N, Dy)\\n z = np.dot(activation[-1], W2) + b2\\n activation.append( softmax(z) )\\n\\n # Cross-entropy cost\\n\\n y_p = activation[-1]\\n activation = activation[:-1] # remove activation data (output)\\n\\n cost = -np.sum(labels * np.log(y_p))\\n \\n error = []\\n \\n ### backward propagation\\n sigma = (y_p - labels)\\n error.append(sigma)\\n\\n gradb2 = np.sum(error[-1], axis=0)\\n gradW2 = np.dot(activation[-1].T, error[-1])\\n\\n #\\n sigma = np.dot(W2, error[-1].T)\\n sigma = sigma.T * sigmoid_grad(activation[-1])\\n activation = activation[:-1] # remove activation data ( hidden layer )\\n\\n error.append(sigma)\\n\\n gradb1 = np.sum(error[-1], axis=0)\\n gradW1 = np.dot(activation[-1].T, error[-1])\\n\\n\\n ### Stack gradients (do not modify)\\n grad = np.concatenate((gradW1.flatten(), gradb1.flatten(), \\n gradW2.flatten(), gradb2.flatten()))\\n \\n return cost, grad\",\n \"def backward_pass(self):\\r\\n # the gradient of cross-entropy on top of softmax is (t-y)\\r\\n back_output = (self.targets - self.y) / self.y.shape[0]\\r\\n\\r\\n for layer in reversed(self.layers):\\r\\n back_output = layer.backward_pass(back_output)\",\n \"def backward(ctx, G):\\n backend = ctx.backend\\n aliases = ctx.aliases\\n formula = ctx.formula\\n signature = ctx.signature\\n sum_index = ctx.sum_index\\n args = ctx.saved_tensors # Unwrap the saved variables\\n\\n # number of arguments (including parameters)\\n nvars = 0;\\n for sig in signature[1:]:\\n nvars += 1\\n\\n # If formula takes 5 variables (numbered from 0 to 4), then the gradient\\n # wrt. the output, G, should be given as a 6-th variable (numbered 5),\\n # with the same dim-cat as the formula's output.\\n eta = \\\"Var(\\\" + str(nvars) + \\\",\\\" + str(signature[0][0]) + \\\",\\\" + str(signature[0][1]) + \\\")\\\"\\n grads = [] # list of gradients wrt. args;\\n arg_ind = 5 # current arg index (4 since backend, ... are in front of the tensors); \\n var_ind = 0 # current Variable index;\\n\\n for sig in signature[1:]: # Run through the actual parameters, given in *args in the forward.\\n if not ctx.needs_input_grad[arg_ind]: # If the current gradient is to be discarded immediatly...\\n grads.append(None) # Don't waste time computing it.\\n else: # Otherwise, the current gradient is really needed by the user:\\n # adding new aliases is waaaaay too dangerous if we want to compute\\n # second derivatives, etc. So we make explicit references to Var<ind,dim,cat> instead.\\n var = \\\"Var(\\\" + str(var_ind) + \\\",\\\" + str(sig[0]) + \\\",\\\" + str(sig[1]) + \\\")\\\" # V\\n formula_g = \\\"Grad(\\\" + formula + \\\",\\\" + var + \\\",\\\" + eta + \\\")\\\" # Grad<F,V,G>\\n args_g = args + (G,) # Don't forget the gradient to backprop !\\n \\n # N.B.: if I understand PyTorch's doc, we should redefine this function every time we use it?\\n genconv = GenericSum().apply\\n\\n if sig[1] == 2: # we're referring to a parameter, so we'll have to sum both wrt 'i' and 'j'\\n sumindex_g = 1 # The first sum will be done wrt 'i'\\n signature_g = [ [sig[0],1] ] + signature[1:] + signature[:1]\\n grad = genconv(backend, aliases, formula_g, signature_g, sumindex_g, *args_g)\\n # Then, sum 'grad' wrt 'j' :\\n # I think that \\\".sum\\\"'s backward introduces non-contiguous arrays,\\n # and is thus non-compatible with GenericSum:\\n # grad = grad.sum(0) \\n # We replace it with a \\\"handmade hack\\\" :\\n grad = Variable(torch.ones(1, grad.shape[0]).type_as(grad.data)) @ grad\\n grad = grad.view(-1)\\n else :\\n # sumindex is \\\"the index that stays in the end\\\", not \\\"the one in the sum\\\"\\n # (It's ambiguous, I know... But it's the convention chosen by Joan, which makes\\n # sense if we were to expand our model to 3D tensors or whatever.)\\n sumindex_g = sig[1] # The sum will be \\\"eventually indexed just like V\\\".\\n signature_g = [sig] + signature[1:] + signature[:1]\\n grad = genconv(backend, aliases, formula_g, signature_g, sumindex_g, *args_g)\\n grads.append(grad)\\n\\n # increment the Variable counts\\n arg_ind += 1 ; var_ind += 1 \\n\\n # Grads wrt. backend, aliases, formula, signature, sum_index, *args\\n return (None, None, None, None, None, *grads)\",\n \"def _backward(loss):\\n\\n loss.backward()\",\n \"def backward(self, gradient: Tensor) -> Tensor:\\n self.b_grad = np.sum(gradient, axis=0)\\n self.w_grad = self.inputs.T @ gradient\\n return gradient @ self.w.T\",\n \"def backward(self, input_train, input_train_label):\\n batchSize = len(input_train) #liczba obrazow podawanych na wejscie w trakcie jednej iteracji\\n weights = self.Weights\\n biases = self.Biases\\n delta_W = self.delta_W\\n delta_B = self.delta_B\\n poolParams = self.poolParams\\n dW_list = []\\n dB_list = []\\n dW4 = np.zeros(weights[4].shape)\\n dB4 = np.zeros(biases[4].shape)\\n dW3 = np.zeros(weights[3].shape)\\n dB3 = np.zeros(biases[3].shape)\\n dW2 = np.zeros(weights[2].shape)\\n dB2 = np.zeros(biases[2].shape)\\n dW1 = np.zeros(weights[1].shape)\\n dB1 = np.zeros(biases[1].shape)\\n dW0 = np.zeros(weights[0].shape)\\n dB0 = np.zeros(biases[0].shape)\\n loss = 0\\n for image in range(batchSize):\\n\\n X_data = input_train[image]\\n X_label = input_train_label[image]\\n output_forward, cache = self.forward(X_data) \\n loss += -1*sum(X_label - np.log(output_forward)) #obliczenie wartosci funkcji straty [cross entropy]\\n\\n #Propagacja wsteczna gradientu\\n dy = -1*(X_label - output_forward)/2\\n #print(\\\"X_label = {} \\\\t layer7 = {} \\\\t dy = {}\\\".format(X_label, output_forward, dy))\\n\\n [dy, dW, dB ] = fullycon_b(cache[6], np.asarray([dy]).transpose() , weights[4])\\n dW4 += dW\\n dB4 += dB.flatten() #wektoryzacja macierzy\\n dy = act.relu_b(dy.transpose(), cache[6])\\n\\n [dy, dW, dB ] = fullycon_b(cache[5][:,0], dy, weights[3])\\n dW3 += dW\\n dB3 += dB.flatten()\\n dy = act.relu_b(dy.transpose(), cache[5][:,0]) \\n \\n [dy, dW, dB ] = convolution_b(cache[4], dy, weights[2])\\n dW2 += dW\\n dB2 += dB.flatten()\\n \\n dy = maxpool_b(cache[3], dy)\\n dy = act.relu_b(dy, cache[3])\\n\\n [dy, dW, dB ] = convolution_b(cache[2], dy, weights[1])\\n dW1 += dW\\n dB1 += dB.flatten()\\n \\n dy = maxpool_b(cache[1], dy)\\n dy = act.relu_b(dy, cache[1]) \\n\\n [dy, dW, dB ] = convolution_b(np.asarray([cache[0]]), dy, weights[0])\\n dW0 += dW\\n dB0 += dB.flatten()\\n\\t\\t\\t\\n dW_list.append(dW4)\\n dB_list.append(dB4)\\n dW_list.append(dW3)\\n dB_list.append(dB3)\\n dW_list.append(dW2)\\n dB_list.append(dB2)\\n dW_list.append(dW1)\\n dB_list.append(dB1)\\n dW_list.append(dW0)\\n dB_list.append(dB0)\\n dW_list = dW_list[::-1]\\n dB_list = dB_list[::-1]\\n \\n #Aktualizacja parametrow kazdej z warstw (o ile takie posiada)\\n #uczenie z metoda momentum: learning rate = const; alpha = const\\n for x in range(len(dW_list)):\\n delta_W[x] = alpha*delta_W[x] - eta*dW_list[x]/batchSize\\n weights[x] += delta_W[x]\\n delta_B[x] = alpha*delta_B[x] - eta*dB_list[x]/batchSize\\n biases[x] += delta_B[x]\\n #przypisanie nowych wag po aktualiacji wszystkich parametrow\\n self.Weights = weights\\n self.Biases = biases\\n\\n #zwrocenie stosunku wartosci f-cji straty do rozmiaru batch'u\\n return loss/batchSize\",\n \"def backward_pass(self, delta):\\n\\n a = config['learning_rate']\\n y = config['momentum_gamma']\\n m = config['momentum']\\n l = config['L2_penalty']\\n\\n # print(\\\"shape of delta incoming: \\\", delta.shape, \\\"shape of x: \\\", self.x.shape)\\n self.d_x = delta.T @ self.x\\n # print(\\\"SHAPE OF GRADIENT: \\\", self.d_x.shape)\\n\\n # gradient momentum\\n self.w_inc = (a * self.d_x.T) + (y * self.d_v) - l * self.w\\n \\n # saving \\n if m:\\n self.d_v = self.w_inc\\n else:\\n self.d_v = np.zeros(self.w.shape)\\n\\n # backprop for bias weights\\n x_0 = np.ones([len(delta), 1])\\n\\n self.d_b = delta.T @ x_0\\n\\n # print(\\\"shape of BIAS GRAD: \\\", self.d_b.shape)\\n\\n self.d_w = delta @ self.w.T\\n # print(\\\"shape of w.T: \\\", self.w.T.shape, \\\"shape of RETURN delta: \\\", self.d_w.shape)\\n #print(self.w.shape)\\n return self.d_w\",\n \"def backward(self, inputs, gradients, **kwargs):\\n grad_relu = inputs > 0\\n return gradients * grad_relu\",\n \"def backward_and_step(self, loss):\\n self.opt.zero_grad()\\n loss.backward()\\n self.opt.step()\",\n \"def backward_step(activations, targets, layers):\\n param_grads = collections.deque() # List of parameter gradients for each layer\\n output_grad = None # The error gradient at the output of the current layer\\n # Propagate the error backwards through all the layers.\\n # Use reversed to iterate backwards over the list of layers.\\n for layer in reversed(layers): \\n Y = activations.pop() # Get the activations of the last layer on the stack\\n # Compute the error at the output layer.\\n # The output layer error is calculated different then hidden layer error.\\n if output_grad is None:\\n input_grad = layer.get_input_grad(Y, targets)\\n else: # output_grad is not None (layer is not output layer)\\n input_grad = layer.get_input_grad(Y, output_grad)\\n # Get the input of this layer (activations of the previous layer)\\n X = activations[-1]\\n # Compute the layer parameter gradients used to update the parameters\\n grads = layer.get_params_grad(X, output_grad)\\n param_grads.appendleft(grads)\\n # Compute gradient at output of previous layer (input of current layer):\\n output_grad = input_grad\\n return list(param_grads) # Return the parameter gradients\",\n \"def backward(ctx, grad_output):\\n\\n # This is a pattern that is very convenient - at the top of backward\\n # unpack saved_tensors and initialize all gradients w.r.t. inputs to\\n # None. Thanks to the fact that additional trailing Nones are\\n # ignored, the return statement is simple even when the function has\\n # optional inputs.\\n # input, weight, bias = ctx.saved_variables\\n\\n return grad_output\",\n \"def forward_backward_prop(data, labels, params, dimensions):\\n\\n ### Unpack network parameters (do not modify)\\n ofs = 0\\n Dx, H, Dy = (dimensions[0], dimensions[1], dimensions[2])\\n\\n W1 = np.reshape(params[ofs:ofs+ Dx * H], (Dx, H))\\n ofs += Dx * H\\n b1 = np.reshape(params[ofs:ofs + H], (1, H))\\n ofs += H\\n W2 = np.reshape(params[ofs:ofs + H * Dy], (H, Dy))\\n ofs += H * Dy\\n b2 = np.reshape(params[ofs:ofs + Dy], (1, Dy))\\n\\n ### YOUR CODE HERE: forward propagation\\n affine_1 = np.dot(data, W1) + b1\\n sigmoid_1 = sigmoid(affine_1)\\n affine_2 = np.dot(sigmoid_1, W2) + b2\\n scores = sigmoid(affine_2)\\n cost = - np.sum(np.multiply(np.log(softmax(scores)), labels))\\n ### END YOUR CODE\\n \\n ### YOUR CODE HERE: backward propagation\\n cross_entropy_grad_ = cross_entropy_grad(scores, labels)\\n sigmoid_2_grads = sigmoid_input_grad(cross_entropy_grad_, scores)\\n x_2_grad, gradW2, gradb2 = affine_grads(sigmoid_2_grads, sigmoid_1, W2, b2)\\n sigmoid_1_grads = sigmoid_input_grad(x_2_grad, sigmoid_1)\\n x_1_grad, gradW1, gradb1 = affine_grads(sigmoid_1_grads, data, W1, b1)\\n ### END YOUR CODE\\n \\n ### Stack gradients (do not modify)\\n grad = np.concatenate((gradW1.flatten(), gradb1.flatten(), \\n gradW2.flatten(), gradb2.flatten()))\\n return cost, grad\",\n \"def backward_gradient(\\n self, input: np.ndarray, head_gradients: Dict[str, np.ndarray]\\n ) -> np.ndarray:\\n raise NotImplementedError\",\n \"def backprop(x, y, biases, weights, cost, num_layers):\\n # initial zero list for store gradient of biases and weights\\n nabla_b = [np.zeros(b.shape) for b in biases]\\n nabla_w = [np.zeros(w.shape) for w in weights]\\n activations = [np.zeros(w.shape) for w in biases]\\n\\n ### Implement here\\n # feedforward\\n # Here you need to store all the activations of all the units\\n # by feedforward pass\\n ###\\n activations.insert(0,x)\\n for layer in range(1,num_layers):\\n activations[layer]=sigmoid(np.dot(weights[layer-1],activations[layer-1])+biases[layer-1])\\n\\n # compute the gradient of error respect to output\\n # activations[-1] is the list of activations of the output layer\\n delta = (cost).delta(activations[-1], y) \\n \\n ### Implement here\\n # backward pass\\n # Here you need to implement the backward pass to compute the\\n # gradient for each weight and bias\\n ###\\n for k in range(num_layers,1,-1):\\n delta=delta*sigmoid_prime(activations[k-1])\\n nabla_b[k-2]=delta\\n nabla_w[k-2]=np.dot(delta,activations[k-2].T)\\n delta=np.dot(weights[k-2].T,delta)\\n \\n\\n return (nabla_b, nabla_w)\",\n \"def backward(self, inGradient, lr=0.001): # batchSize = 1\\n wGradient = np.dot(inGradient.T, self.data)\\n bGradient = np.sum(inGradient, axis=0)\\n outGradient = np.dot(inGradient, self.weights)\\n\\n self.weights = self.weights - lr * wGradient\\n self.bias = self.bias - lr * bGradient\\n self.wGradient = wGradient\\n self.bGradient = bGradient\\n\\n #print \\\"weight gradient \\\", wGradient\\n #print \\\"bias gradient \\\", bGradient\\n\\n return outGradient\",\n \"def backward(self, grad_out):\\n\\n # *********************************************\\n # check this with torch.autograd.gradcheck !!!!\\n # *********************************************\\n\\n k, a, m, y, targets = self.saved_tensors\\n b = 1.0 - a\\n\\n features = y.numpy()\\n labels = targets.numpy()\\n\\n loss, counts, centers, l_intra, inter_indices, l_inter, d = self.compute_loss(features, labels, k.numpy(), a.numpy(), b.numpy(), m.numpy())\\n\\n grad_inter = torch.FloatTensor(y.size())\\n grad_intra = torch.FloatTensor(y.size())\\n\\n idx1 = inter_indices[0]\\n idx2 = inter_indices[1]\\n grad_inter[idx1] = torch.from_numpy(0.5 / (counts[idx1]) * np.abs(centers[idx1] - centers[idx2]))\\n grad_inter[idx2] = torch.from_numpy(0.5 / (counts[idx2]) * np.abs(centers[idx2] - centers[idx1]))\\n\\n # compute intra class gradients with respect to xi, xj\\n # only nonzero for these two values\\n\\n # *********************************************************\\n # HOW TO COMPUTE GRADIENTS WITH RESPECT TO MULTIPLE SAMPLES\\n # WHEN LOSS IS JUST COMPUTED OVERALL????\\n # *********************************************************\\n\\n for idx in range(y.size()[1]):\\n denom = np.array([np.power(d[idx,0]*np.sum(d[idx,:]),2)])\\n grad = 2*k.double() / torch.from_numpy(denom)\\n for entry in range(y.size()[0]):\\n grad_intra[entry, idx] = grad[0]\\n\\n # compute inter class gradients with respect to xq, xr\\n # only nonzero for these two values\\n\\n # ****************************************\\n # SOMEHOW THE GRADIENT IS WAY TOO BIG ****\\n # ****************************************\\n grad_in = a*grad_intra + b*grad_inter\\n print(grad_in)\\n return grad_in, torch.DoubleTensor([0]), torch.DoubleTensor([0]), torch.DoubleTensor([0]), torch.DoubleTensor([0])\",\n \"def backward_G(self):\\n # Calculate regularzation loss to make transformed feature and target image feature in the same latent space\\n self.loss_reg_gen = self.loss_reg * self.opt.lambda_regularization\\n\\n # Calculate l1 loss \\n loss_app_gen = self.L1loss(self.img_gen, self.input_P2)\\n self.loss_app_gen = loss_app_gen * self.opt.lambda_rec \\n \\n # parsing loss\\n label_P2 = self.label_P2.squeeze(1).long()\\n #print(self.input_SPL2.min(), self.input_SPL2.max(), self.parsav.min(), self.parsav.max())\\n self.loss_par = self.parLoss(self.parsav,label_P2)# * 20. \\n self.loss_par1 = self.L1loss(self.parsav, self.input_SPL2) * 100 \\n\\n # Calculate GAN loss\\n base_function._freeze(self.net_D)\\n D_fake = self.net_D(self.img_gen)\\n self.loss_ad_gen = self.GANloss(D_fake, True, False) * self.opt.lambda_g\\n\\n # Calculate perceptual loss\\n loss_content_gen, loss_style_gen = self.Vggloss(self.img_gen, self.input_P2) \\n self.loss_style_gen = loss_style_gen*self.opt.lambda_style\\n self.loss_content_gen = loss_content_gen*self.opt.lambda_content\\n\\n total_loss = 0\\n\\n for name in self.loss_names:\\n if name != 'dis_img_gen':\\n #print(getattr(self, \\\"loss_\\\" + name))\\n total_loss += getattr(self, \\\"loss_\\\" + name)\\n total_loss.backward()\",\n \"def backward(self):\\n gradient = blah\\n return gradient\",\n \"def backward(self):\\n gradient = blah\\n return gradient\",\n \"def backward(self):\\n #initiate the gradients\\n #print('')\\n \\n #print('node {} grad {}'.format(self.id, self.gradient))\\n #print('node {} times visited : {}/{}'.format(self.id, self.times_visited, self.times_used))\\n\\n if self.gradient is None:\\n self.gradient=np.eye(self.output_dim)\\n self.times_visited+=1\\n\\n \\n \\n if self.childrens==[]:\\n return(self.gradient)\\n else:\\n self.backward()\\n \\n else: \\n if self.childrens!=[]:\\n #we can still going deeper in backprop\\n #print(len(self.childrens), ' childrens', str([self.childrens[i]['node'].id for i in range(len(self.childrens))]))\\n for child in self.childrens:\\n node,jacobian=child['node'], child['jacobian']\\n \\n new_grad = np.dot(self.gradient, jacobian)\\n #print(node.gradient)\\n #print(new_grad)\\n \\n if node.gradient is None:\\n node.gradient = new_grad\\n else: \\n node.gradient += new_grad\\n \\n node.times_visited+=1\\n #print('looking at node {} \\\\ngradient {}'.format(node.id, node.gradient))\\n\\n \\n if node.times_used ==node.times_visited: \\n #print(node.gradient)\\n node.backward() \\n else:\\n #still some computations to perform upwards before going deeped\\n #print('node {} visits : {}/{}'.format(node.id, node.times_visited, node.times_used))\\n pass\",\n \"def backward_pass(total_loss):\\n\\n # Get the tensor that keeps track of step in this graph or create one if not there\\n global_step = tf.train.get_or_create_global_step()\\n\\n # Print summary of total loss\\n tf.summary.scalar('Total_Loss', total_loss)\\n\\n # Decay the learning rate\\n dk_steps = int((FLAGS.epoch_size / FLAGS.batch_size) * 75)\\n lr_decayed = tf.train.cosine_decay_restarts(FLAGS.learning_rate, global_step, dk_steps)\\n\\n # Compute the gradients. NAdam optimizer came in tensorflow 1.2\\n opt = tf.contrib.opt.NadamOptimizer(learning_rate=lr_decayed, beta1=FLAGS.beta1,\\n beta2=FLAGS.beta2, epsilon=0.1)\\n\\n # Compute the gradients\\n gradients = opt.compute_gradients(total_loss)\\n\\n # Apply the gradients\\n train_op = opt.apply_gradients(gradients, global_step, name='train')\\n\\n # Add histograms for the trainable variables. i.e. the collection of variables created with Trainable=True\\n for var in tf.trainable_variables():\\n tf.summary.histogram(var.op.name, var)\\n\\n # Maintain average weights to smooth out training\\n variable_averages = tf.train.ExponentialMovingAverage(FLAGS.moving_avg_decay, global_step)\\n\\n # Applies the average to the variables in the trainable ops collection\\n variable_averages_op = variable_averages.apply(tf.trainable_variables())\\n\\n with tf.control_dependencies([train_op, variable_averages_op]): # Wait until we apply the gradients\\n dummy_op = tf.no_op(name='train') # Does nothing. placeholder to control the execution of the graph\\n\\n return dummy_op\",\n \"def backward(ctx, grad_L):\\n A, T = ctx.saved_tensors\\n\\n grad_A = None\\n grad_T = None\\n\\n B = A.shape[0]\\n\\n # We only need to compute gradients for tensors that are flagged to\\n # require gradients!\\n if ctx.needs_input_grad[0]:\\n grad_A = (A - T) / B\\n\\n if ctx.needs_input_grad[1]:\\n grad_T = (T - A) / B\\n\\n return grad_A, grad_T\",\n \"def backward(self, d_out):\\n # TODO: Implement backward pass\\n # Compute both gradient with respect to input\\n # and gradients with respect to W and B\\n # Add gradients of W and B to their `grad` attribute\\n\\n # It should be pretty similar to linear classifier from\\n # the previous assignment\\n \\n dW = np.dot(self.X.T, d_out);\\n dB = np.dot(np.ones((1, d_out.shape[0])), d_out);\\n \\n d_input = np.dot(d_out, self.W.value.T);\\n #print(\\\"self.X = \\\", self.X);\\n #print(\\\"self.W.grad.T = \\\", self.W.grad.T);\\n #print(\\\"dW.T = \\\", dW.T);\\n \\n self.W.grad += dW;\\n self.B.grad += dB;\\n \\n return d_input;\",\n \"def backward(\\n self, X: np.ndarray, y: np.ndarray, lr: float, reg: float = 0.0\\n ) -> float:\\n y_hat = self.forward(X)\\n\\n y_one_hot = self.one_hot_encode(y)\\n loss = CrossEntropy.forward(y_one_hot, y_hat)\\n\\n d_layer = CrossEntropy.backward(y, y_hat)\\n\\n w_grads = []\\n b_grads = []\\n\\n for idx, layer in reversed(list(enumerate(self.layers))):\\n # Not output layer\\n if (idx + 1) < len(self.layers):\\n next_layer = self.layers[idx + 1]\\n\\n d_layer = d_layer.dot(next_layer.w.T)\\n d_layer = layer.activation_func.backward(d_layer, layer.activated_out)\\n\\n d_w = layer.linear_in.T.dot(d_layer) + 2 * reg * layer.w\\n d_b = np.sum(d_layer, axis=0)\\n\\n w_grads.insert(0, d_w)\\n b_grads.insert(0, d_b)\\n\\n self.optimizer.step(self.layers, w_grads, b_grads, lr)\\n\\n if self.norm_weights:\\n w_norm = max(np.linalg.norm(l.w) for l in self.layers) / len(self.layers)\\n b_norm = max(np.linalg.norm(l.w) for l in self.layers) / len(self.layers)\\n for layer in self.layers:\\n layer.w /= w_norm\\n layer.b /= b_norm\\n\\n return loss\",\n \"def backward(self, out_grad, input):\\n raise NotImplementedError\",\n \"def compute_loss_and_gradients(self, X, y):\\n # Before running forward and backward pass through the model,\\n # clear parameter gradients aggregated from the previous pass\\n # TODO Set parameter gradient to zeros\\n # Hint: using self.params() might be useful!\\n self.fulllayer1.W.grad = np.zeros_like(self.fulllayer1.W.grad)\\n self.fulllayer1.B.grad = np.zeros_like(self.fulllayer1.B.grad)\\n self.fulllayer2.W.grad = np.zeros_like(self.fulllayer2.W.grad)\\n self.fulllayer2.B.grad = np.zeros_like(self.fulllayer2.B.grad)\\n\\n\\n # TODO Compute loss and fill param gradients\\n # by running forward and backward passes through the model\\n res = self.fulllayer1.forward(X)\\n res2 = self.reglayer1.forward(res)\\n res3 = self.fulllayer2.forward(res2)\\n\\n loss, grad = softmax_with_cross_entropy(res3, y)\\n\\n back3 = self.fulllayer2.backward(grad)\\n back2 = self.reglayer1.backward(back3)\\n back = self.fulllayer1.backward(back2)\\n \\n # After that, implement l2 regularization on all params\\n # Hint: self.params() is useful again!\\n\\n for params in self.params().keys():\\n # print(params)\\n # print(self.params()[params].value)\\n loc_loss, loc_grad = l2_regularization(self.params()[params].value, self.reg)\\n loss += loc_loss\\n self.params()[params].grad += loc_grad\\n\\n return loss\",\n \"def backward(self, lhs: Tensor, rhs: Tensor, acc_grad: np.ndarray):\\n raise NotImplementedError\",\n \"def backward(self, grad, **kwargs):\\n if not self._iszero:\\n self._product = grad * reduce(lambda x, y: x*y, (var.data for n, var in enumerate(self.variables)))\\n else:\\n self._product = None\\n\\n for index, var in enumerate(self.variables):\\n if not var.constant:\\n self.backward_var(grad, index)\",\n \"def backward_step_matrix_version(activations, targets, layers):\\n param_grads = collections.deque() # List of parameter gradients for each layer\\n \\n output_grad = None # The error gradient at the output of the current layer\\n # Propagate the error backwards through all the layers.\\n # Use reversed to iterate backwards over the list of layers.\\n for i, layer in enumerate(reversed(layers)):\\n cur_layer_idx = len(layers) - i - 1\\n if cur_layer_idx <= NUM_LAYERS_SKIP:\\n # implement short circuit here\\n if layer.is_fc_layer:\\n grads = [0.0 for _ in range(layer.W.shape[0]*layer.W.shape[1]+layer.W.shape[1])]\\n else:\\n # normal gradient computation \\n Y = activations.pop() # Get the activations of the last layer on the stack\\n # Compute the error at the output layer.\\n # The output layer error is calculated different then hidden layer error.\\n if output_grad is None:\\n input_grad = layer.get_input_grad(Y, targets)\\n else: # output_grad is not None (layer is not output layer)\\n input_grad = layer.get_input_grad(Y, output_grad)\\n # Get the input of this layer (activations of the previous layer)\\n X = activations[-1]\\n # Compute the layer parameter gradients used to update the parameters\\n grads = layer.get_params_grad(X, output_grad)\\n # we do one extra gradient reshape step here:\\n if layer.is_fc_layer:\\n grads_new = np.array(grads).reshape((layer.get_shape[0]+1, layer.get_shape[1]))\\n param_grads.appendleft(grads_new)\\n else:\\n param_grads.appendleft(grads)\\n # Compute gradient at output of previous layer (input of current layer):\\n output_grad = input_grad\\n return list(param_grads) # in this way, `param_grads` will be a list which contains grads of numpy ndarray\",\n \"def backward_D(self):\\n self.loss_D.backward()\",\n \"def backward(self, loss):\\n global_timer.my_timer.start_profile(\\\"BWD\\\")\\n mgr = PatrickStarManager()\\n mgr.set_training_stage(TrainingStage.BWD)\\n\\n for param_fp16 in self.client.chunk_based_param_fp16:\\n param_fp16.ps_attr.bwd_used_cnt = 0\\n\\n self.optimizer.zero_grad()\\n if self.loss_scaler:\\n self.loss_scaler.backward(loss)\\n else:\\n loss.backward()\\n mgr.update_margin_mem()\\n global_timer.my_timer.finish_profile(\\\"BWD\\\")\",\n \"def backward(ctx, grad_output):\\n if PROFILE:\\n batch_tic = time.time()\\n tic = time.time()\\n timings = defaultdict(float)\\n\\n feats1, feats2, xxyy, batch_grid_u, params, pow = ctx.saved_tensors\\n\\n \\\"\\\"\\\"We needed to store the integers as part of a tensor, so the\\n unpacking code here is a little convoluted.\\\"\\\"\\\"\\n B, C, H, W, stride, norm = [x.item() for x in params]\\n h, w = H, W\\n pow = pow.item()\\n\\n \\\"\\\"\\\"This is a pattern that is very convenient - at the top of backward\\n unpack saved_tensors and initialize all gradients w.r.t. inputs to\\n None. Thanks to the fact that additional trailing Nones are\\n ignored, the return statement is simple even when the function has\\n optional inputs.\\\"\\\"\\\"\\n grad_feats1 = grad_feats2 = grad_xxyy = grad_batch_u = None\\n grad_stride = grad_norm = grad_pow = None\\n\\n \\\"\\\"\\\"Returning gradients for inputs that don't require it is\\n not an error.\\\"\\\"\\\"\\n assert ctx.needs_input_grad[0], \\\"expected feats1 to need grad\\\"\\n assert ctx.needs_input_grad[1], \\\"expected feats2 to need grad\\\"\\n assert not ctx.needs_input_grad[2], \\\"expected xxyy does not need grad\\\"\\n assert not ctx.needs_input_grad[3], \\\"expected batch_grid_u does not need grad\\\"\\n assert not ctx.needs_input_grad[4], \\\"expected stride does not need grad\\\"\\n\\n if PROFILE:\\n timings[\\\"back-init\\\"] = time.time() - tic\\n tic = time.time()\\n\\n with torch.no_grad():\\n\\n if feats1.is_cuda:\\n # TODO: clean up types here\\n if feats1.dtype == torch.float32:\\n grad_feats1 = torch.cuda.FloatTensor(B, C, H, W).fill_(0)\\n grad_feats2 = torch.cuda.FloatTensor(B, C, h, w).fill_(0)\\n elif feats1.dtype == torch.float16:\\n grad_feats1 = torch.cuda.HalfTensor(B, C, H, W).fill_(0)\\n grad_feats2 = torch.cuda.HalfTensor(B, C, h, w).fill_(0)\\n else:\\n grad_feats1 = torch.zeros((B, C, H, W), dtype=feats1.dtype)\\n grad_feats2 = torch.zeros((B, C, h, w), dtype=feats2.dtype)\\n\\n grad_loss = grad_output / (H * W * B)\\n\\n if PROFILE:\\n timings[\\\"data transfer\\\"] = time.time() - batch_tic\\n\\n for b in range(B):\\n\\n if PROFILE:\\n tic = time.time()\\n\\n with torch.no_grad():\\n diff = batch_grid_u[b, :, :, None, None, :] - \\\\\\n xxyy[None, None, ::stride, ::stride, :]\\n diff = (diff * diff).sum(4).sqrt()\\n diff = diff.pow(pow)\\n\\n if PROFILE:\\n timings[\\\"diff-grid\\\"] += time.time() - tic\\n tic = time.time()\\n\\n # loss gradient for the current minibatch element (expand to tensor)\\n grad_loss_b = grad_loss\\n grad_smcorr2 = grad_loss_b * diff\\n\\n if LOCAL_CHECKS:\\n ones = torch.ones(diff.shape, dtype=diff.dtype)\\n grad_loss_b_ = ones * grad_loss\\n smcorr_ = torch.randn(\\n diff.shape,\\n dtype=torch.double,\\n requires_grad=True)\\n with torch.autograd.enable_grad():\\n L_ = diff * smcorr_\\n d_smcorr = torch.autograd.grad(\\n outputs=L_,\\n inputs=smcorr_,\\n grad_outputs=grad_loss_b_,\\n )\\n rel_diff(grad_smcorr2, d_smcorr[0], \\\"smax\\\")\\n if torch.any(torch.isnan(grad_smcorr2[0])):\\n import ipdb; ipdb.set_trace()\\n\\n\\n if PROFILE:\\n timings[\\\"scale-feats\\\"] += time.time() - tic\\n tic = time.time()\\n\\n # Re-compute intermediate values\\n grad_smcorr2 = grad_smcorr2.view(H, W, -1)\\n f1_ = feats1[b].view(C, H * W)\\n f2_ = feats2[b].view(C, h * w)\\n fa_ = feats1[(b + 1) % B].reshape(C, h * w) # auxiliary\\n\\n if norm:\\n f1_norm = F.normalize(f1_, p=2, dim=0) * JDT_FACTOR\\n f2_norm = F.normalize(f2_, p=2, dim=0) * JDT_FACTOR\\n fa_norm = F.normalize(fa_, p=2, dim=0) * JDT_FACTOR\\n else:\\n f1_norm = f1_.clone()\\n f2_norm = f2_.clone()\\n fa_norm = fa_.clone()\\n\\n if PROFILE:\\n timings[\\\"fwd-norm\\\"] += time.time() - tic\\n tic = time.time()\\n\\n # Match the source features against the auxiliaries\\n corr = torch.matmul(f1_norm.t(), fa_norm)\\n corr = corr.reshape(H, W, h, w)\\n\\n if PROFILE:\\n timings[\\\"f1-aux-correlation\\\"] += time.time() - tic\\n tic = time.time()\\n\\n smcorr = F.softmax(corr.view(H, W, -1), dim=2)\\n smcorr = smcorr.view(corr.shape)\\n if LOCAL_CHECKS:\\n # cache a copy of the mega tensor for numerical checks\\n smcorr_fa = smcorr[None, ...] * fa_norm.view(-1, 1, 1, h, w)\\n f1_via_fa = smcorr_fa.sum((3, 4))\\n else:\\n \\\"\\\"\\\"This is one of the largest tensors.....\\\"\\\"\\\"\\n f1_via_fa = (smcorr[None, ...] *\\n fa_norm.view(-1, 1, 1, h, w)).sum((3, 4))\\n\\n f1_via_fa = f1_via_fa.view(C, H * W)\\n\\n # Main correlation computation\\n corr2 = torch.matmul(f1_via_fa.t(), f2_norm).view(corr.shape)\\n\\n # Direct backward pass for second softmax\\n smcorr2 = F.softmax(corr2.view(H, W, -1), dim=2)\\n sum_term = torch.sum(grad_smcorr2 * smcorr2, dim=2, keepdim=True)\\n grad_corr2 = smcorr2 * (grad_smcorr2 - sum_term)\\n\\n if not LOCAL_CHECKS:\\n del smcorr2\\n\\n if PROFILE:\\n timings[\\\"softmax\\\"] += time.time() - tic\\n tic = time.time()\\n\\n # safety checks\\n if LOCAL_CHECKS:\\n with torch.enable_grad():\\n corr2_num = corr2.clone().requires_grad_()\\n corr2_num = corr2_num.reshape(H, W, -1)\\n smcorr2_num = F.softmax(corr2_num, dim=2)\\n grad_corr2_num = torch.autograd.grad(\\n outputs=smcorr2_num,\\n inputs=(corr2_num,),\\n grad_outputs=grad_smcorr2,\\n )\\n rel_diff(grad_corr2, grad_corr2_num[0], \\\"smax-corr2\\\")\\n\\n \\\"\\\"\\\"Derivatives through the main correlation correlation\\\"\\\"\\\"\\n grad_corr2 = grad_corr2.view(H * W, H * W)\\n grad_f1_via_fa = torch.matmul(grad_corr2, f2_norm.t()).t()\\n grad_f2_norm = torch.matmul(f1_via_fa, grad_corr2)\\n\\n if not LOCAL_CHECKS:\\n del grad_corr2\\n\\n if PROFILE:\\n timings[\\\"corr-back\\\"] += time.time() - tic\\n tic = time.time()\\n\\n if LOCAL_CHECKS:\\n with torch.enable_grad():\\n f1_via_fa_num = f1_via_fa.clone().requires_grad_()\\n f2_norm_num = f2_norm.clone().requires_grad_()\\n corr2_num = torch.matmul(f1_via_fa_num.t(), f2_norm_num)\\n grad_f1_via_fa_num, grad_f2_norm_num = torch.autograd.grad(\\n outputs=corr2_num,\\n inputs=(f1_via_fa_num, f2_norm_num),\\n grad_outputs=grad_corr2,\\n )\\n rel_diff(grad_f1_via_fa, grad_f1_via_fa_num,\\n \\\"corr-f1-via-fa\\\")\\n rel_diff(grad_f2_norm, grad_f2_norm_num,\\n \\\"corr->f2-norm\\\")\\n\\n if OLD_METHOD:\\n # (may be able to collapse all this later)\\n grad_f1_via_fa = grad_f1_via_fa.view(-1, H, W, 1, 1)\\n\\n # This tensor is crashing the GPU\\n grad_smcorr_fa = grad_f1_via_fa.repeat(1, 1, 1, h, w)\\n\\n # safety checks over the summation\\n if LOCAL_CHECKS:\\n with torch.enable_grad():\\n\\n smcorr_fa_num = smcorr_fa.clone().requires_grad_()\\n f1_via_fa_num = smcorr_fa_num.sum((3, 4))\\n # f1_via_fa_num = f1_via_fa_num.view(C, H * W)\\n\\n grad_smcorr_fa_num = torch.autograd.grad(\\n outputs=f1_via_fa_num,\\n inputs=(smcorr_fa_num,),\\n grad_outputs=grad_f1_via_fa.view(-1, H, w),\\n )\\n rel_diff(grad_smcorr_fa, grad_smcorr_fa_num[0],\\n \\\"summation of grad_smcorr-fa\\\")\\n\\n # smcorr_fa = smcorr[None, ...] * fa_.view(-1, 1, 1, h, w)\\n grad_smcorr = (grad_smcorr_fa * fa_norm.view(-1, 1, 1, h, w)).sum(0)\\n grad_fa_ = (grad_smcorr_fa * smcorr[None, ...]).sum(1).sum(1)\\n grad_fa_ = grad_fa_.reshape(C, h * w)\\n\\n # safety checks over the weighted sum\\n if LOCAL_CHECKS:\\n with torch.enable_grad():\\n\\n smcorr_num = smcorr.clone().requires_grad_()\\n fa_norm_num = fa_norm.clone().requires_grad_()\\n smcorr_fa_num = smcorr_num[None, ...] \\\\\\n * fa_norm_num.view(-1, 1, 1, h, w)\\n\\n (grad_smcorr_num, grad_fa_num) = torch.autograd.grad(\\n outputs=smcorr_fa_num,\\n inputs=(smcorr_num, fa_norm_num),\\n grad_outputs=grad_smcorr_fa,\\n )\\n rel_diff(grad_fa_, grad_fa_num,\\n \\\"product of grad_fa_\\\")\\n rel_diff(grad_smcorr, grad_smcorr_num,\\n \\\"product of grad_smcor\\\")\\n else:\\n # -------------------------------------------------------\\n # Collapsed summation method\\n # -------------------------------------------------------\\n # Fwd ops ->\\n # smcorr_fa = smcorr[None, ...] * fa.reshape(-1, 1, 1, h, w)\\n # f1_via_fa = smcorr_fa.sum((3, 4)).reshape(C, H * w)\\n\\n # Given gradient ->\\n # (grad_f1_via_fa)\\n\\n # Desired gradients ->\\n # (grad_fa_, grad_smcorr)\\n\\n grad_f1_via_fa = grad_f1_via_fa.view(-1, H, W, 1, 1)\\n\\n # safety checks over the summation\\n if LOCAL_CHECKS:\\n # This tensor is crashing the GPU, so should only be\\n # used for numerical checks\\n grad_smcorr_fa = grad_f1_via_fa.repeat(1, 1, 1, h, w)\\n with torch.enable_grad():\\n\\n smcorr_fa_num = smcorr_fa.clone().requires_grad_()\\n f1_via_fa_num = smcorr_fa_num.sum((3, 4))\\n # f1_via_fa_num = f1_via_fa_num.view(C, H * W)\\n\\n grad_smcorr_fa_num = torch.autograd.grad(\\n outputs=f1_via_fa_num,\\n inputs=(smcorr_fa_num,),\\n grad_outputs=grad_f1_via_fa.view(-1, H, w),\\n )\\n rel_diff(grad_smcorr_fa, grad_smcorr_fa_num[0],\\n \\\"summation of grad_smcorr-fa\\\")\\n\\n # Use for-loop over EVC dimension to avoid memory issues\\n if feats1.is_cuda:\\n if grad_f1_via_fa.dtype == torch.float64:\\n grad_smcorr = torch.cuda.DoubleTensor(H, W, h, w).fill_(0)\\n grad_fa_ = torch.cuda.DoubleTensor(C, h, w).fill_(0)\\n else:\\n grad_smcorr = torch.cuda.FloatTensor(H, W, h, w).fill_(0)\\n grad_fa_ = torch.cuda.FloatTensor(C, h, w).fill_(0)\\n else:\\n grad_smcorr = torch.zeros((H, W, h, w), dtype=feats1.dtype)\\n grad_fa_ = torch.zeros((C, h, w), dtype=feats1.dtype)\\n\\n for cc in range(C):\\n grad_smcorr += (grad_f1_via_fa[cc] * fa_norm[cc].view(1, 1, h, w))\\n grad_fa_[cc] = (grad_f1_via_fa[cc] * smcorr).sum((0, 1))\\n grad_fa_ = grad_fa_.reshape(C, h * w)\\n\\n # safety checks over the weighted sum\\n if LOCAL_CHECKS:\\n with torch.enable_grad():\\n\\n smcorr_num = smcorr.clone().requires_grad_()\\n fa_norm_num = fa_norm.clone().requires_grad_()\\n smcorr_fa_num = smcorr_num[None, ...] \\\\\\n * fa_norm_num.view(-1, 1, 1, h, w)\\n\\n (grad_smcorr_num, grad_fa_num) = torch.autograd.grad(\\n outputs=smcorr_fa_num,\\n inputs=(smcorr_num, fa_norm_num),\\n grad_outputs=grad_smcorr_fa,\\n )\\n rel_diff(grad_fa_, grad_fa_num,\\n \\\"product of grad_fa_\\\")\\n rel_diff(grad_smcorr, grad_smcorr_num,\\n \\\"product of grad_smcor\\\")\\n\\n if PRINT_MEM:\\n key = None\\n val = None\\n shape_mems = {}\\n for key, val in locals().items():\\n if hasattr(val, \\\"shape\\\"):\\n shape_mems[key] = estimate_mem(val)\\n\\n sorted_mems = sorted(shape_mems.items(), key=lambda kv: -kv[1])\\n for key, val in sorted_mems:\\n print(\\\"{}: {:.4f} GiB\\\".format(key, val))\\n\\n # Direct backward pass for first softmax\\n # smcorr = F.softmax(corr.view(H, W, -1), dim=2)\\n grad_smcorr = grad_smcorr.view(H, W, -1)\\n smcorr = smcorr.view(H, W, -1)\\n sum_term = torch.sum(grad_smcorr * smcorr, dim=2, keepdim=True)\\n grad_corr = smcorr * (grad_smcorr - sum_term)\\n\\n if not LOCAL_CHECKS:\\n del grad_smcorr\\n del grad_smcorr2\\n del smcorr\\n del corr\\n\\n if LOCAL_CHECKS:\\n with torch.enable_grad():\\n corr_num = corr.clone().requires_grad_()\\n smcorr_num = F.softmax(corr_num.view(H, W, -1), dim=2)\\n smcorr_num = smcorr_num.reshape(corr_num.shape)\\n grad_corr_num = torch.autograd.grad(\\n outputs=smcorr_num,\\n inputs=(corr_num,),\\n grad_outputs=grad_smcorr.view(H, W, h, w),\\n )\\n rel_diff(grad_corr, grad_corr_num[0].view(H, W, -1),\\n \\\"smax-corr\\\")\\n\\n # Back through the first correlation\\n # [Fwd op] -> `corr = torch.matmul(f1_norm.t(), fa_norm)`\\n grad_corr = grad_corr.view(H * W, h * w)\\n grad_f1_norm = torch.matmul(grad_corr, fa_norm.t()).t()\\n grad_fa_norm = torch.matmul(f1_norm, grad_corr)\\n\\n if not LOCAL_CHECKS:\\n del grad_corr\\n\\n\\n if LOCAL_CHECKS:\\n with torch.enable_grad():\\n f1_norm_num = f1_norm.clone().requires_grad_()\\n fa_norm_num = fa_norm.clone().requires_grad_()\\n corr_num = torch.matmul(f1_norm_num.t(), fa_norm_num)\\n grad_f1_norm_num, grad_fa_norm_num = torch.autograd.grad(\\n outputs=corr_num,\\n inputs=(f1_norm_num, fa_norm_num),\\n grad_outputs=grad_corr,\\n )\\n rel_diff(grad_f1_norm, grad_f1_norm_num, \\\"corr->f1n-orm\\\")\\n rel_diff(grad_fa_norm, grad_fa_norm_num, \\\"corr->fa-norm\\\")\\n\\n # Combine gradients for two ops using aux features\\n grad_fa_norm = grad_fa_norm + grad_fa_\\n\\n # Back through the norms\\n # [Fwd op] -> `f1_norm = F.normalize(f1_, p=2, dim=0) * JDT_FACTOR`\\n # [Fwd op] -> `f2_norm = F.normalize(f2_, p=2, dim=0) * JDT_FACTOR`\\n # [Fwd op] -> `fa_norm = F.normalize(fa_, p=2, dim=0) * JDT_FACTOR`\\n # xNorm = sqrt(sum(x.*x, 3) + opts.epsilon) ;\\n\\n if norm:\\n f1_norm_val = torch.norm(f1_, p=2, dim=0).clamp(min=EPS)\\n f2_norm_val = torch.norm(f2_, p=2, dim=0).clamp(min=EPS)\\n fa_norm_val = torch.norm(fa_, p=2, dim=0).clamp(min=EPS)\\n\\n max_val_f1 = torch.max(f1_norm_val)\\n max_val_f2 = torch.max(f2_norm_val)\\n max_val_fa = torch.max(fa_norm_val)\\n if max_val_f1 + max_val_f2 + max_val_fa > 1E8:\\n import ipdb; ipdb.set_trace()\\n\\n grad_f1_norm_ = grad_f1_norm / f1_norm_val\\n grad_f1 = JDT_FACTOR * (grad_f1_norm_ -\\n (grad_f1_norm_ * f1_).sum(0) * (f1_ / (f1_norm_val ** 2)))\\n\\n grad_f2_norm_ = grad_f2_norm / f2_norm_val\\n grad_f2 = JDT_FACTOR * (grad_f2_norm_ -\\n (grad_f2_norm_ * f2_).sum(0) * (f2_ / (f2_norm_val ** 2)))\\n\\n grad_fa_norm_ = grad_fa_norm / fa_norm_val\\n grad_fa = JDT_FACTOR * (grad_fa_norm_ -\\n (grad_fa_norm_ * fa_).sum(0) * (fa_ / (fa_norm_val ** 2)))\\n\\n if LOCAL_CHECKS:\\n with torch.enable_grad():\\n f1_num = f1_.clone().requires_grad_()\\n f2_num = f2_.clone().requires_grad_()\\n fa_num = fa_.clone().requires_grad_()\\n\\n f1_norm_num = F.normalize(f1_num, p=2, dim=0) * JDT_FACTOR\\n f2_norm_num = F.normalize(f2_num, p=2, dim=0) * JDT_FACTOR\\n fa_norm_num = F.normalize(fa_num, p=2, dim=0) * JDT_FACTOR\\n\\n grad_f1_num = torch.autograd.grad(\\n outputs=f1_norm_num,\\n inputs=(f1_num,),\\n grad_outputs=grad_f1_norm,\\n )\\n grad_f2_num = torch.autograd.grad(\\n outputs=f2_norm_num,\\n inputs=(f2_num,),\\n grad_outputs=grad_f2_norm,\\n )\\n grad_fa_num = torch.autograd.grad(\\n outputs=fa_norm_num,\\n inputs=(fa_num,),\\n grad_outputs=grad_fa_norm,\\n )\\n rel_diff(grad_f1, grad_f1_num[0], \\\"norm-f1\\\")\\n rel_diff(grad_f2, grad_f2_num[0], \\\"norm-f2\\\")\\n rel_diff(grad_fa, grad_fa_num[0], \\\"norm-fa\\\")\\n else:\\n grad_f1 = grad_f1_norm\\n grad_f2 = grad_f2_norm\\n grad_fa = grad_fa_norm\\n\\n\\n if PRINT_MEM:\\n key = None\\n val = None\\n shape_mems = {}\\n print(\\\"=======================\\\")\\n for key, val in locals().items():\\n if hasattr(val, \\\"shape\\\"):\\n shape_mems[key] = estimate_mem(val)\\n\\n sorted_mems = sorted(shape_mems.items(), key=lambda kv: -kv[1])\\n for key, val in sorted_mems:\\n print(\\\"{}: {:.4f} GiB\\\".format(key, val))\\n import ipdb; ipdb.set_trace()\\n\\n\\n # safety checks over the whole inner loop\\n if LOCAL_CHECKS:\\n with torch.enable_grad():\\n\\n f1_num = feats1[b].clone().detach().requires_grad_().reshape(C, H * W)\\n f2_num = feats2[b].clone().detach().requires_grad_().reshape(C, h * w)\\n fa_num = feats1[(b + 1) % B].clone().detach().requires_grad_().reshape(C, h * w)\\n\\n if norm:\\n f1_norm_num = F.normalize(f1_num, p=2, dim=0) * JDT_FACTOR\\n f2_norm_num = F.normalize(f2_num, p=2, dim=0) * JDT_FACTOR\\n fa_norm_num = F.normalize(fa_num, p=2, dim=0) * JDT_FACTOR\\n else:\\n f1_norm_num = f1_num\\n f2_norm_num = f2_num\\n fa_norm_num = fa_num\\n\\n # BLock 1 ------------------------------------------\\n corr_num = torch.matmul(f1_norm_num.t(), fa_norm_num)\\n corr_num = corr_num.reshape(H, W, H, W)\\n smcorr_num = F.softmax(corr_num.reshape(H, W, -1), dim=2)\\n smcorr_num = smcorr_num.reshape(corr_num.shape)\\n # BLock 1 ------------------------------------------\\n\\n\\n # BLock 2 ------------------------------------------\\n smcorr_fa_num = smcorr_num[None, ...] * \\\\\\n fa_norm_num.reshape(-1, 1, 1, h, w)\\n # BLock 2 ------------------------------------------\\n\\n\\n # BLock 3 ------------------------------------------\\n f1_via_fa_num = smcorr_fa_num.sum((3, 4)).reshape(C, H * W)\\n # BLock 3 ------------------------------------------\\n\\n # BLock 4 ------------------------------------------\\n corr2_num = torch.matmul(f1_via_fa_num.t(), f2_norm_num)\\n corr2_num = corr2_num.reshape(corr_num.shape)\\n smcorr2_num = F.softmax(corr2_num.reshape(H, W, -1), dim=2)\\n smcorr2_num = smcorr2_num.reshape(corr_num.shape)\\n # BLock 4 ------------------------------------------\\n\\n grad_f1_num, grad_fa_num, grad_f2_num = torch.autograd.grad(\\n outputs=(smcorr2_num,),\\n inputs=(f1_num, fa_num, f2_num),\\n grad_outputs=(grad_smcorr2.view(corr_num.shape)),\\n )\\n\\n rel_diff(grad_f1, grad_f1_num, \\\"df1_\\\")\\n rel_diff(grad_f2, grad_f2_num, \\\"df2_\\\")\\n rel_diff(grad_fa, grad_fa_num, \\\"dfa_\\\")\\n\\n \\\"\\\"\\\"Distribute the gradients back among the input tensor\\n features that require them.\\\"\\\"\\\"\\n grad_feats1[b] += grad_f1.reshape((C, H, W))\\n grad_feats1[(b + 1) % B] += grad_fa.reshape((C, h, w))\\n grad_feats2[b] += grad_f2.reshape((C, h, w))\\n\\n if PROFILE:\\n timings[\\\"feat-assign\\\"] += time.time() - tic\\n\\n\\n if LOCAL_CHECKS_INNER_LOOP:\\n with torch.enable_grad():\\n loss = 0.\\n grad_loss_ = grad_loss * (H * W * B) # unscale\\n for b in range(B):\\n f1 = feats1[b].reshape(C, H * W) # source\\n f2 = feats2[b].reshape(C, h * w) # target\\n fa = feats1[(b + 1) % B].reshape(C, h * w) # auxiliary\\n\\n if norm:\\n f1 = F.normalize(f1, p=2, dim=0) * JDT_FACTOR\\n f2 = F.normalize(f2, p=2, dim=0) * JDT_FACTOR\\n fa = F.normalize(fa, p=2, dim=0) * JDT_FACTOR\\n\\n corr = torch.matmul(f1.t(), fa)\\n corr = corr.reshape(H, W, h, w)\\n smcorr = F.softmax(corr.reshape(H, W, -1), dim=2).reshape(corr.shape)\\n smcorr_fa = smcorr[None, ...] * fa.reshape(-1, 1, 1, h, w)\\n # del smcorr\\n\\n f1_via_fa = smcorr_fa.sum((3, 4)).reshape(C, H * w)\\n # del smcorr_fa\\n\\n corr2 = torch.matmul(f1_via_fa.t(), f2).reshape(corr.shape)\\n smcorr2 = F.softmax(corr2.reshape(H, W, -1), dim=2).reshape(corr.shape)\\n # del corr2\\n\\n with torch.no_grad():\\n diff = batch_grid_u[b, :, :, None, None, :] - \\\\\\n xxyy[None, None, ::stride, ::stride, :]\\n diff = (diff * diff).sum(4).sqrt()\\n diff = diff.pow(pow)\\n L = diff * smcorr2\\n loss += L.float().sum()\\n\\n loss = loss / (H * W * B)\\n grad_f1_num, grad_f2_num = torch.autograd.grad(\\n outputs=loss,\\n inputs=(feats1, feats2),\\n grad_outputs=grad_loss_,\\n )\\n\\n rel_diff(grad_feats1, grad_f1_num, \\\"full-loop f2\\\")\\n rel_diff(grad_feats2, grad_f2_num, \\\"full-loop f2\\\")\\n\\n if PROFILE:\\n tic = time.time()\\n\\n if PRINT_MEM:\\n key = None\\n val = None\\n shape_mems = {}\\n for key, val in locals().items():\\n if hasattr(val, \\\"shape\\\"):\\n shape_mems[key] = estimate_mem(val)\\n\\n sorted_mems = sorted(shape_mems.items(), key=lambda kv: -kv[1])\\n for key, val in sorted_mems:\\n print(\\\"{}: {:.4f} GiB\\\".format(key, val))\\n\\n if PROFILE:\\n timings[\\\"cleanup\\\"] += time.time() - tic\\n\\n if PROFILE:\\n timings[\\\"minibatch\\\"] = time.time() - batch_tic\\n print(\\\"==============\\\")\\n total_ratios = 0\\n for key in timings:\\n ratio = 100 * timings[key] / timings[\\\"minibatch\\\"]\\n msg = \\\"{:.3f} ({:.2f}%) >>> {}\\\"\\n print(msg.format(timings[key], ratio, key))\\n total_ratios += ratio\\n msg = \\\"{:.3f}s >>> ratio total {}\\\"\\n print(msg.format(timings[\\\"minibatch\\\"], total_ratios - 100))\\n print(\\\"==============\\\")\\n\\n return (grad_feats1, grad_feats2, grad_xxyy, grad_batch_u,\\n grad_stride, grad_norm, grad_pow)\",\n \"def on_iter_backward(self, runner):\\n runner.optimizer.zero_grad()\\n runner.loss.backward()\\n runner.optimizer.step()\",\n \"def _backprop(self, y_train, X_train, A_hidden, Z_hidden, A_out, Z_out, batch_idx):\\n\\n # This is the derivative assuming our costfunction is 0.5*two_norm(A_out - y)**2\\n # This results in different backpropagation \\n \\n error_out = A_out - y_train[batch_idx].reshape(len(y_train[batch_idx]), 1)\\n \\n # Since we are in the regression case with a linear ouput funct.\\n act_derivative_out = 1\\n\\n delta_out = error_out*act_derivative_out\\n\\n grad_w_out = np.dot(A_hidden[-1].T, delta_out)\\n grad_b_out = np.sum(delta_out, axis=0)\\n\\n # Updating the output weights \\n self.W_out = self.W_out - self.eta * grad_w_out\\n self.b_out = self.b_out - self.eta * grad_b_out\\n \\n \\n # Looping over all the hidden layers except one\\n # If the layer only have one layer it doesn't go into this while loop \\n \\n i = 0\\n while (i < self.n_hidden_layers-1):\\n # Index moving backward in the layers.\\n #print(\\\"this should only be one loop\\\")\\n layer_ind = self.n_hidden_layers - 1 - i\\n #print(\\\"layer_ind: : \\\", layer_ind)\\n act_derivative_h = self.activate(Z_hidden[layer_ind], self.activation, deriv=True)\\n \\n if (i == 0):\\n error_prev = np.dot(delta_out, self.W_out.T) * act_derivative_h\\n else:\\n #print(\\\"np.shape(error_prev)\\\", np.shape(error_prev))\\n error_prev = np.dot(error_prev, self.W_h[layer_ind+1].T) * act_derivative_h\\n \\n grad_w_h = np.dot(A_hidden[layer_ind - 1].T, error_prev)\\n grad_b_h = np.sum(error_prev, axis=0)\\n \\n self.W_h[layer_ind] = self.W_h[layer_ind] - self.eta * grad_w_h\\n self.b_h[layer_ind] = self.b_h[layer_ind] - self.eta * grad_b_h\\n i += 1\\n \\n \\n act_derivative_h = self.activate(Z_hidden[0], self.activation, deriv=True) \\n \\n # Case with one hidden layer doesn't enter the while loop.\\n if( self.n_hidden_layers == 1):\\n error_last = np.dot(delta_out, self.W_out.T) * act_derivative_h\\n else:\\n error_last = np.dot(error_prev, self.W_h[layer_ind].T) * act_derivative_h\\n\\n grad_w_h = np.dot(X_train[batch_idx].T, error_last)\\n grad_b_h = np.sum(error_last, axis = 0)\\n\\n self.W_h[0] = self.W_h[0] - self.eta * grad_w_h\\n self.b_h[0] = self.b_h[0] - self.eta * grad_b_h\\n\\n return None\",\n \"def backward_pass(self, grad):\\n pass\",\n \"def compute_loss_and_gradients(self, X, y):\\n # TODO Compute loss and fill param gradients\\n # by running forward and backward passes through the model\",\n \"def backward_G(self):\\n self.loss_G.backward()\",\n \"def backward(ctx, grad_output):\\n loss, reg, u, lbda = ctx.saved_tensors\\n\\n device = u.device\\n\\n # do clever computations\\n eps = 1e-10\\n grad, = torch.autograd.grad(loss, u, only_inputs=True,\\n retain_graph=True)\\n x = (u - eps * grad).data\\n lbda = lbda.data\\n\\n prox_x = check_tensor(\\n np.array([prox_tv.tv1_1d(xx, eps * lbda) for xx in x]),\\n device=device,\\n )\\n grad_u = (u - prox_x) / eps\\n grad_lbda = reg.clone()\\n return (torch.ones(0), grad_u, grad_lbda)\",\n \"def backward(self, grad):\\n self.grads[\\\"w\\\"] = np.matmul(self.input_data.T, grad)\\n self.grads[\\\"b\\\"] = np.sum(grad, axis=0)\\n return np.matmul(self.input_data.T, grad)\",\n \"def backwards(delta,params,name='',activation_deriv=sigmoid_deriv):\\n # everything you may need for this layer\\n W = params['W' + name]\\n b = params['b' + name]\\n X, pre_act, post_act = params['cache_' + name]\\n # your code here\\n # do the derivative through activation first\\n # then compute the derivative W,b, and X\\n \\n delta_pre = activation_deriv(post_act) * delta\\n # (in_dim, out_dim) = (in_dim, examples) @ (examples, out_dim)\\n grad_W = X.transpose() @ delta_pre\\n grad_b = np.sum(delta_pre, axis=0, keepdims=True) # (1, out_dim)\\n # (examples, in_dim) = (examples, out_dim) @ (out_dim, in_dim)\\n grad_X = delta_pre @ W.transpose()\\n\\n # store the gradients\\n params['grad_W' + name] = grad_W\\n params['grad_b' + name] = grad_b\\n return grad_X\",\n \"def backward(ctx, grad_A):\\n Z, = ctx.saved_tensors\\n\\n grad_Z = None\\n\\n # We only need to compute gradients for tensors that are flagged to\\n # require gradients!\\n if ctx.needs_input_grad[0]:\\n sigmoid = 1. / (1. + torch.exp(-Z))\\n grad_Z = grad_A * sigmoid * (1. - sigmoid)\\n\\n return grad_Z\",\n \"def backward(self, accum_grad):\\n\\n W = self.W\\n\\n grad_w = self.layer_input.T.dot(accum_grad)\\n grad_b = np.sum(accum_grad, axis=0, keepdims=True)\\n\\n # Update the layer weights\\n self.W = self.W_optimizer.update(self.W, grad_w)\\n self.b = self.b_optimizer.update(self.b, grad_b)\\n\\n accum_grad = accum_grad.dot(W.T)\\n return accum_grad\",\n \"def backward(self, d_out):\\n # TODO: Implement backward pass\\n # Compute both gradient with respect to input\\n # and gradients with respect to W and B\\n # Add gradients of W and B to their `grad` attribute\\n\\n # It should be pretty similar to linear classifier from\\n # the previous assignment\\n\\n d_input = np.dot(d_out, self.W.value.T)\\n self.W.grad = np.dot(self.X.T, d_out)\\n self.B.grad = np.sum(d_out, axis=0, keepdims=True)\\n\\n return d_input\",\n \"def unrolled_backward(self, trn_X, trn_y, val_X, val_y, lr, w_optim, amended: bool = False):\\n # do virtual step (calc w`)\\n self.virtual_step(trn_X, trn_y, lr, w_optim)\\n\\n # calc unrolled loss\\n normal_alphas, reduce_alphas = self.v_net.alpha_weights()\\n loss = self.v_net.loss(val_X, val_y) # L_val(w`)\\n\\n # Loss += SUM[ none - mean(others) ]\\n loss += self.normal_none_penalty * sum([(alpha[:, -1] - alpha[:, :-1].mean()).sum() for alpha in normal_alphas])\\n loss += self.reduce_none_penalty * sum([(alpha[:, -1] - alpha[:, :-1].mean()).sum() for alpha in reduce_alphas])\\n\\n # compute gradient\\n v_alphas = tuple(self.v_net.alphas())\\n v_weights = tuple(self.v_net.weights())\\n v_grads = torch.autograd.grad(loss, v_alphas + v_weights)\\n dalpha = v_grads[:len(v_alphas)]\\n dw = v_grads[len(v_alphas):]\\n\\n hessian = self.amended_gradient(dw, trn_X, trn_y) if amended else self.compute_hessian(dw, trn_X, trn_y)\\n\\n # update final gradient = dalpha - lr*hessian\\n with torch.no_grad():\\n for alpha, da, h in zip(self.net.alphas(), dalpha, hessian):\\n alpha.grad = da - lr * h\",\n \"def L_model_backward(AL, Y, caches):\\n grads = {}\\n L = len(caches) # the number of layers\\n m = AL.shape[1]\\n Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL\\n\\n dAL = -(np.divide(Y,AL)-np.divide(1-Y,1-AL))\\n \\\"\\\"\\\"\\n cache = caches[-1]\\n grads[\\\"dA\\\"+str(L)],grads[\\\"dW\\\"+str(L)],grads[\\\"db\\\"+str(L)] = linear_activation_backward(dAL,cache,activation = 'sigmoid')\\n\\n for i in reversed(range(L-1)):\\n grads[\\\"dA\\\"+str(i+1)],grads[\\\"dW\\\"+str(i+1)],grads[\\\"db\\\"+str(i+1)] = linear_activation_backward(grads[\\\"dA\\\"+str(i+2)],caches[i],activation = 'relu')\\n \\\"\\\"\\\"\\n\\n current_cache = caches[-1]\\n grads[\\\"dA\\\" + str(L)], grads[\\\"dW\\\" + str(L)], grads[\\\"db\\\" + str(L)] = linear_backward(sigmoid_backward(dAL, current_cache[1]),current_cache[0])\\n\\n for l in reversed(range(L - 1)):\\n # lth layer: (RELU -> LINEAR) gradients.\\n # Inputs: \\\"grads[\\\"dA\\\" + str(l + 2)], caches\\\". Outputs: \\\"grads[\\\"dA\\\" + str(l + 1)] , grads[\\\"dW\\\" + str(l + 1)] , grads[\\\"db\\\" + str(l + 1)]\\n ### START CODE HERE ### (approx. 5 lines)\\n current_cache = caches[l]\\n dA_prev_temp, dW_temp, db_temp = linear_backward(sigmoid_backward(dAL, current_cache[1]), current_cache[0])\\n grads[\\\"dA\\\" + str(l + 1)] = dA_prev_temp\\n grads[\\\"dW\\\" + str(l + 1)] = dW_temp\\n grads[\\\"db\\\" + str(l + 1)] = db_temp\\n ### END CODE HERE ###\\n\\n return grads\",\n \"def backward(self, loss, update_hp_grads=True, clear_lp_grads=False, **bwd_kwargs):\\n self.clear_lp_grads()\\n loss.backward(**bwd_kwargs)\\n\\n if update_hp_grads:\\n self.update_hp_grads(clear_lp_grads=clear_lp_grads)\",\n \"def forward_backward_prop(data, labels, params, dimensions):\\n\\n ### Unpack network parameters (do not modify)\\n ofs = 0\\n Dx, H, Dy = (dimensions[0], dimensions[1], dimensions[2])\\n\\n W1 = np.reshape(params[ofs:ofs+ Dx * H], (Dx, H))\\n ofs += Dx * H\\n b1 = np.reshape(params[ofs:ofs + H], (1, H))\\n ofs += H\\n W2 = np.reshape(params[ofs:ofs + H * Dy], (H, Dy))\\n ofs += H * Dy\\n b2 = np.reshape(params[ofs:ofs + Dy], (1, Dy))\\n\\n #print W2.shape, b2.shape\\n\\n #print len(W1), data[0], b1, len(data)\\n\\n ### YOUR CODE HERE: forward propagation\\n #Eg, find the cost function. Save some intermediate stuff though, seems like it'd be useful\\n #h = sigmoid(x * w1 + b1)\\n # y = (softmax( h * w2 + b2)\\n # hence the cost function will be labels * log(y) and then sum it all up\\n\\n z_1 = np.matrix(data) * W1 + b1\\n h = sigmoid(z_1)\\n y_prime = softmax(h * W2 + b2)\\n logs = np.log(y_prime)\\n\\n #print y_prime.shape\\n\\n #print np.array(logs) * labels\\n\\n cost = - np.sum(np.array(logs) * labels, axis = 1)\\n cost = np.sum(cost) # lets add up each instance fo the cost for now and see what happens\\n\\n # My question is then do we just sum up the costs of each function\\n #print cost #somethign is printing so I'm gonan say i'm a genius right here duh\\n\\n #Cost(y, y') = -sum of (y * log Y')\\n ### END YOUR CODE\\n\\n ### YOUR CODE HERE: backward propagation\\n\\n # you'll need gradients for each parameter except for the input vectors. Right now this isn't even a word2vec\\n delta_1 = y_prime - labels\\n delta_2 = delta_1 * W2.T\\n #print sigmoid_grad(h).shape\\n delta_3 = np.array(delta_2) * sigmoid_grad(h)\\n\\n gradW2 = np.array(h.T * delta_1) # i dunno or its reverse OMG I HASTE EVERYONE why is it that np.array fixes everything. Sigh\\n gradb2 = np.array(np.sum(delta_1, axis=0)) # main issue is that this is a 20 x 5 vector when it should be a 1 x 5\\n gradW1 = data.T.dot(delta_3)\\n gradb1 = np.sum(delta_3, axis=0) # this should be 1 x10 not 20 x 5\\n\\n\\n\\n ### END YOUR CODE\\n\\n #print gradW1, gradW1.flatten()\\n # print 'jee'\\n\\n ### Stack gradients (do not modify)\\n grad = np.concatenate((\\n gradW1.flatten(),\\n gradb1.flatten(),\\n gradW2.flatten(),\\n gradb2.flatten())\\n )\\n #print grad\\n #print cost\\n return cost, grad\",\n \"def backward(self, d_out):\\n # TODO: Implement backward pass\\n # Compute both gradient with respect to input\\n # and gradients with respect to W and B\\n # Add gradients of W and B to their `grad` attribute\\n\\n # It should be pretty similar to linear classifier from\\n # the previous assignment\\n self.W.grad += np.dot(self.X.T, d_out)\\n self.B.grad += np.sum(d_out, axis=0)[np.newaxis, :]\\n return np.dot(d_out, self.W.value.T)\",\n \"def backward(self, grad_output):\\n raise NotImplementedError\",\n \"def backward(self, grad=None):\\n if not self.requires_grad:\\n raise RuntimeError(\\\"This tensor did not require grad!\\\")\\n grad = self._to_tensor(grad) if grad else Tensor(np.ones_like(self.data, dtype=np.float))\\n self.grad.data += grad.data\\n for node in self.nodes:\\n node.tensor.backward(Tensor(data=node.df(grad.data)))\",\n \"def backward(self, grad_z):\\n\\t\\t#######################################################################\\n\\t\\t# ** START OF YOUR CODE **\\n\\t\\t#######################################################################\\n\\n\\t\\tgradient = self._layers[-1].backward(grad_z)\\n\\t\\tfor i in range(len(self._layers) - 2, -1, -1):\\n\\t\\t\\tgradient = self._layers[i].backward(gradient)\\n\\t\\treturn gradient\\n\\n\\t\\t#######################################################################\\n\\t\\t# ** END OF YOUR CODE **\\n\\t\\t#######################################################################\",\n \"def backward(self, y_grad):\\n self.b_grad = y_grad.sum(axis=0)\\n dim = len(self.b_grad)\\n self.b_grad = self.b_grad.reshape((1, dim))\\n self.W_grad = (np.dot(np.transpose(y_grad), self.x))\\n\\n return y_grad.dot(self.W)\",\n \"def backward(ctx, grad_output_var):\\n xmin = 0\\n xmax = 1\\n grad_output = grad_output_var.data\\n gamma_mu,kappa,uTx,x = ctx.saved_tensors\\n n = kappa.size()[0]\\n nx = grad_output.size()[2]\\n u = 1/nx**2*torch.linspace(1,nx,nx)\\n norm_u = torch.norm(u)**2\\n torch_u = u.view(1,1,-1)+torch.zeros(n,1,nx)#broadcast\\n denom = (xmin-kappa)*(xmax-kappa)\\\\\\n -(kappa-uTx)*(xmin+xmax-2*kappa)\\\\\\n -2*gamma_mu*norm_u \\n #\\n idx = (denom.abs()>1e-7)\\n ind = (denom.abs()>1e-7)+ torch.zeros(n,1,nx)#broadcasting\\n ind = ind>0\\n denom[~idx] = denom[~idx]+1\\n grad_input_gamma_mu = (2*kappa-(xmin+xmax))/denom*torch_u\\n coeff = (xmax-kappa)*(xmin-kappa)/denom - 1\\n grad_input_u = torch.eye(nx) \\\\\\n +coeff*torch.matmul(torch_u.view(1,1,-1,1),u.view(1,-1))/norm_u\\n # if denom is very small, it means that gamma_mu is very small and u is very close to one of the bounds,\\n # there is a discontinuity when gamma_mu tends to zero, if 0<u<1 the derivative wrt x is approximately equal to \\n # 1 and the derivative wrt gamma_mu is approximated by 10^3 times the error 2kappa-xmin-xmax\\n grad_input_gamma_mu[~ind] = 0*grad_input_gamma_mu[~ind]+1e3*(2*kappa[~idx]-(xmin+xmax))\\n grad_input_u[~ind] = 0*grad_input_u[~ind]+1\\n \\n grad_input_gamma_mu = grad_input_gamma_mu*grad_output#.sum(1).sum(1).unsqueeze(1).unsqueeze(2)\\n grad_input_u = grad_input_u*grad_output\\n \\n # safety check for numerical instabilities\\n if (grad_input_gamma_mu!=grad_input_gamma_mu).any():\\n print('there is a nan in grad_input_gamma_mu')\\n if (x!=x).any():\\n print('there is a nan in x')\\n sys.exit()\\n if (grad_input_u!=grad_input_u).any():\\n print('there is a nan in grad_input_u')\\n sys.exit()\\n \\n grad_input_gamma_mu = Variable(grad_input_gamma_mu,requires_grad=True)\\n grad_input_u = Variable(grad_input_u,requires_grad=True)\\n \\n return grad_input_gamma_mu, grad_input_u, None\",\n \"def backprop(model, loss_function, optimizer, batch, device):\\n model.train()\\n model.to(device)\\n optimizer.zero_grad()\\n\\n inputs, targets = batch[0], batch[1]\\n\\n inputs = inputs.to(device)\\n targets = targets.to(device)\\n\\n outputs = model(inputs)\\n loss = loss_function(outputs, targets)\\n loss.backward()\\n optimizer.step()\",\n \"def backward(self,y_out, y_truth):\\n gradient = None\\n ###########################################################################\\n # TODO: #\\n # Implement the backward pass. Return the gradient wrt y_out #\\n # hint: you may use np.where here. #\\n ###########################################################################\\n\\n gradient = np.where(not np.all(y_out==0), 0, 1.e-18)\\n\\n ###########################################################################\\n # END OF YOUR CODE #\\n ########################################################################### \\n return gradient\",\n \"def backward(ctx, grad_output):\\n batch_size, n_dim = grad_output.shape\\n sign_z, = ctx.saved_tensors\\n device = grad_output.device\\n S = sign_z != 0\\n S[:, 0] = True\\n sign_z[:, 0] = 0\\n # XXX do clever computations\\n L = torch.triu(torch.ones((n_dim, n_dim), dtype=torch.float64,\\n device=device))\\n\\n grad_x, grad_lbda = [], []\\n for i in range(batch_size):\\n L_S = L[:, S[i]] # n_dim x |S|\\n grad_u = grad_output[i].matmul(L_S) # 1 x |S|\\n H_S = torch.inverse(L_S.t().matmul(L_S))\\n grad_x.append(grad_u.matmul(H_S.matmul(L_S.t())))\\n grad_lbda.append(grad_u.matmul(H_S.matmul(-sign_z[i][S[i]])))\\n grad_x = torch.stack(grad_x)\\n grad_lbda = torch.stack(grad_lbda)\\n return (grad_x, grad_lbda)\",\n \"def backward(self, outputs, labels):\\n # Layers & shape\\n depth = len(self.layer_dimensions) - 1\\n # num_classes, batch_size = outputs.shape\\n batch_size, num_classes = outputs.shape\\n coefficient = 1 / batch_size\\n # 1/ First case : last layer -> output\\n layer_a = \\\"a_\\\" + str(depth - 1)\\n a = self._cache[layer_a]\\n Jz = outputs - labels\\n # Weights gradients\\n dw = coefficient * np.dot(a.T, Jz)\\n db = coefficient * np.sum(Jz, axis=0)\\n self._grad[\\\"dw_\\\" + str(depth)] = dw\\n self._grad[\\\"db_\\\" + str(depth)] = db\\n # 2/ Second case : inside the layers\\n for i in range(depth - 1, 0, -1):\\n # Get the weights and biases\\n layer_w = \\\"w_\\\" + str(i + 1)\\n layer_a = \\\"a_\\\" + str(i - 1)\\n layer_z = \\\"z_\\\" + str(i)\\n w = self._parameters[layer_w]\\n a = self._cache[layer_a]\\n z = self._cache[layer_z]\\n # Gradients\\n Jz = self.activation_hidden.backward(z) * np.dot(Jz, w.T)\\n db = coefficient * np.sum(Jz, axis=0)\\n dw = coefficient * np.dot(a.T, Jz)\\n self._grad[\\\"dw_\\\" + str(i)] = dw\\n self._grad[\\\"db_\\\" + str(i)] = db\",\n \"def backward(self,y_out, y_truth):\\n gradient = None\\n\\n ###########################################################################\\n # TODO: #\\n # Implement the backward pass. Return the gradient wrt y_out #\\n ###########################################################################\\n\\n gradient = -1 * (np.multiply(y_truth, np.divide(1, y_out)) - np.multiply((1 - y_truth), np.divide(1, (1 - y_out))))\\n \\n ###########################################################################\\n # END OF YOUR CODE #\\n ########################################################################### \\n return gradient\",\n \"def backward(self, residuals):\\n in_channel, out_channel, kernel_size, a = self.weights.shape\\n dw = np.zeros_like(self.weights) \\n \\n for i in range(in_channel):\\n for o in range(out_channel):\\n dw[i, o] += inv_conv2(self.in_val[:,:,i], \\n residuals[:,:,o], \\n self.stride)\\n\\n self.db += residuals.sum(axis=1).sum(axis=0)\\n self.dw += dw \\n gradient_x = np.zeros_like(self.in_val)\\n \\n for i in range(in_channel):\\n for o in range(out_channel):\\n gradient_x[:,:,i] += conv_delta(residuals[:,:,o] \\n , self.weights[i][o]\\n , self.stride\\n , self.in_val.shape[0])\\n \\n return gradient_x\",\n \"def backward(self, index, gradOutput):\\n self.gradInput = np.dot(gradOutput, self.weight.T)\\n if index != -1:\\n self.gradWeight[index] += gradOutput #the gradients wrt. the params are accumulated\\n self.gradBias += gradOutput\\n return self.gradInput\",\n \"def backward(self, upstream_grad):\\n\\n # derivative of Cost w.r.t W\\n self.dW = np.dot(upstream_grad, self.A_prev.T)\\n\\n # derivative of Cost w.r.t b, sum across rows\\n self.db = np.sum(upstream_grad, axis=1, keepdims=True)\\n\\n # derivative of Cost w.r.t A_prev\\n self.dA_prev = np.dot(self.params['W'].T, upstream_grad)\",\n \"def backward(self,y_out, y_truth):\\n gradient = None\\n ###########################################################################\\n # TODO: #\\n # Implement the backward pass. Return the gradient wrt y_out #\\n ###########################################################################\\n\\n gradient = np.multiply(2, np.subtract(y_out, y_truth))\\n\\n ###########################################################################\\n # END OF YOUR CODE #\\n ########################################################################### \\n return gradient\",\n \"def backward(self, X, Y, P, H, lmd):\\n G = - (Y - P)\\n _, Npts = P.shape\\n n_layers = len(self.hidden_units)\\n\\n gradients_W = []\\n gradients_b = []\\n\\n for i in range(n_layers, -1, -1):\\n\\n if i == 0:\\n grad_W = G @ X.T * (1/Npts) + 2 * lmd * self.W[i]\\n grad_b = G @ np.ones((Npts, 1)) * (1/Npts)\\n\\n else:\\n\\n h = H[i - 1]\\n w = self.W[i]\\n grad_W = G @ h.T * (1/Npts) + 2 * lmd * w\\n grad_b = G @ np.ones((Npts, 1)) * (1/Npts)\\n\\n G = w.T @ G\\n G = G * np.where(h > 0, 1, 0)\\n\\n gradients_W.append(grad_W)\\n gradients_b.append(grad_b)\\n\\n return gradients_W, gradients_b\",\n \"def backward(self, inputs): \\n self.error = self.error * sigmoid(self.output, der=True) # because the activation function of last layer must be sigmoid\\n delta3_weights = np.dot(self.z2.T, self.error)\\n\\n self.error = np.dot(self.error, self.output3_weights.T) * self.af(self.z2, der=True) \\n delta2_weights = np.dot(self.z1.T, self.error)\\n\\n self.error = np.dot(self.error, self.hidden2_weights.T) * self.af(self.z1, der=True)\\n delta1_weights = np.dot(inputs.T, self.error)\\n\\n self.hidden1_weights -= self.lr * delta1_weights\\n self.hidden2_weights -= self.lr * delta2_weights\\n self.output3_weights -= self.lr * delta3_weights\",\n \"def compute_grad(*, model: nn.Module, loss: Tensor) -> None:\\n grad_list = torch.autograd.grad(loss, tuple(model.parameters()), retain_graph=True)\\n\\n for param, grad in zip(model.parameters(), grad_list):\\n param.grad = grad\",\n \"def backward(ctx, grad_output):\\n input, = ctx.saved_tensors\\n\\n sp = F.softplus(input)\\n grad_sp = -torch.expm1(sp)\\n\\n tsp = F.tanh(sp)\\n grad_tsp = (1 - tsp * tsp) * grad_sp\\n grad = input * grad_tsp + tsp\\n return grad\",\n \"def back_propagate(self,y):\\n if y.ndim > 1: #case of multioutput prediction\\n m = np.shape(y)[0] #number of samples\\n n = np.shape(y)[1] #number of output elements\\n \\n #calculating gradients for each layer\\n for layer, activation in zip(reversed(range(len(self.architecture))), self.activations[::-1]):\\n \\n if layer == len(self.architecture)-1: #identifies output layer and does output layer specific calculations\\n dCda_L = self.derivatives(function='mse', y_pred = self.all_data[f'A{layer}'], y= y)\\n da_LdZ_L = self.derivatives(np.sum(self.all_data[f'Z{layer}'], axis=0)*(1/m),activation)\\n delta_L = np.multiply(dCda_L,da_LdZ_L)\\n self.all_data[f'dCda_{layer}'] = dCda_L\\n self.all_data[f'da_{layer}dZ_{layer}'] = da_LdZ_L\\n self.all_data[f'delta_{layer}'] = delta_L\\n else: #for other layers\\n da_LdZ_l = self.derivatives(np.sum(self.all_data[f'Z{layer}'], axis=0)*(1/m),activation)\\n self.all_data[f'da_{layer}dZ_{layer}'] = da_LdZ_l\\n delta_l = np.multiply(np.dot(self.all_data[f'delta_{layer+1}'], (self.weights_and_biases[f'W{layer+1}']).T), da_LdZ_l) \\n self.all_data[f'delta_{layer}'] = delta_l\\n \\n dCdW_l = np.outer(np.sum(self.all_data[f'A{layer-1}'],axis=0)*(1/m),self.all_data[f'delta_{layer}'])\\n dCdb_l = self.all_data[f'delta_{layer}']\\n\\n ##saving calculated data\\n self.all_data[f'dCdW{layer}'] = dCdW_l\\n self.all_data[f'dCdb{layer}'] = dCdb_l\\n self.parameter_gradients[f'dCdW{layer}'] = dCdW_l\\n self.parameter_gradients[f'dCdb{layer}'] = dCdb_l\\n \\n else: #calculations for single dataset(eg for SGD)\\n m = 1\\n n = len(y)\\n\\n ##calculating gradients for each layer\\n for layer, activation in zip(reversed(range(len(self.architecture))), self.activations[::-1]):\\n \\n if layer == len(self.architecture)-1:\\n #dCda_L = (self.all_data[f'A{layer}'] - y)*(1/(m*n))*2\\n dCda_L = self.derivatives(function='mse', y_pred = self.all_data[f'A{layer}'], y=y)\\n da_LdZ_L = self.derivatives(self.all_data[f'Z{layer}'],activation)\\n delta_L = np.multiply(dCda_L,da_LdZ_L)\\n self.all_data[f'dCda_{layer}'] = dCda_L\\n self.all_data[f'da_{layer}dZ_{layer}'] = da_LdZ_L\\n self.all_data[f'delta_{layer}'] = delta_L\\n else:\\n da_LdZ_l = self.derivatives(self.all_data[f'Z{layer}'],activation)\\n self.all_data[f'da_{layer}dZ_{layer}'] = da_LdZ_l\\n delta_l = np.multiply(np.dot(self.all_data[f'delta_{layer+1}'], (self.weights_and_biases[f'W{layer+1}']).T), da_LdZ_l) \\n self.all_data[f'delta_{layer}'] = delta_l\\n\\n dCdW_l = np.outer(self.all_data[f'A{layer-1}'],self.all_data[f'delta_{layer}'])\\n dCdb_l = self.all_data[f'delta_{layer}']\\n\\n #saving data\\n self.all_data[f'dCdW{layer}'] = dCdW_l\\n self.all_data[f'dCdb{layer}'] = dCdb_l\\n self.parameter_gradients[f'dCdW{layer}'] = dCdW_l\\n self.parameter_gradients[f'dCdb{layer}'] = dCdb_l\",\n \"def gradient_descent(data_x, data_y, parameters, learn_rate, nb_iterations):\\n\\n # Cost history\\n cost_tracking = np.zeros(nb_iterations)\\n\\n for _i in range(nb_iterations):\\n parameters -= learn_rate * gradient(data_x, data_y, parameters)\\n # recording the cost for each iteration\\n cost_tracking[_i] = cost_function(data_x, data_y, parameters)\\n\\n return parameters, cost_tracking\",\n \"def backprop(self, grad):\\n # TODO: look into exploiting the symmetry of the result here\\n # to speed up the calculation\\n assert self.out is not None, 'must run forward() before running reverse()'\\n\\n grad = grad.reshape(self.work_shape)\\n\\n # first step is to compute the dot product between the activation levels\\n # and the input gradient\\n tmp = _multi_dot(grad, self.out)\\n # tmp will be of shape (K,) for an (N, K) work shape\\n tmp = np.broadcast_to(tmp[:, np.newaxis], self.work_shape)\\n\\n tmp2 = grad - tmp\\n gout = self.out*tmp2\\n return gout.reshape(self.in_shape)\",\n \"def __backpropagation(self, X, y, alpha):\\n # perform forward pass\\n y_pred = self.__feed_forward(X)\\n # loop over the layers backward\\n for i in reversed(range(len(self.__layers))):\\n layer = self.__layers[i]\\n\\n # output layer\\n if layer == self.__layers[-1]:\\n layer.error = 2 * (y_pred - y)\\n # other layers\\n else:\\n next_layer = self.__layers[i + 1]\\n layer.error = next_layer.error * next_layer.d_act_f(next_layer.p) @ next_layer.weights \\n\\n # update the weights\\n for i in range(len(self.__layers)):\\n layer = self.__layers[i]\\n input_to_use = np.atleast_2d(X if i == 0 else self.__layers[i - 1].z)\\n grad = (layer.error * layer.d_act_f(layer.p) * input_to_use.T)\\n if layer.weights.shape[1] != grad.shape[1]: grad = grad.T\\n layer.weights -= alpha * grad\",\n \"def compute_gradients(self, inputs, targets, hprev):\\n n = len(inputs)\\n loss = 0\\n\\n # Dictionaries for storing values during the forward pass\\n aa, xx, hh, oo, pp = {}, {}, {}, {}, {}\\n hh[-1] = np.copy(hprev)\\n\\n # Forward pass\\n for t in range(n):\\n xx[t] = np.zeros((self.vocab_len, 1))\\n xx[t][inputs[t]] = 1 # 1-hot-encoding\\n\\n aa[t], hh[t], oo[t], pp[t] = self.evaluate_classifier(hh[t-1], xx[t])\\n\\n loss += -np.log(pp[t][targets[t]][0]) # update the loss\\n\\n # Dictionary for storing the gradients\\n grads = {\\\"W\\\": np.zeros_like(self.W), \\\"U\\\": np.zeros_like(self.U),\\n \\\"V\\\": np.zeros_like(self.V), \\\"b\\\": np.zeros_like(self.b),\\n \\\"c\\\": np.zeros_like(self.c), \\\"o\\\": np.zeros_like(pp[0]),\\n \\\"h\\\": np.zeros_like(hh[0]), \\\"h_next\\\": np.zeros_like(hh[0]),\\n \\\"a\\\": np.zeros_like(aa[0])}\\n\\n # Backward pass\\n for t in reversed(range(n)):\\n grads[\\\"o\\\"] = np.copy(pp[t])\\n grads[\\\"o\\\"][targets[t]] -= 1\\n\\n grads[\\\"V\\\"] += grads[\\\"o\\\"]@hh[t].T\\n grads[\\\"c\\\"] += grads[\\\"o\\\"]\\n\\n grads[\\\"h\\\"] = np.matmul(self.V.T , grads[\\\"o\\\"] )+ grads[\\\"h_next\\\"]\\n grads[\\\"a\\\"] = np.multiply(grads[\\\"h\\\"], (1 - np.square(hh[t])))\\n\\n grads[\\\"U\\\"] += np.matmul(grads[\\\"a\\\"], xx[t].T)\\n grads[\\\"W\\\"] += np.matmul(grads[\\\"a\\\"], hh[t-1].T)\\n grads[\\\"b\\\"] += grads[\\\"a\\\"]\\n\\n grads[\\\"h_next\\\"] = np.matmul(self.W.T, grads[\\\"a\\\"])\\n\\n # Drop redundant gradients\\n grads = {k: grads[k] for k in grads if k not in [\\\"o\\\", \\\"h\\\", \\\"h_next\\\", \\\"a\\\"]}\\n\\n # Clip the gradients\\n for grad in grads:\\n grads[grad] = np.clip(grads[grad], -5, 5)\\n\\n # Update the hidden state sequence\\n h = hh[n-1]\\n\\n return grads, loss, h\",\n \"def test_multiple_gradient_descent_with_backprop():\\n layer_list = [7, 7, 7, 2]\\n print(\\\"test\\\", \\\"layer_list\\\", layer_list)\\n\\n X, W, B = initialize_parameters_for_layers(layer_list, 5)\\n\\n alpha = 0.01\\n num_iterations = 2000\\n num_layers = len(layer_list) - 1\\n\\n Y = np.arange(10).reshape(2, 5)\\n W, B, yhat = gradient_descent_for_n_layers(num_layers, W, B, X, Y, alpha, num_iterations)\\n\\n print(\\\"test done.\\\") # final W and B are\\\", W, \\\"and\\\", B)\\n print(\\\"final yhat\\\", yhat)\",\n \"def _poputil_recompute_backward(op, grads):\\n return grads\",\n \"def optimize(self, loss):\\n loss.backward()\\n self.optimizer.step()\\n self.optimizer.zero_grad()\",\n \"def optimize(self,gradients):\\n\\n for k in range(self.size):\\n delta_weight = self.learningRate * gradients[k]\\n full_change = delta_weight + self.momentum*self.last_change[k]\\n self.weights[k] -= full_change\\n self.last_change[k] = 1*gradients[k] #copy gradient mat\",\n \"def backward(model, xs, h1s, h2s, errs):\\n # errs is the gradients of output layer for the minibatch\\n # dW4 = (np.dot(h3s.T, errs))/xs.shape[0]\\n\\n # # Get gradient of hidden layer\\n # dh_3 = np.dot(errs, model['W4'].T)\\n # dh_3[h3s <= 0] = 0\\n \\n # # The bias \\\"neuron\\\" is the constant 1, we don't need to backpropagate its gradient\\n # # since it has no inputs, so we just remove its column from the gradient\\n # dh_3 = dh_3[:, :-1]\\n \\n # Gradient for weights H1 -> H2\\n dW3 = (np.dot(h2s.T, errs)) / xs.shape[0]\\n\\n dh_2 = np.dot(errs, model['W3'].T)\\n dh_2[h2s <= 0] = 0\\n \\n # The bias \\\"neuron\\\" is the constant 1, we don't need to backpropagate its gradient\\n # since it has no inputs, so we just remove its column from the gradient\\n dh_2 = dh_2[:, :-1]\\n \\n # Gradient for weights H1 -> H2\\n dW2 = (np.dot(h1s.T, dh_2)) / xs.shape[0]\\n \\n # Gradient of h1\\n dh_1 = np.dot(dh_2, model['W2'].T)\\n dh_1[h1s <= 0] = 0\\n\\n # Again, drop the bias column\\n dh_1 = dh_1[:, :-1]\\n \\n # Add the 1 to the data, to compute the gradient of W1\\n ones = np.ones((xs.shape[0], 1))\\n xs = np.hstack([xs, ones])\\n\\n dW1 = (np.dot(xs.T, dh_1))/xs.shape[0]\\n\\n return dict(W1=dW1, W2=dW2, W3=dW3)\",\n \"def backward(self, grad_output=None):\\n # Compute dL/dP_j\\n self.loss.backward(grad_output)\\n dLdP = self.preds_enc.grad\\n\\n # Turn batched vector into batched matrix for matmul\\n dLdP = dLdP.unsqueeze(-1)\\n\\n # Compute Jacobians wrt model weights\\n if self.rank == self.feature_src:\\n jacobians = self._compute_model_jacobians()\\n\\n # Populate parameter grad fields using Jacobians\\n params = torch.nn.utils.parameters_to_vector(self.model.parameters())\\n if self.rank == self.feature_src:\\n jacobian = torch.cat(\\n [jacobians[param] for param in self.model.parameters()], dim=0\\n )\\n else:\\n jacobian_size = (params.numel(), dLdP.size(-2))\\n jacobian = torch.empty(jacobian_size)\\n\\n jacobian = crypten.cryptensor(jacobian, src=self.feature_src)\\n\\n # Compute gradeints wrt each param\\n while jacobian.dim() < dLdP.dim():\\n jacobian = jacobian.unsqueeze(0)\\n grad = jacobian.matmul(dLdP)\\n grad = grad.view(-1, *(params.size()))\\n\\n # Compute DP noise\\n if not self.rr_prob:\\n # Determine noise generation function\\n generate_noise = (\\n self._generate_noise_from_src\\n if self.noise_src\\n else self._generate_noise_no_src\\n )\\n noise = generate_noise(params.size())\\n grad += noise\\n\\n # Sum over batch dimension\\n while grad.size() != params.size():\\n grad = grad.sum(0)\\n\\n # Decrypt dL/dP_j * dP_j/dW_i with Differential Privacy\\n grads = grad.flatten().get_plain_text(dst=self.feature_src)\\n\\n # Populate grad fields of parameters:\\n if self.rank == self.feature_src:\\n ind = 0\\n for param in self.model.parameters():\\n numel = param.numel()\\n param.grad = grads[ind : ind + numel].view(param.size())\\n ind += numel\",\n \"def backward(self, delta):\\n if self.activation_type == \\\"sigmoid\\\":\\n grad = self.grad_sigmoid()\\n\\n elif self.activation_type == \\\"tanh\\\":\\n grad = self.grad_tanh()\\n\\n elif self.activation_type == \\\"ReLU\\\":\\n grad = self.grad_ReLU()\\n\\n return grad * delta\",\n \"def back_prop_through_time(self, da, caches, batch_size, parameters):\\n\\n # Retrieve values from the caches\\n (caches, x) = caches\\n \\n # Retrieve important dimensions\\n n_x, n_a = self.nx, self.UNITS\\n \\n # initialize the gradients with the right sizes, to zeroes \\n da0 = np.zeros((n_a, batch_size))\\n dc_prevt = np.zeros(da0.shape)\\n dWf = np.zeros((n_a, n_a + n_x))\\n dWi = np.zeros(dWf.shape)\\n dWc = np.zeros(dWf.shape)\\n dWo = np.zeros(dWf.shape)\\n dbf = np.zeros((n_a, 1))\\n dbi = np.zeros(dbf.shape)\\n dbc = np.zeros(dbf.shape)\\n dbo = np.zeros(dbf.shape)\\n \\n #from the previous layer\\n da_prevt = da \\n\\n # loop back over the whole sequence\\n for t in reversed(range(self.T_x)):\\n # Compute all gradients using lstm_cell_backward\\n gradients = self.lstm_cell_backward(da_prevt, dc_prevt, caches[t], parameters)\\n # Store or add the gradient to the parameters' previous step's gradient\\n da_prevt = gradients[\\\"da_prev\\\"]\\n dc_prevt = gradients[\\\"dc_prev\\\"]\\n #sum up the gradients\\n dWf += gradients[\\\"dWf\\\"]\\n dWi += gradients[\\\"dWi\\\"]\\n dWc += gradients[\\\"dWc\\\"]\\n dWo += gradients[\\\"dWo\\\"]\\n dbf += gradients[\\\"dbf\\\"]\\n dbi += gradients[\\\"dbi\\\"]\\n dbc += gradients[\\\"dbc\\\"]\\n dbo += gradients[\\\"dbo\\\"]\\n \\n # Store the gradients in a python dictionary\\n gradients = {\\\"dWf\\\": dWf,\\\"dbf\\\": dbf, \\\"dWi\\\": dWi,\\\"dbi\\\": dbi,\\\"dWc\\\": dWc,\\\"dbc\\\": dbc, \\\"dWo\\\": dWo, \\\"dbo\\\": dbo}\\n\\n return gradients\",\n \"def compute_gradients(self):\\n wlist = self._neural_net.weights()\\n blist = self._neural_net.biases()\\n\\n nmatrices = len(wlist)\\n weight_grad = []\\n bias_grad = []\\n\\n cost_function = self._cost_function\\n weight_der = WeightDerivative(neural_net=self._neural_net,\\n data_src=self._data_src,\\n cost_function=cost_function)\\n biase_der = BiasDerivative(neural_net=self._neural_net,\\n data_src=self._data_src,\\n cost_function=cost_function)\\n for layer in range(nmatrices):\\n weight_grad.append(np.zeros(wlist[layer].shape))\\n bias_grad.append(np.zeros(blist[layer].shape))\\n\\n rows, cols = wlist[layer].shape\\n for i in range(rows):\\n for j in range(cols):\\n loc = ParameterLocation(layer=layer, row=i, column=j)\\n weight_grad[layer][i][j] = weight_der.partial_derivative(loc)\\n\\n for row in range(rows):\\n loc = ParameterLocation(layer=layer, row=row, column=0)\\n bias_grad[layer][row] = biase_der.partial_derivative(loc)\\n\\n return weight_grad, bias_grad\",\n \"def _update_parameters(self, loss):\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\",\n \"def backward(last_layer: str) -> Callable:\\n\\n def closure() -> Tuple[Optional[torch.Tensor], torch.Tensor]:\\n optimizer.zero_grad()\\n output = model(data)\\n if last_layer == \\\"output\\\":\\n output.backward(torch.ones_like(target))\\n return None, output\\n elif last_layer == 'loss':\\n loss = compute_loss(output - target)\\n loss.backward()\\n return loss, output\\n else:\\n assert False, 'last layer must be \\\"output\\\" or \\\"loss\\\"'\\n\\n return closure\",\n \"def backward(last_layer: str) -> Callable:\\n\\n def closure() -> Tuple[Optional[torch.Tensor], torch.Tensor]:\\n optimizer.zero_grad()\\n output = model(data)\\n if last_layer == \\\"output\\\":\\n output.backward(torch.ones_like(target))\\n return None, output\\n elif last_layer == 'loss':\\n loss = compute_loss(output - target)\\n loss.backward()\\n return loss, output\\n else:\\n assert False, 'last layer must be \\\"output\\\" or \\\"loss\\\"'\\n\\n return closure\",\n \"def backward(self, grad_of_output=None):\\n if grad_of_output is None:\\n grad_of_output = Tensor.ones(self.shape)\\n\\n if grad_of_output.shape != self.shape:\\n # this block will be executed only when graient is supplied\\n raise Exception('The shape of gradient and variable must match')\\n\\n if self.grad_fn is None:\\n raise Exception('backward should not be called on tensors '\\n + 'without grad_fn')\\n\\n return autograd.backward(self.grad_fn, grad_of_output)\",\n \"def backward_linear(Data):\\n\\n # data\\n graph = tf.Graph()\\n X = Data[0]\\n Y_ = Data[1]\\n\\n if X.shape[0] != Y_.shape[0]:\\n raise Exception(\\\"The quantity of Input X and Compare Y_ are not same!\\\")\\n\\n Loss = []\\n with graph.as_default():\\n print(\\\"This is the process of all the Dose!\\\")\\n print(\\\"There are %d data in this process.\\\" % X.shape[0])\\n print(\\\"Features of X: %d\\\" % X.shape[1])\\n print(\\\"Learning rate is: %f\\\" % learning_rate)\\n # Init all the parameters\\n global_step = tf.Variable(0, trainable=False)\\n\\n STEPS = int(Epoch * X.shape[0] / BATCH_SIZE) + 1\\n epoch = 0\\n\\n with tf.name_scope('inputs'):\\n x = tf.placeholder(tf.float32, [None, Forward.INPUT_NODE], name='x_Input')\\n y_ = tf.placeholder(tf.float32, [None, Forward.OUTPUT_NODE], name='y_Exact')\\n y = Forward.forward_linear(x, regularizer=None)\\n\\n # lost function\\n with tf.name_scope('loss'):\\n loss_mse = tf.reduce_mean(tf.square(y - y_))\\n loss = loss_mse + tf.add_n(tf.get_collection(\\\"losses\\\"))\\n tf.summary.scalar('loss', loss)\\n\\n # Todo\\n # LM algorithm\\n\\n # learning_rate = tf.train.exponential_decay(\\n # LEARNING_RATE_BASE,\\n # global_step,\\n # X.shape[0] / BATCH_SIZE,\\n # LEARNING_RATE_DECAY,\\n # staircase=True\\n # )\\n\\n with tf.name_scope('train'):\\n # train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step)\\n # train_step = tf.train.MomentumOptimizer(learning_rate, momentum=0.9).minimize(loss, global_step)\\n train_step = tf.train.AdamOptimizer(learning_rate, beta1=0.9, beta2=0.99).minimize(loss, global_step)\\n\\n # EMA algorithm\\n ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)\\n ema_op = ema.apply(tf.trainable_variables())\\n with tf.control_dependencies([train_step, ema_op]):\\n train_op = tf.no_op(name='train')\\n\\n # ready for storing the model\\n saver = tf.train.Saver()\\n\\n with tf.Session() as sess:\\n init_op = tf.global_variables_initializer()\\n sess.run(init_op)\\n\\n # Get the check point\\n ckpt = tf.train.get_checkpoint_state(MODEL_SAVE_PATH_LINEAR)\\n if ckpt and ckpt.model_checkpoint_path:\\n saver.restore(sess, ckpt.model_checkpoint_path)\\n\\n # begin multi threads\\n coord = tf.train.Coordinator()\\n threads = tf.train.start_queue_runners(sess, coord)\\n print(\\\"Begin the multi threads!\\\")\\n\\n # Graph\\n merged = tf.summary.merge_all()\\n writer = tf.summary.FileWriter(\\\"./logs_linear/\\\", sess.graph)\\n\\n # Training\\n for i in range(STEPS):\\n start = (i * BATCH_SIZE) % int(X.shape[0])\\n end = start + BATCH_SIZE\\n # if finish all the data\\n if end >= X.shape[0]:\\n end = X.shape[0]\\n\\n _, loss_value, step = sess.run([train_op, loss, global_step],\\n feed_dict={x: X[start:end], y_: Y_[start:end]})\\n\\n if i % 4000 == 0:\\n print(\\\"Steps are: %d , loss is: %g.\\\" % (step, loss_value))\\n rs = sess.run(merged, feed_dict={x: X[start:end], y_: Y_[start:end]})\\n writer.add_summary(rs, i)\\n saver.save(sess, os.path.join(MODEL_SAVE_PATH_LINEAR, MODEL_NAME), global_step)\\n\\n # a round\\n if end == X.shape[0]:\\n # get the results\\n epoch += 1\\n loss_total = sess.run(loss, feed_dict={x: X, y_: Y_})\\n\\n Loss.append(loss_total)\\n # Loss.append(loss_total*10000)\\n print(\\\"After %d epoch(s), steps are: %d, loss total is: %g.\\\\n\\\" % (epoch, step, loss_total))\\n saver.save(sess, os.path.join(MODEL_SAVE_PATH_LINEAR, MODEL_NAME), global_step)\\n\\n # close the multi threads\\n coord.request_stop()\\n coord.join(threads)\\n print(\\\"Close the multi threads!\\\")\\n\\n return Loss\",\n \"def learning_by_gradient_descent(y, tx, w, gamma):\\n loss = calculate_loss(y,tx,w)\\n grad = calculate_gradient(y,tx,w)\\n w_new = w - gamma*grad\\n #grad is for debugging purpose\\n return loss, w_new,grad\",\n \"def backward_D(self):\\n base_function._unfreeze(self.net_D)\\n #print(self.input_P2.shape, self.img_gen.shape)\\n self.loss_dis_img_gen = self.backward_D_basic(self.net_D, self.input_P2, self.img_gen)\",\n \"def backpropagate(self, error, learning_rate):\\n #assert isinstance(error, np.ndarray)\\n #assert isinstance(self._prev_layer._outputs, np.ndarray)\\n #assert isinstance(self._outputs, np.ndarray) \\n\\n # Compute deltas. \\n deltas = np.dot(error, self._activation_function.derivative_given_y(self._outputs))\\n \\n # Compute gradient.\\n synapse = np.dot(np.dot(error, self._prev_layer._outputs), learning_rate)\\n \\n # Adjust weights.\\n self._weights = np.add(self._weights, synapse)\\n \\n # Adjust bias weights.\\n if self._use_bias:\\n self._bias = np.add(self._bias, synapse)\\n \\n return deltas\",\n \"def backward(self, previous_grad, learning_rate):\\n conv_grad = np.zeros(self.conv_filter.shape)\\n for patch, i, j in self.image_patch(self.current_image):\\n for k in range(self.num_filters):\\n conv_grad[k] += patch*previous_grad[i,j,k]\\n \\n self.conv_filter -= learning_rate*conv_grad\\n return conv_grad\",\n \"def __backprop(self, X, Y_hat, Y):\\n m = Y.shape[1]\\n Y = Y.reshape(Y_hat.shape.eval())\\n\\n # Compute the gradient of the output layer\\n dA = - ((Y / Y_hat) - ((1 - Y) / (1 - Y_hat)))\\n i = len(self.layers) - 1\\n while i >= 0:\\n\\n # Get activation of the previous layer\\n A_prev = None\\n if i == 0:\\n A_prev = X\\n else:\\n A_prev = self.layers[i-1].A\\n \\n # Compute gradient for the next layer down\\n dA = self.layers[i]._Dense__backward(dA, A_prev)\\n i -= 1\",\n \"def backprop(self, grad):\\n self.a.backprop(self.partial_a() * grad) # backprop: dF/d(op)*d(op)/da -> dF/da\\n self.b.backprop(self.partial_b() * grad)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8062878","0.80259913","0.7828948","0.7777686","0.77527696","0.7702246","0.7693619","0.76381147","0.76381147","0.7636189","0.7616303","0.7592515","0.7568821","0.75661427","0.7554769","0.7545626","0.7532964","0.75251085","0.7524329","0.7416668","0.74125963","0.7404803","0.73786026","0.7376848","0.7375491","0.7316547","0.73004216","0.73004216","0.7290629","0.72891086","0.7288144","0.72702783","0.72677493","0.7263554","0.72590613","0.72552854","0.7253542","0.7246372","0.72442484","0.724339","0.7233947","0.7225608","0.71951544","0.7146683","0.7141457","0.7135528","0.71225506","0.710237","0.7099084","0.70913184","0.709047","0.70787215","0.70602137","0.7044998","0.70202595","0.7018884","0.6977833","0.6977797","0.69693893","0.6967144","0.6958734","0.69514513","0.6949482","0.6949383","0.6947638","0.693871","0.69338375","0.6926743","0.6925125","0.6922271","0.6915801","0.6914429","0.6905986","0.6897353","0.6892207","0.6886046","0.6868668","0.68641436","0.6862554","0.6847786","0.6845465","0.6843809","0.6842481","0.6833591","0.6824051","0.6822142","0.68194366","0.68170387","0.6813264","0.681314","0.68089014","0.68089014","0.6808211","0.6795945","0.6787569","0.67833894","0.67809993","0.67752016","0.67745006","0.6768384"],"string":"[\n \"0.8062878\",\n \"0.80259913\",\n \"0.7828948\",\n \"0.7777686\",\n \"0.77527696\",\n \"0.7702246\",\n \"0.7693619\",\n \"0.76381147\",\n \"0.76381147\",\n \"0.7636189\",\n \"0.7616303\",\n \"0.7592515\",\n \"0.7568821\",\n \"0.75661427\",\n \"0.7554769\",\n \"0.7545626\",\n \"0.7532964\",\n \"0.75251085\",\n \"0.7524329\",\n \"0.7416668\",\n \"0.74125963\",\n \"0.7404803\",\n \"0.73786026\",\n \"0.7376848\",\n \"0.7375491\",\n \"0.7316547\",\n \"0.73004216\",\n \"0.73004216\",\n \"0.7290629\",\n \"0.72891086\",\n \"0.7288144\",\n \"0.72702783\",\n \"0.72677493\",\n \"0.7263554\",\n \"0.72590613\",\n \"0.72552854\",\n \"0.7253542\",\n \"0.7246372\",\n \"0.72442484\",\n \"0.724339\",\n \"0.7233947\",\n \"0.7225608\",\n \"0.71951544\",\n \"0.7146683\",\n \"0.7141457\",\n \"0.7135528\",\n \"0.71225506\",\n \"0.710237\",\n \"0.7099084\",\n \"0.70913184\",\n \"0.709047\",\n \"0.70787215\",\n \"0.70602137\",\n \"0.7044998\",\n \"0.70202595\",\n \"0.7018884\",\n \"0.6977833\",\n \"0.6977797\",\n \"0.69693893\",\n \"0.6967144\",\n \"0.6958734\",\n \"0.69514513\",\n \"0.6949482\",\n \"0.6949383\",\n \"0.6947638\",\n \"0.693871\",\n \"0.69338375\",\n \"0.6926743\",\n \"0.6925125\",\n \"0.6922271\",\n \"0.6915801\",\n \"0.6914429\",\n \"0.6905986\",\n \"0.6897353\",\n \"0.6892207\",\n \"0.6886046\",\n \"0.6868668\",\n \"0.68641436\",\n \"0.6862554\",\n \"0.6847786\",\n \"0.6845465\",\n \"0.6843809\",\n \"0.6842481\",\n \"0.6833591\",\n \"0.6824051\",\n \"0.6822142\",\n \"0.68194366\",\n \"0.68170387\",\n \"0.6813264\",\n \"0.681314\",\n \"0.68089014\",\n \"0.68089014\",\n \"0.6808211\",\n \"0.6795945\",\n \"0.6787569\",\n \"0.67833894\",\n \"0.67809993\",\n \"0.67752016\",\n \"0.67745006\",\n \"0.6768384\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6830542"},"document_rank":{"kind":"string","value":"84"}}},{"rowIdx":12191,"cells":{"query":{"kind":"string","value":"Compute the loss and gradients for an iteration."},"document":{"kind":"string","value":"def loss(self, X, y=None, lambda_reg=0.0):\n \n # Unpack variables from the params dictionary\n N, D = X.shape\n\n # Compute the forward pass\n #############################################################################\n # TODO: Perform the forward pass, computing the class scores for the input. #\n # Store the result in the scores variable, which should be an array of #\n # shape (N, C). #\n #############################################################################\n scores, cache_list = self.network_forward(X)\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n\n \n #############################################################################\n # TODO: Compute for the loss. This should include L2 regularization for #\n # the weights of each layer. #\n #############################################################################\n loss_softmax, dloss_softmax = self.softmax_cross_entropy_loss(scores, y)\n loss = loss_softmax\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n\n \n #############################################################################\n # TODO: Compute the derivatives of the weights and biases. Store the #\n # results in the grads dictionary. For example, grads['W1'] should store #\n # the gradient on the weights W of the first layer, and be a matrix of #\n # same size. #\n #############################################################################\n grads = self.network_backward(dloss_softmax, cache_list)\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n\n return loss, grads"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def train(self) -> None:\n for _ in range(self.epochs):\n for x, y in zip(self.x_train, self.y_train):\n\n weights_gradient = [\n None for weight in self.weights\n ] # Initializing weight gradients for each layer which are going to be used to update the weights in the network.\n\n biases_gradient = [\n None for bias in self.biases\n ] # Initializing bias gradients for each layer which are going to be used to update the biases in the network.\n\n activation = np.expand_dims(x, axis=1)\n activations = [\n activation\n ] # A list for storing all the activations when doing forward propagation\n\n values = (\n []\n ) # A list for storing weight * x + bias values without applying the activation function.\n\n for weight, bias in zip(self.weights, self.biases):\n value = np.dot(weight, activation) + bias\n values.append(value)\n\n activation = self.sigmoid(value)\n activations.append(activation)\n\n \"\"\"\n Calculating the error delta from output layer to be propagated backwards in the network. It is calculated\n by taking the derivative of the loss function, which in our case is MSE, and multiply with derivate of\n the sigmoid function applied on the value that entered the last layer of the network.\n \"\"\"\n\n error_delta = (activations[-1] - y) * self.sigmoid_derivative(\n values[-1]\n )\n\n weights_gradient[-1] = np.dot(\n error_delta, activations[-2].T\n ) # Setting error delta multiplied with the second last layer activations as weight gradient for last layer.\n\n biases_gradient[-1] = error_delta # Setting error delta as bias gradient for last layer.\n\n \"\"\"\n This for-loop does the same as the code from line 128 - 136, but for each layer in the network.\n Thus, the error is propagated backwards in the network, and the gradients for each layer are set.\n \"\"\"\n for layer in range(2, self.total_layers):\n error_delta = np.dot(\n self.weights[-layer + 1].T, error_delta\n ) * self.sigmoid_derivative(values[-layer])\n\n weights_gradient[-layer] = np.dot(\n error_delta, activations[-layer - 1].T\n )\n\n biases_gradient[-layer] = error_delta\n\n self.weights = [\n weight - self.lr * weight_gradient\n for weight, weight_gradient in zip(self.weights, weights_gradient)\n ] # Updating the weights of the network by w_i - learning_rate * nabla w_i (w_i is the weight matrix at layer i, and nabla w_i is weight gradient.)\n\n self.biases = [\n bias - self.lr * bias_gradient\n for bias, bias_gradient in zip(self.biases, biases_gradient)\n ] # Updating the biases of the network by b_i - learning_rate * nabla b_i (b_i is the bias vector at layer i, and nabla b_i is weight gradient.)","def train_step(self):\n\n # Custom gradient\n if self.model.computed_gradient:\n outputs = self.model.compute_all(next(self.dataset_it))\n gradients = outputs[\"gradients\"]\n\n # Compute\n else:\n with tf.GradientTape() as tape:\n outputs = self.model.compute_all(next(self.dataset_it))\n gradients = tape.gradient(outputs[\"loss\"], self.params)\n\n # Apply\n self.optimizer.apply_gradients(zip(gradients, self.params))\n\n return outputs","def grad_step(self, data, optimizer):\n\n running_loss = 0\n \n for i, batch in enumerate(data):\n optimizer.zero_grad()\n \n # print(batch)\n\n nums, labels = batch\n nums = nums.transpose(0,1)\n # nums = nums.squeeze(1).reshape((-1, 784))\n hidden = self.init_hidden(nums.size(1))\n # print(nums.shape)\n # # forward\n out, _ = self(nums, hidden)\n # loss = -self.obs.distr(out).log_prob(labels).mean()\n # print(out.shape)\n # print(labels.shape)\n loss = nn.BCEWithLogitsLoss()(out.squeeze(), labels.squeeze())\n # loss = -self.obs.distr(out).log_prob(labels).sum()\n \n # loss = -loglihood(self, nums, labels)\n # foo = self(nums)[0]\n # loss = nn.NLLLoss(reduction='sum')(foo, labels)\n\n # optimise\n loss.backward()\n optimizer.step()\n \n running_loss += loss.item()\n \n return running_loss/(i+1)","def _optimization_closure(self, iteration, step):\n aug = self._get_augmentation(iteration)\n if iteration == self.num_iter_per_step - 1:\n reg_noise_std = 0\n aug = 0\n else:\n reg_noise_std = (1 / 1000.) * (iteration // 400)\n # creates left_net_inputs and right_net_inputs by adding small noise\n clean_nets_inputs = [clean_net_input[aug] + (clean_net_input[aug].clone().normal_() * reg_noise_std)\n for clean_net_input in self.clean_nets_inputs]\n watermark_net_input = self.watermark_net_input[aug] # + (self.watermark_net_input[aug].clone().normal_() * reg_noise_std)\n mask_net_input = self.mask_net_input[aug]\n # applies the nets\n self.clean_nets_outputs = [clean_net(clean_net_input) for clean_net, clean_net_input\n in zip(self.clean_nets, clean_nets_inputs)]\n self.watermark_net_output = self.watermark_net(watermark_net_input)\n self.mask_net_output = self.mask_net(mask_net_input)\n self.total_loss = 0\n self.blur = 0\n\n self.total_loss += sum(self.l1_loss(self.watermark_net_output * self.mask_net_output +\n clean_net_output * (1 - self.mask_net_output), image_torch[aug])\n for clean_net_output, image_torch in zip(self.clean_nets_outputs, self.images_torch))\n self.total_loss.backward(retain_graph=True)","def compute_gradients(self):\n wlist = self._neural_net.weights()\n blist = self._neural_net.biases()\n\n nmatrices = len(wlist)\n weight_grad = []\n bias_grad = []\n\n cost_function = self._cost_function\n weight_der = WeightDerivative(neural_net=self._neural_net,\n data_src=self._data_src,\n cost_function=cost_function)\n biase_der = BiasDerivative(neural_net=self._neural_net,\n data_src=self._data_src,\n cost_function=cost_function)\n for layer in range(nmatrices):\n weight_grad.append(np.zeros(wlist[layer].shape))\n bias_grad.append(np.zeros(blist[layer].shape))\n\n rows, cols = wlist[layer].shape\n for i in range(rows):\n for j in range(cols):\n loc = ParameterLocation(layer=layer, row=i, column=j)\n weight_grad[layer][i][j] = weight_der.partial_derivative(loc)\n\n for row in range(rows):\n loc = ParameterLocation(layer=layer, row=row, column=0)\n bias_grad[layer][row] = biase_der.partial_derivative(loc)\n\n return weight_grad, bias_grad","def update_grhs():\n init_gradient()\n costs_per_batch = []\n for i in range(n_train_batches):\n c = update_gradient_batch(i,*args)\n costs_per_batch.append(c)\n return numpy.mean(costs_per_batch,axis=0)","def compute_gradients(self):\n raise NotImplementedError()","def compute_gradient(self, verbose):\n from inversionson.helpers.autoinverter_helpers import IterationListener\n\n # Attempt to dispatch model smoothing right at the beginning.\n # So there is no smoothing bottleneck when updates are not smoothed.\n it_listen = IterationListener(\n self.comm,\n events=self.comm.project.events_in_iteration)\n it_listen.listen()\n\n self.task_dict[\"forward_submitted\"] = True\n self.task_dict[\"misfit_completed\"] = True\n self.task_dict[\"gradient_completed\"] = True\n self._update_task_file()\n self.finish_task()","def optimizer(self):\n \n # taken from https://github.com/germain-hug/Deep-RL-Keras/blob/master/DDPG/actor.py\n # I believe this is a work around to get keras to learn **given a gradient**\n # As opposed to bunch of x_train, y_trains?\n \n #Inputs\n state_pl = self.model.input\n action_grads_pl = K.placeholder(shape=(None,1)) \n \n #Find grad_(pars) mu(state)\n mu_pl = self.model.output\n pars = self.model.trainable_weights\n pars_grad_mu = tf.gradients(mu_pl, pars, -action_grads_pl)\n \n #grads_and_pars = zip(pars_grad_mu, pars) #keras needs this form\n #updates = tf.train.AdamOptimizer(self.lr).apply_gradients(grads_and_pars)\n\n # The gradients as defined above work on my mac, but not ubuntu.\n # Below I am trying a workaround. I changed the keras source code \n # To get this working. Specifically, I make the optimizer.get_updates()\n # function accept custom gradients. It was easy to do.\n \n opt = Adam(self.lr)\n loss = pars_grad_mu #placeholder, I won't use it\n updates = opt.get_updates(loss = loss, params = pars, grads = pars_grad_mu)\n\n return K.function(inputs = [state_pl, action_grads_pl], outputs = [], updates = updates)\n #return K.function(inputs = [state_pl, action_grads_pl], outputs = [updates])","def compute_loss_and_gradients(self, X, y):\n # TODO Compute loss and fill param gradients\n # by running forward and backward passes through the model","def eval_one_iteration(sess, model, cv_num_batch, iteration):\n counter = 0\n cv_g_mse_loss = 0.0\n cv_g_l2_loss = 0.0\n cv_g_loss = 0.0\n for batch in range(int(cv_num_batch/FLAGS.num_gpu)):\n g_mse_losses, g_l2_losses, \\\n g_losses = sess.run([model.g_mse_losses,\n model.g_l2_losses,\n model.g_losses])\n g_mse_loss = np.mean(g_mse_losses)\n g_l2_loss = np.mean(g_l2_losses)\n g_loss = np.mean(g_losses)\n counter += FLAGS.num_gpu\n cv_g_mse_loss += g_mse_loss\n cv_g_l2_loss += g_l2_loss\n cv_g_loss += g_loss\n\n _summaries = sess.run(model.summaries)\n model.writer.add_summary(_summaries, iteration * cv_num_batch)\n\n cv_g_mse_loss = cv_g_mse_loss / counter * FLAGS.num_gpu\n cv_g_l2_loss = cv_g_l2_loss / counter * FLAGS.num_gpu\n cv_g_loss = cv_g_loss / counter * FLAGS.num_gpu\n\n return cv_g_mse_loss, cv_g_l2_loss, cv_g_loss","def compute_loss_and_gradients(self, X, y):\n # Before running forward and backward pass through the model,\n # clear parameter gradients aggregated from the previous pass\n # TODO Set parameter gradient to zeros\n # Hint: using self.params() might be useful!\n self.fulllayer1.W.grad = np.zeros_like(self.fulllayer1.W.grad)\n self.fulllayer1.B.grad = np.zeros_like(self.fulllayer1.B.grad)\n self.fulllayer2.W.grad = np.zeros_like(self.fulllayer2.W.grad)\n self.fulllayer2.B.grad = np.zeros_like(self.fulllayer2.B.grad)\n\n\n # TODO Compute loss and fill param gradients\n # by running forward and backward passes through the model\n res = self.fulllayer1.forward(X)\n res2 = self.reglayer1.forward(res)\n res3 = self.fulllayer2.forward(res2)\n\n loss, grad = softmax_with_cross_entropy(res3, y)\n\n back3 = self.fulllayer2.backward(grad)\n back2 = self.reglayer1.backward(back3)\n back = self.fulllayer1.backward(back2)\n \n # After that, implement l2 regularization on all params\n # Hint: self.params() is useful again!\n\n for params in self.params().keys():\n # print(params)\n # print(self.params()[params].value)\n loc_loss, loc_grad = l2_regularization(self.params()[params].value, self.reg)\n loss += loc_loss\n self.params()[params].grad += loc_grad\n\n return loss","def compute_gradients(self, inputs, targets, hprev):\n n = len(inputs)\n loss = 0\n\n # Dictionaries for storing values during the forward pass\n aa, xx, hh, oo, pp = {}, {}, {}, {}, {}\n hh[-1] = np.copy(hprev)\n\n # Forward pass\n for t in range(n):\n xx[t] = np.zeros((self.vocab_len, 1))\n xx[t][inputs[t]] = 1 # 1-hot-encoding\n\n aa[t], hh[t], oo[t], pp[t] = self.evaluate_classifier(hh[t-1], xx[t])\n\n loss += -np.log(pp[t][targets[t]][0]) # update the loss\n\n # Dictionary for storing the gradients\n grads = {\"W\": np.zeros_like(self.W), \"U\": np.zeros_like(self.U),\n \"V\": np.zeros_like(self.V), \"b\": np.zeros_like(self.b),\n \"c\": np.zeros_like(self.c), \"o\": np.zeros_like(pp[0]),\n \"h\": np.zeros_like(hh[0]), \"h_next\": np.zeros_like(hh[0]),\n \"a\": np.zeros_like(aa[0])}\n\n # Backward pass\n for t in reversed(range(n)):\n grads[\"o\"] = np.copy(pp[t])\n grads[\"o\"][targets[t]] -= 1\n\n grads[\"V\"] += grads[\"o\"]@hh[t].T\n grads[\"c\"] += grads[\"o\"]\n\n grads[\"h\"] = np.matmul(self.V.T , grads[\"o\"] )+ grads[\"h_next\"]\n grads[\"a\"] = np.multiply(grads[\"h\"], (1 - np.square(hh[t])))\n\n grads[\"U\"] += np.matmul(grads[\"a\"], xx[t].T)\n grads[\"W\"] += np.matmul(grads[\"a\"], hh[t-1].T)\n grads[\"b\"] += grads[\"a\"]\n\n grads[\"h_next\"] = np.matmul(self.W.T, grads[\"a\"])\n\n # Drop redundant gradients\n grads = {k: grads[k] for k in grads if k not in [\"o\", \"h\", \"h_next\", \"a\"]}\n\n # Clip the gradients\n for grad in grads:\n grads[grad] = np.clip(grads[grad], -5, 5)\n\n # Update the hidden state sequence\n h = hh[n-1]\n\n return grads, loss, h","def _compute_gradients(self, config):\n with tf.GradientTape() as tape:\n all_loss = self._compute_loss(**config)\n # Compute gradients wrt input image\n total_loss = all_loss[0]\n return tape.gradient(total_loss, config['init_image']), all_loss","def compute_gradients_and_update(batch_y0, batch_yN):\n with tf.GradientTape() as g:\n pred_y = node_network(tb, batch_y0)\n loss = tf.reduce_mean(tf.abs(pred_y - batch_yN))\n grads = g.gradient(loss, var_list)\n optimizer.apply_gradients(zip(grads, var_list))\n return loss","def _compute(self, global_step, params, batch_loss):\n individual_losses = get_individual_losses(global_step)\n individual_gradients = autograd_individual_gradients(\n individual_losses, params, concat=True\n )\n hist, edges = self._compute_histogram(individual_gradients)\n\n return {\"hist\": hist.float(), \"edges\": edges}","def calculate_per_sample_gradients(self):\n if not self._forward_succesful:\n raise RuntimeError(\n \"An error occured during model training. Please ascertain that the\"\n \" model.forward() method was called before calculating per sample gradients\"\n )\n\n for model in self.models:\n for param in model.parameters():\n if param.requires_grad and param.grad is None:\n raise RuntimeError(\n \"No gradients have been calculated yet! This method should be\"\n \" called after .backward() was called on the loss.\"\n )\n\n model_grads = zip(\n *[\n [param.grad for param in m.parameters() if param.requires_grad]\n for m in self.models\n ]\n ) # a list of length = self.replicas which holds lists of parameter gradients\n\n for param, gradient_source in zip(\n [param for param in self.wrapped_model.parameters() if param.requires_grad],\n model_grads,\n ):\n if param.requires_grad:\n setattr(\n param,\n \"accumulated_gradients\",\n torch.stack(gradient_source),\n )","def compute_loss(self, inputs):\r\n outputs = self.net.compute_outputs(inputs)\r\n loss_grad = self.net.compute_loss_grad(outputs - inputs)\r\n loss = np.sum((inputs - outputs) ** 2, axis=0).mean() / 2.0\r\n return loss, loss_grad","def _batch_gradient_descent(self, X, y, lr, epochs):\n\n # Initialize the bias and weights.\n _, n = X.shape\n self.bias = 0\n self.weights = np.random.normal(size=n)\n\n for i in range(epochs):\n # Calculate and sum the gradient delta of each sample\n grad_bias, grad_weights = self._get_gradient(X, y)\n\n # Show the gradient of each epoch.\n grad = (grad_bias + grad_weights.mean()) / 2\n print(\"Epochs %d gradient %.3f\" % (i + 1, grad), flush=True)\n\n # Update the bias and weight by gradient of current epoch\n self.bias += lr * grad_bias\n self.weights += lr * grad_weights","def backward(self, i):\n \n #Compute gradient for w1, w2, w3\n w1_grad = np.zeros((2, 3))\n w2_grad = np.zeros((3, 3))\n w3_grad = np.zeros((3, 1))\n \n \n w3_backward_pass = np.zeros((1, 1))\n w2_backward_pass = np.zeros((1, 3))\n \n #print(\"self.error shape\",self.error.shape)\n #Compute w3 gradient\n for i, w in enumerate(w3_grad): # 3 x 1 \n w3_forward_pass = self.a2[0][i]\n w3_backward_pass = self.error * der_sigmoid(self.y)\n w3_grad[i] = w3_forward_pass * w3_backward_pass\n \n #Compute w2 gradient\n for i, w_row in enumerate(w2_grad): # 3 x 3 \n for j, w in enumerate(w2_grad[i]):# 1 x 3 \n w2_forward_pass = self.a1[0][i]\n w2_backward_pass[0][i] = der_sigmoid(self.a2[0][i]) * self.w3[i][0] * w3_backward_pass\n w2_grad[i][j] = w2_forward_pass * w2_backward_pass[0][i]\n \n \n #Compute w1 gradient \n for i, w_rol in enumerate(w1_grad): # 2 x 3\n for j, w in enumerate(w1_grad[i]): # 1 x 3\n w1_forward_pass = self.input[0][i]\n w1_backward_pass = der_sigmoid(self.a1[0][i]) * self.w2[i][j] * w2_backward_pass[0][i]\n w1_grad[i][j] = w1_forward_pass * w1_backward_pass\n \n \n #Update \n for i, w in enumerate(w3_grad): \n self.w3[i] -= self.learning_rate * w3_grad[i]\n \n for i, w_row in enumerate(w2_grad): # 3 x 3 \n for j, w in enumerate(w2_grad[i]):# 1 x 3 \n self.w2[i][j] -= self.learning_rate * w2_grad[i][j]\n \n for i, w_rol in enumerate(w1_grad): # 2 x 3\n for j, w in enumerate(w1_grad[i]): # 1 x 3\n self.w1[i][j] -= self.learning_rate * w1_grad[i][j]\n \n #print(\"w3 grad : \", w3_grad)\n #print(\"w3.shape :\", self.w3.shape)","def _optimize(self):\n # Retrieve all trainable variables\n train_variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\n\n # Compute the gradient (return a pair of variable and their respective gradient)\n grads = self.optimizer.compute_gradients(loss=self.loss, var_list=train_variables)\n self.train_dis = self.optimizer.apply_gradients(grads, global_step=self.global_step)","def evaluate_loss(net, data_iter, loss): #@save\n metric = d2l.Accumulator(2) # Sum of losses, no. of examples\n for X, y in data_iter:\n l = loss(net(X), y)\n metric.add(d2l.reduce_sum(l), d2l.size(l))\n return metric[0] / metric[1]","def ComputeGradients(self, input_data: list, target_output_data: list):\n delta = 1e-6\n normal_cost = self.Cost(input_data, target_output_data)\n\n # Evaluate Gradient for Hidden Layer Biases\n for i in range(self.hidden_layer_biases.shape[0]):\n original_bias_value = self.hidden_layer_biases[i]\n self.hidden_layer_biases[i] += delta\n plusdelta_cost = self.Cost(input_data, target_output_data)\n self.hidden_layer_biases[i] = original_bias_value\n self.hidden_biases_gradient[i] = (plusdelta_cost - normal_cost) / delta\n\n # Evaluate Gradient for Output Layer Biases\n for i in range(self.output_layer_biases.shape[0]):\n original_bias_value = self.output_layer_biases[i]\n self.output_layer_biases[i] += delta\n plusdelta_cost = self.Cost(input_data, target_output_data)\n self.output_layer_biases[i] = original_bias_value\n self.output_biases_gradient[i] = (plusdelta_cost - normal_cost) / delta\n\n # Evaluate Gradient for Input Layer to Hidden Layer Weights\n for i in range(self.input_to_hidden_weights.shape[0]):\n for h in range(self.input_to_hidden_weights.shape[1]):\n original_bias_value = self.input_to_hidden_weights[i, h]\n self.input_to_hidden_weights[i, h] += delta\n plusdelta_cost = self.Cost(input_data, target_output_data)\n self.input_to_hidden_weights[i, h] = original_bias_value\n self.input_to_hidden_weights_gradient[i, h] = (plusdelta_cost - normal_cost) / delta\n\n # Evaluate Gradient for Input Layer to Hidden Layer Weights\n for h in range(self.hidden_to_output_weights.shape[0]):\n for o in range(self.hidden_to_output_weights.shape[1]):\n original_bias_value = self.hidden_to_output_weights[h, o]\n self.hidden_to_output_weights[h, o] += delta\n plusdelta_cost = self.Cost(input_data, target_output_data)\n self.hidden_to_output_weights[h, o] = original_bias_value\n self.hidden_to_output_weights_gradient[h, o] = (plusdelta_cost - normal_cost) / delta","def compute_loss(self):","def step(self):\n for p, grad, v, square_grad_avg, delta_x_acc in self.params:\n # Compute the running average of the squared gradients \n square_grad_avg.mul_(self.rho)\n square_grad_avg.addcmul_(grad, grad, value = 1 - self.rho)\n # Compute the RMS of the previous squared gradients (eps to avoid numerical issues later for division)\n std = (square_grad_avg.add_(self.eps)).sqrt_()\n # Compute the accumulated update\n delta_x = ((delta_x_acc.add_(self.eps)).sqrt_()) * grad / std\n # Accumulate the updates\n delta_x_acc.mul_(self.rho)\n delta_x_acc.addcmul_(delta_x, delta_x, value = 1 - self.rho) \n # Update the parameters\n p.add_(delta_x, alpha = - self.lr)","def update(self):\n\n # Update W (gradient should be up-to-date)\n _projected_step(self.W, self.gW, 1.0 / self.lipschitz_W())\n\n # Update H (need to recompute residuals since W was updated).\n self.cache_resids()\n self.cache_gH()\n _projected_step(self.H, self.gH, self.step_size)\n\n # Update residuals and gradient computation for W (for next iteration).\n self.cache_resids()\n self.cache_gW()\n\n # Return loss\n return self.loss","def _calc_gradients_chunked(self, batch_data, training_settings=None):\n\n if not is_chunkable(batch_data):\n raise BatchNotChunkableException()\n\n auxiliary_results = BatchChunkingResults()\n\n loss = 0\n # Will be set when we have the trainable variables\n accumulated_grads = None\n\n batch_size = len(batch_data)\n num_chunks = math.ceil(batch_size / self.batch_chunk_size)\n for chunk_idx in range(num_chunks):\n chunk_start = chunk_idx*self.batch_chunk_size\n chunk_end = min((chunk_idx+1)*self.batch_chunk_size, batch_size)\n\n chunk_len = chunk_end-chunk_start\n\n chunk = batch_data[chunk_start:chunk_end]\n\n with tf.GradientTape() as tape:\n results = self.evaluate_loss(chunk,\n inference_mode=False,\n evaluate_settings=training_settings)\n\n if 'loss' not in results:\n raise LossNotAvailableException()\n\n if self.trainable_variables is None:\n # We now have evaluated the model and the trainable variables should be available\n self._retrieve_trainable_variables()\n\n if accumulated_grads is None:\n if self.trainable_variables is None:\n raise MLPugException(\"Unexpected state : trainable variables not found. Please file an issue.\")\n\n accumulated_grads = {}\n for optimizer_name, tvs in self.trainable_variables.item():\n accumulated_grads[optimizer_name] = [tf.zeros_like(tv) for tv in tvs]\n\n loss = results['loss']\n aux_results = get_value_at('auxiliary_results', results, warn_on_failure=False)\n\n # loss is assumed to be the average over the sample loss for the chunk\n # Divide through batch size to factor in that this loss is part of a larger batch.\n last_chunk = chunk_idx == (num_chunks-1)\n chunk_loss = chunk_len*loss/batch_size\n chunk_gradients = self._back_propagate_from(chunk_loss, tape, last_chunk=last_chunk)\n\n loss += chunk_loss\n\n for optimizer_name, chunk_grads in chunk_gradients.items():\n accu_grads = accumulated_grads[optimizer_name]\n accumulated_grads[optimizer_name] = [(accu_grad+chunk_grad)\n for accu_grad, chunk_grad in zip(accu_grads, chunk_grads)]\n\n auxiliary_results += [{\n \"results\": aux_results,\n \"num_samples\": chunk_len\n }]\n\n return loss, auxiliary_results, accumulated_grads","def step(self, closure=None):\n self.steps += 1\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n k = group['k']\n alpha_k = group['alpha_k']\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data\n if grad.is_sparse:\n raise RuntimeError('RMSprop does not support sparse gradients')\n state = self.state[p]\n\n # State initialization\n if len(state) == 0:\n state['step'] = 0\n state['square_avg'] = torch.zeros_like(p.data)\n if group['momentum'] > 0:\n state['momentum_buffer'] = torch.zeros_like(p.data)\n if group['centered']:\n state['grad_avg'] = torch.zeros_like(p.data)\n\n square_avg = state['square_avg']\n alpha = group['alpha']\n\n state['step'] += 1\n\n if group['weight_decay'] != 0:\n grad = grad.add(group['weight_decay'], p.data)\n\n square_avg.mul_(alpha).addcmul_(1 - alpha, grad, grad)\n\n if group['centered']:\n grad_avg = state['grad_avg']\n grad_avg.mul_(alpha).add_(1 - alpha, grad)\n avg = square_avg.addcmul(-1, grad_avg, grad_avg).sqrt_().add_(group['eps'])\n else:\n avg = square_avg.sqrt().add_(group['eps'])\n\n if group['momentum'] > 0:\n buf = state['momentum_buffer']\n buf.mul_(group['momentum']).addcdiv_(grad, avg)\n p.data.add_(-group['lr'], buf)\n else:\n p.data.addcdiv_(-group['lr'], grad, avg)\n # ---- Lookahead Algorithm ----\n if 'slow_weight' not in state:\n state['slow_weight'] = p.data.clone().detach()\n if self.steps % k == 0:\n p.data = state['slow_weight'] + alpha_k * (p.data - state['slow_weight'])\n state['slow_weight'] = p.data.clone().detach()","def loss_and_grad(self, X, y):\n\n # Initialize the loss and gradient to zero.\n loss = 0.0\n grad = np.zeros_like(self.W)\n grad_tmp = np.zeros_like(self.W)\n num_classes = self.W.shape[0] # C = num_classes\n num_train = X.shape[0]\n \n # ================================================================ #\n # YOUR CODE HERE:\n # Calculate the softmax loss and the gradient. Store the gradient\n # as the variable grad.\n # ================================================================ #\n \n exp_a = np.zeros((num_classes,num_train))\n for i in np.arange(num_train):\n \n Loss = 0.0\n\n class_scores = np.dot(self.W,X[i,:].T) # calculating class scores (C x 1 vector)\n class_scores -= np.max(class_scores) # considering the possible issue for numerical instability and account for it\n\n exp_a[:,i] = np.exp(class_scores) # turning class scores to probabilities (C x 1 vector), without normalization\n\n Loss -= np.log(exp_a[y[i],i]/np.sum(exp_a[:,i]))\n \n \n #if i==0:\n grada = np.zeros(X.shape[1])\n \n for j in range(num_classes):\n if j != y[i]:\n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) \n else: \n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) - X[i,:].T \n\n grad += grad_tmp\n loss += Loss \n \n pass\n\n\n loss /= num_train\n grad /= num_train\n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n\n return loss, grad","def _gradient_descent(self, X, y, epochs, learning_rate, batch_size):\n num_feats = X.shape[1]\n num_samples = X.shape[0]\n\n y = y.reshape(num_samples, 1)\n W = np.random.rand(num_feats, 1)\n training_loss_epochs = []\n\n for ix in range(epochs):\n shuffled_ix = (np.arange(0, len(X)))\n np.random.shuffle(shuffled_ix)\n X = X[shuffled_ix, :]\n y = y[shuffled_ix, :]\n\n for batch_ix in np.arange(0, X.shape[0], batch_size):\n dW = self._compute_gradient(W, X[batch_ix:batch_ix + batch_size], y[batch_ix:batch_ix + batch_size])\n W -= learning_rate * dW\n\n if ix % 10 == 0:\n y_pred = np.dot(X, W)\n training_loss = self.mse(y, y_pred)\n print('epoch {0} : training loss {1}'.format(ix, training_loss))\n training_loss_epochs.append(training_loss[0])\n\n self.weights = W\n self.training_loss = training_loss_epochs\n return None","def step(self, closure=None):\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n\n for p in group['params']:\n if p.grad is None:\n grad = p.grad\n continue\n else:\n grad =p.grad\n\n # s = self.spikes.popitem()\n #grad = jnp.matmul(p.grad, s.data)\n\n\n state = self.state[p]\n\n # State initialization\n if len(state) == 0:\n state['step'] = 0\n # Exponential moving average of gradient values\n state['exp_avg'] = jnp.zeros(grad.shape)\n # Exponential moving average of squared gradient values\n state['exp_avg_sq'] = jnp.zeros(grad.shape)\n\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n beta1, beta2 = group['betas']\n\n state['step'] += 1\n\n if group['weight_decay'] != 0:\n grad += group['weight_decay'] * p.data\n\n # Decay the first and second moment running average coefficient\n exp_avg = exp_avg * beta1 + (1 - beta1) * grad\n exp_avg_sq = exp_avg_sq * beta2 + (1 - beta2) * grad * grad\n denom = jnp.sqrt(exp_avg_sq) + group['eps']\n\n bias_correction1 = 1 - beta1 ** state['step']\n bias_correction2 = 1 - beta2 ** state['step']\n step_size = group['lr'] * jmath.sqrt(bias_correction2) / bias_correction1\n\n p.data += -step_size * exp_avg / denom\n\n return loss","def gradient_descent(y, tx, initial_w, max_iters, gamma, compute_loss, compute_grad, verbose=False):\n \n w = initial_w.copy()\n loss = 0\n\n for n_iter in range(max_iters):\n grad = compute_grad(y, tx, w)\n loss = compute_loss(y, tx, w)\n\n w -= gamma * grad\n\n if verbose:\n print(f\"Gradient Descent ({n_iter}/{max_iters - 1}): loss={loss}, w={w}\")\n \n return w, loss","def step(self, closure=None):\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data\n if grad.dtype in {torch.float16, torch.bfloat16}:\n grad = grad.float()\n if grad.is_sparse:\n raise RuntimeError('Adafactor does not support sparse gradients.')\n\n state = self.state[p]\n grad_shape = grad.shape\n\n factored, use_first_moment = self._get_options(group, grad_shape)\n # State Initialization\n if len(state) == 0:\n state['step'] = 0\n\n if use_first_moment:\n # Exponential moving average of gradient values\n state['exp_avg'] = torch.zeros_like(grad)\n if factored:\n state['exp_avg_sq_row'] = torch.zeros(grad_shape[:-1]).to(grad)\n state['exp_avg_sq_col'] = torch.zeros(grad_shape[:-2] + grad_shape[-1:]).to(grad)\n else:\n state['exp_avg_sq'] = torch.zeros_like(grad)\n\n state['RMS'] = 0\n else:\n if use_first_moment:\n state['exp_avg'] = state['exp_avg'].to(grad)\n if factored:\n state['exp_avg_sq_row'] = state['exp_avg_sq_row'].to(grad)\n state['exp_avg_sq_col'] = state['exp_avg_sq_col'].to(grad)\n else:\n state['exp_avg_sq'] = state['exp_avg_sq'].to(grad)\n\n p_data_fp32 = p.data\n if p.data.dtype in {torch.float16, torch.bfloat16}:\n p_data_fp32 = p_data_fp32.float()\n\n state['step'] += 1\n state['RMS'] = self._rms(p_data_fp32)\n group['lr'] = self._get_lr(group, state)\n\n beta2t = 1.0 - math.pow(state['step'], group['decay_rate'])\n update = (grad**2) + group['eps'][0]\n if factored:\n exp_avg_sq_row = state['exp_avg_sq_row']\n exp_avg_sq_col = state['exp_avg_sq_col']\n\n exp_avg_sq_row.mul_(beta2t).add_(1.0 - beta2t, update.mean(dim=-1))\n exp_avg_sq_col.mul_(beta2t).add_(1.0 - beta2t, update.mean(dim=-2))\n\n # Approximation of exponential moving average of square of gradient\n update = self._approx_sq_grad(exp_avg_sq_row, exp_avg_sq_col)\n update.mul_(grad)\n else:\n exp_avg_sq = state['exp_avg_sq']\n\n exp_avg_sq.mul_(beta2t).add_(1.0 - beta2t, update)\n update = exp_avg_sq.rsqrt().mul_(grad)\n\n update.div_(\n (self._rms(update) / group['clip_threshold']).clamp_(min=1.0)\n )\n update.mul_(group['lr'])\n\n if use_first_moment:\n exp_avg = state['exp_avg']\n exp_avg.mul_(group['beta1']).add_(1 - group['beta1'], update)\n update = exp_avg\n\n if group['weight_decay'] != 0:\n p_data_fp32.add_(-group['weight_decay'] * group['lr'], p_data_fp32)\n\n p_data_fp32.add_(-update)\n\n if p.data.dtype in {torch.float16, torch.bfloat16}:\n p.data.copy_(p_data_fp32)\n\n return loss","def step(self, closure=None):\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data\n state = self.state[p]\n\n # State initialization\n if len(state) == 0:\n state['step'] = 0\n # Exponential moving average of gradient values\n state['exp_avg'] = grad.new().resize_as_(grad).zero_()\n # Exponential moving average of squared gradient values\n state['exp_avg_sq'] = grad.new().resize_as_(grad).zero_()\n\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n beta1, beta2 = group['betas']\n\n state['step'] += 1\n\n if group['l1_weight_decay'] != 0:\n grad = grad.add(group['l1_weight_decay'], torch.sign(p.data))\n if group['l2_weight_decay'] != 0:\n grad = grad.add(group['l2_weight_decay'], p.data)\n\n # Decay the first and second moment running average coefficient\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n\n denom = exp_avg_sq.sqrt().add_(group['eps'])\n\n bias_correction1 = 1 - beta1 ** state['step']\n bias_correction2 = 1 - beta2 ** state['step']\n step_size = group['lr'] * math.sqrt(bias_correction2) / bias_correction1\n\n p.data.addcdiv_(-step_size, exp_avg, denom)\n\n # custom clamping\n if group['lower_bound'] is not None:\n p.data.clamp_(min=group['lower_bound'])\n if group['upper_bound'] is not None:\n p.data.clamp_(max=group['upper_bound'])\n\n return loss","def gradient_descent(self, alpha, batch, weight_gradients, bias_gradients):\n self._dwg = [0] * 8\n self._dbg = [0] * 8\n self._cost = 0\n\n workers = []\n for i in range(batch[0].shape[0]-1):\n p = Process(target=self.mp_gd, args=(batch, weight_gradients, bias_gradients, i))\n workers.append(p)\n p.start()\n\n\n for p in workers:\n self._cost += self._q.get()\n\n self._dwg = list(map(add, self._dwg, self._dwgq.get()))\n self._dbg = list(map(add, self._dbg, self._dbgq.get()))\n\n p.join()\n\n for j in range(len(self._dwg)):\n weight_gradients[j] = weight_gradients[j] - alpha * self._dwg[j]\n bias_gradients[j] = bias_gradients[j] - alpha * self._dbg[j]\n cost = self._cost/len(batch)\n self._cost_history.append(cost)\n\n return weight_gradients, bias_gradients","def step(self, closure=None):\n self.steps += 1\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n k = group['k']\n alpha = group['alpha']\n for p in group['params']:\n if p.grad is None:\n continue\n\n # Perform stepweight decay\n p.data.mul_(1 - group['lr'] * group['weight_decay'])\n\n # Perform optimization step\n grad = p.grad.data\n if grad.is_sparse:\n raise RuntimeError('Adam does not support sparse gradients, please consider SparseAdam instead')\n amsgrad = group['amsgrad']\n\n state = self.state[p]\n\n # State initialization\n if len(state) == 0:\n state['step'] = 0\n # Exponential moving average of gradient values\n state['exp_avg'] = torch.zeros_like(p.data)\n # Exponential moving average of squared gradient values\n state['exp_avg_sq'] = torch.zeros_like(p.data)\n if amsgrad:\n # Maintains max of all exp. moving avg. of sq. grad. values\n state['max_exp_avg_sq'] = torch.zeros_like(p.data)\n\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n if amsgrad:\n max_exp_avg_sq = state['max_exp_avg_sq']\n beta1, beta2 = group['betas']\n\n state['step'] += 1\n bias_correction1 = 1 - beta1 ** state['step']\n bias_correction2 = 1 - beta2 ** state['step']\n\n # Decay the first and second moment running average coefficient\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n if amsgrad:\n # Maintains the maximum of all 2nd moment running avg. till now\n torch.max(max_exp_avg_sq, exp_avg_sq, out=max_exp_avg_sq)\n # Use the max. for normalizing running avg. of gradient\n denom = (max_exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps'])\n else:\n denom = (exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps'])\n\n step_size = group['lr'] / bias_correction1\n\n p.data.addcdiv_(-step_size, exp_avg, denom)\n # ---- Lookahead Algorithm ----\n if 'slow_weight' not in state:\n state['slow_weight'] = p.data.clone().detach()\n if self.steps % k == 0:\n p.data = state['slow_weight'] + alpha * (p.data - state['slow_weight'])\n state['slow_weight'] = p.data.clone().detach()\n state['exp_avg'].fill_(0)\n state['exp_avg_sq'].fill_(0)\n\n return loss","def train(self, inputs, targets, eta, niterations):\n ndata = np.shape(inputs)[0] # number of data samples\n # adding the bias\n inputs = np.concatenate((inputs, -np.ones((ndata, 1))), axis=1)\n\n # numpy array to store the update weights\n updatew1 = np.zeros((np.shape(self.weights1)))\n updatew2 = np.zeros((np.shape(self.weights2)))\n updatew3 = np.zeros((np.shape(self.weights3)))\n\n self.Errors = []\n for n in range(niterations):\n\n #############################################################################\n # TODO: implement the training phase of one iteration which consists of two phases:\n # the forward phase and the backward phase. you will implement the forward phase in \n # the self.forwardPass method and return the outputs to self.outputs. Then compute \n # the error (hints: similar to what we did in the lab). Next is to implement the \n # backward phase where you will compute the derivative of the layers and update \n # their weights. \n #############################################################################\n\n # forward phase \n self.outputs = self.forwardPass(inputs)\n\n # Error using the sum-of-squares error function\n error = 0.5 * np.sum((self.outputs - targets) ** 2)\n\n if np.mod(n, 100) == 0:\n self.Errors.append(error)\n print(\"Iteration: \", n, \" Error: \", error)\n\n # backward phase \n # Compute the derivative of the output layer. NOTE: you will need to compute the derivative of \n # the softmax function. Hints: equation 4.55 in the book. \n # deltao = (self.outputs - targets) * (self.outputs - self.outputs ** 2)\n deltao = (self.outputs - targets) * self.outputs * (1 - self.outputs)\n\n # compute the derivative of the second hidden layer\n\n deltah2 = self.beta * self.hidden2 * (1.0 - self.hidden2) * (np.dot(deltao, np.transpose(self.weights3)))\n\n\n # compute the derivative of the first hidden layer\n deltah1 = self.beta * self.hidden1 * (1.0 - self.hidden1) * (np.dot(deltah2[:, :-1], np.transpose(self.weights2)))\n\n # update the weights of the three layers: self.weights1, self.weights2 and self.weights3\n # here you can update the weights as we did in the week 4 lab (using gradient descent) \n # but you can also add the momentum\n\n updatew1 = eta * np.dot(np.transpose(inputs), deltah1[:, :-1]) + self.momentum * updatew1\n updatew2 = eta * np.dot(np.transpose(self.hidden1), deltah2[:, :-1]) + self.momentum * updatew2\n updatew3 = eta * np.dot(np.transpose(self.hidden2), deltao) + self.momentum * updatew3\n\n self.weights1 -= updatew1\n self.weights2 -= updatew2\n self.weights3 -= updatew3\n\n #############################################################################\n # END of YOUR CODE \n #############################################################################","def step(self, closure=None):\n loss = None\n if closure is not None:\n loss = closure()\n for group in self.param_groups:\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data\n if grad.is_sparse:\n raise RuntimeError('Adam does not support sparse gradients, please consider SparseAdam instead')\n\n state = self.state[p]\n\n # State initialization\n if len(state) == 0:\n state['step'] = 0\n # Exponential moving average of gradient values\n state['next_m'] = torch.zeros_like(p.data)\n # Exponential moving average of squared gradient values\n state['next_v'] = torch.zeros_like(p.data)\n\n next_m, next_v = state['next_m'], state['next_v']\n beta1, beta2 = group['b1'], group['b2']\n\n # Add grad clipping\n if group['max_grad_norm'] > 0:\n clip_grad_norm_(p, group['max_grad_norm'])\n\n # Decay the first and second moment running average coefficient\n # In-place operations to update the averages at the same time\n next_m.mul_(beta1).add_(1 - beta1, grad)\n next_v.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n update = next_m / (next_v.sqrt() + group['e'])\n\n # Just adding the square of the weights to the loss function is *not*\n # the correct way of using L2 regularization/weight decay with Adam,\n # since that will interact with the m and v parameters in strange ways.\n #\n # Instead we want to decay the weights in a manner that doesn't interact\n # with the m/v parameters. This is equivalent to adding the square\n # of the weights to the loss with plain (non-momentum) SGD.\n if group['weight_decay'] > 0.0:\n update += group['weight_decay'] * p.data\n\n if group['t_total'] != -1:\n schedule_fct = SCHEDULES[group['schedule']]\n lr_scheduled = group['lr'] * schedule_fct(state['step']/group['t_total'], group['warmup'])\n else:\n lr_scheduled = group['lr']\n\n update_with_lr = lr_scheduled * update\n p.data.add_(-update_with_lr)\n\n state['step'] += 1\n\n return loss","def compute_gradients(self, *args, **kwargs):\n gradients = self._optimizer.compute_gradients(*args, **kwargs)\n if size() > 1 and not self._enable_async:\n grads, vars = zip(*gradients)\n avg_grads = self._push_pull_grads(grads)\n return list(zip(avg_grads, vars))\n else:\n return gradients","def backpropagate(self, error, learning_rate):\n #assert isinstance(error, np.ndarray)\n #assert isinstance(self._prev_layer._outputs, np.ndarray)\n #assert isinstance(self._outputs, np.ndarray) \n\n # Compute deltas. \n deltas = np.dot(error, self._activation_function.derivative_given_y(self._outputs))\n \n # Compute gradient.\n synapse = np.dot(np.dot(error, self._prev_layer._outputs), learning_rate)\n \n # Adjust weights.\n self._weights = np.add(self._weights, synapse)\n \n # Adjust bias weights.\n if self._use_bias:\n self._bias = np.add(self._bias, synapse)\n \n return deltas","def batchGD(self, x, y, epochs):\n print(\"Training using batch gradient descent\")\n epoch = 0\n #output training progress ten times in run\n outputChunk = int ( epochs / 10 )\n\n while epoch <= epochs:\n\n #output progress? \n if epoch % outputChunk is 0:\n J = self.costFunction(x,y)\n print(\"Epoch=\", epoch, \"J=\", J)\n\n #get analytic gradients \n partial_J_w_ih, partial_J_w_ho, partial_J_b_h, partial_J_b_o = \\\n self.deriv_costFunction( x, y )\n #take a GD step\n #To-do - implement variable learning rate\n self.w_ih -= partial_J_w_ih\n self.w_ho -= partial_J_w_ho\n self.b_h -= partial_J_b_h\n self.b_o -= partial_J_b_o\n \n epoch += 1","def epoch_iter(model, data, optimizer, epoch):\n total_bpd = 0.0\n for i, (inputs, _targets) in enumerate(data):\n log_px = model.forward(inputs)\n loss = -log_px.mean()\n\n if model.training:\n # update gradients\n model.zero_grad()\n loss.backward()\n optimizer.step()\n\n # per dimension\n bpd = loss.item() / (x_dim * np.log(2))\n print({'epoch': epoch, 'i':i, 'loss':loss.item(), 'bpd':bpd})\n total_bpd += bpd\n\n avg_bpd = total_bpd / len(data)\n return avg_bpd","def step(self, closure=None):\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data\n if grad.is_sparse:\n raise RuntimeError('NAdam does not support sparse gradients')\n\n state = self.state[p]\n\n # State initialization\n if len(state) == 0:\n state['step'] = 0\n # Exponential moving average of gradient values\n state['exp_avg'] = torch.zeros_like(p.data)\n # Exponential moving average of squared gradient values\n state['exp_avg_sq'] = torch.zeros_like(p.data)\n # \\mu^{t}\n state['m_schedule'] = 1.\n\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n\n beta1, beta2 = group['betas']\n\n schedule_decay = group['schedule_decay']\n\n state['step'] += 1\n\n if group['weight_decay'] != 0:\n grad = grad.add(group['weight_decay'], p.data)\n\n # calculate the momentum cache \\mu^{t} and \\mu^{t+1}\n momentum_cache_t = beta1 * (\n 1. - 0.5 * (pow(0.96, state['step'] * schedule_decay)))\n momentum_cache_t_1 = beta1 * (\n 1. - 0.5 * (pow(0.96, (state['step'] + 1) * schedule_decay)))\n m_schedule_new = state['m_schedule'] * momentum_cache_t\n m_schedule_next = state['m_schedule'] * momentum_cache_t * momentum_cache_t_1\n\n # Decay the first and second moment running average coefficient\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n\n g_prime = torch.div(grad, 1. - m_schedule_new)\n exp_avg_prime = torch.div(exp_avg, 1. - m_schedule_next)\n exp_avg_sq_prime = torch.div(exp_avg_sq, 1. - pow(beta2, state['step']))\n\n exp_avg_bar = torch.add((1. - momentum_cache_t) * g_prime,\n momentum_cache_t_1, exp_avg_prime)\n\n denom = exp_avg_sq_prime.sqrt().add_(group['eps'])\n\n step_size = group['lr']\n\n p.data.addcdiv_(-step_size, exp_avg_bar, denom)\n\n return loss","def gradients(self):\n error = self.error()\n input_ = self.get_cache('input')\n error_stacked = np.reshape(error, (error.shape[0], 1, error.shape[1]))\n input_stacked = np.reshape(input_, (input_.shape[0], input_.shape[1], 1))\n return {\n 'bias': np.sum(error, axis=0),\n 'weight': np.sum(np.matmul(input_stacked, error_stacked), axis=0)\n }","def step(self, closure=None):\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data\n if grad.is_sparse:\n raise RuntimeError('Adam does not support sparse gradients, please consider SparseAdam instead')\n amsgrad = group['amsgrad']\n\n state = self.state[p]\n\n # State initialization\n if len(state) == 0:\n state['step'] = 0\n # Exponential moving average of gradient values\n state['exp_avg'] = torch.zeros_like(p.data)\n # Exponential moving average of squared gradient values\n state['exp_avg_sq'] = torch.zeros_like(p.data)\n if amsgrad:\n # Maintains max of all exp. moving avg. of sq. grad. values\n state['max_exp_avg_sq'] = torch.zeros_like(p.data)\n\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n if amsgrad:\n max_exp_avg_sq = state['max_exp_avg_sq']\n beta1, beta2 = group['betas']\n\n state['step'] += 1\n\n if group['weight_decay'] != 0:\n grad.add_(group['weight_decay'], p.data)\n\n # Decay the first and second moment running average coefficient\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n if amsgrad:\n # Maintains the maximum of all 2nd moment running avg. till now\n torch.max(max_exp_avg_sq, exp_avg_sq, out=max_exp_avg_sq)\n # Use the max. for normalizing running avg. of gradient\n denom = max_exp_avg_sq.sqrt().add_(group['eps'])\n else:\n denom = exp_avg_sq.sqrt().add_(group['eps'])\n\n bias_correction1 = 1 - beta1 ** state['step']\n bias_correction2 = 1 - beta2 ** state['step']\n step_size = -group['lr'] * math.sqrt(bias_correction2) / bias_correction1 * exp_avg / denom\n\n if group[\"hyperboloid\"]:\n self.expm(p.data, step_size)\n else:\n p.data.add_(step_size)\n\n return loss","def step(self, closure=None):\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data\n if grad.is_sparse:\n raise RuntimeError('Adam does not support sparse gradients, please consider SparseAdam instead')\n\n state = self.state[p]\n\n # State initialization\n if len(state) == 0:\n state['step'] = 0\n # Exponential moving average of gradient values\n state['next_m'] = torch.zeros_like(p.data)\n # Exponential moving average of squared gradient values\n state['next_v'] = torch.zeros_like(p.data)\n\n next_m, next_v = state['next_m'], state['next_v']\n beta1, beta2 = group['b1'], group['b2']\n\n # Add grad clipping\n if group['max_grad_norm'] > 0:\n clip_grad_norm_(p, group['max_grad_norm'])\n\n # Decay the first and second moment running average coefficient\n # In-place operations to update the averages at the same time\n next_m.mul_(beta1).add_(1 - beta1, grad)\n next_v.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n update = next_m / (next_v.sqrt() + group['e'])\n\n # Just adding the square of the weights to the loss function is *not*\n # the correct way of using L2 regularization/weight decay with Adam,\n # since that will interact with the m and v parameters in strange ways.\n #\n # Instead we want to decay the weights in a manner that doesn't interact\n # with the m/v parameters. This is equivalent to adding the square\n # of the weights to the loss with plain (non-momentum) SGD.\n if group['weight_decay'] > 0.0:\n update += group['weight_decay'] * p.data\n\n if group['t_total'] != -1:\n schedule_fct = SCHEDULES[group['schedule']]\n lr_scheduled = group['lr'] * schedule_fct(state['step']/group['t_total'], group['warmup'])\n else:\n lr_scheduled = group['lr']\n\n update_with_lr = lr_scheduled * update\n p.data.add_(-update_with_lr)\n\n state['step'] += 1\n\n # step_size = lr_scheduled * math.sqrt(bias_correction2) / bias_correction1\n # No bias correction\n # bias_correction1 = 1 - beta1 ** state['step']\n # bias_correction2 = 1 - beta2 ** state['step']\n\n return loss","def train_one_iteration(sess, model, tr_num_batch, iteration):\n counter = 0\n duration = 0.0\n tr_g_mse_loss = 0.0\n tr_g_l2_loss = 0.0\n tr_g_loss = 0.0\n for batch in range(int(tr_num_batch/FLAGS.num_gpu)):\n _g_opt, \\\n g_mse_losses, g_l2_losses, \\\n g_losses = sess.run([model.g_opt,\n model.g_mse_losses,\n model.g_l2_losses,\n model.g_losses])\n g_mse_loss = np.mean(g_mse_losses)\n g_l2_loss = np.mean(g_l2_losses)\n g_loss = np.mean(g_losses)\n if model.g_disturb_weights:\n sess.run(model.g_disturb)\n counter += FLAGS.num_gpu\n tr_g_mse_loss += g_mse_loss\n tr_g_l2_loss += g_l2_loss\n tr_g_loss += g_loss\n\n _summaries = sess.run(model.summaries)\n model.writer.add_summary(_summaries, iteration * tr_num_batch)\n\n tr_g_mse_loss = tr_g_mse_loss / counter * FLAGS.num_gpu\n tr_g_l2_loss = tr_g_l2_loss / counter * FLAGS.num_gpu\n tr_g_loss = tr_g_loss / counter * FLAGS.num_gpu\n\n return tr_g_mse_loss, tr_g_l2_loss, tr_g_loss","def step(self, batch_id, closure):\n loss = closure()\n dist_sq_acum = 0.0\n grad_dist_sq_acum = 0.0\n\n #print(\"step loss: \", loss)\n\n for group in self.param_groups:\n momentum = group['momentum']\n weight_decay = group['weight_decay']\n learning_rate = group['lr']\n\n for p in group['params']:\n if p.grad is None:\n continue\n gk = p.grad.data\n\n param_state = self.state[p]\n\n gktbl = param_state['gktbl']\n gavg = param_state['gavg'].type_as(p.data)\n tilde_x = param_state['tilde_x']\n\n if momentum != 0:\n buf = param_state['momentum_buffer']\n\n #########\n\n if self.vr_from_epoch is None or self.epoch < self.vr_from_epoch:\n vr_gradient = gk.clone() # Just do sgd steps\n else:\n gi = gktbl[batch_id, :].cuda()\n\n vr_gradient = gk.clone().sub_(gi - gavg)\n\n # Some diagnostics\n iterate_diff = p.data - tilde_x\n #pdb.set_trace()\n dist_sq_acum += iterate_diff.norm()**2 #torch.dot(iterate_diff,iterate_diff)\n grad_diff = gi - gk\n grad_dist_sq_acum += grad_diff.norm()**2 #torch.dot(grad_diff,grad_diff)\n\n if weight_decay != 0:\n vr_gradient.add_(weight_decay, p.data)\n\n if momentum != 0:\n dampening = 0.0\n vr_gradient = buf.mul_(momentum).add_(1 - dampening, vr_gradient)\n\n # Take step.\n p.data.add_(-learning_rate, vr_gradient)\n\n # Update running iterate mean:\n param_state['running_x'].mul_(self.running_interp).add_(1-self.running_interp, p.data)\n\n # track number of minibatches seen\n self.batches_processed += 1\n\n dist = math.sqrt(dist_sq_acum)\n grad_dist = math.sqrt(grad_dist_sq_acum)\n\n self.inrun_iterate_distances.append(dist)\n self.inrun_grad_distances.append(grad_dist)\n\n return loss","def build_loss(self):\n import tensorflow as tf\n\n y_1d = [tf.reduce_sum(tf.multiply(self.variables[\"y\"][i], self.variables[\"y_action\"][i]), axis=1) for i in range(len(self.variables[\"y\"]))]\n loss = np.sum([tf.nn.l2_loss(y_1d[i] - self.variables[\"y_true\"]) for i in range(len(y_1d))])\n\n l1_reg = 0\n l2_reg = 0\n\n keys = sorted(self.variables.keys())\n keys = [key for key in keys if critere_keys(key) and \"W\" in key]\n for key in keys:\n l1_reg += tf.reduce_sum(tf.abs(self.variables[key]))\n l2_reg += tf.nn.l2_loss(self.variables[key])\n\n self.loss = loss + self.alpha_reg * l1_reg + self.beta_reg * l2_reg\n\n self.train_step = tf.train.RMSPropOptimizer(self.decay_learning_rate,\n decay=0.99, momentum=0., centered=True).minimize(self.loss, global_step=self.global_step)","def gradient_descent(self, x, y):\n # Initialize weights vector\n self.weights = np.zeros(len(x[0]))\n\n # Storing number of training example in a variable \n n = len(x)\n\n # Initiate variables to keep track of the current and smallest loss recorded\n lowest_loss = sys.float_info.max\n current_loss = sys.float_info.max\n\n # Initiate variables to keep track of step sizes\n norm = sys.float_info.max\n smallest_norm = sys.float_info.max\n\n # Initiate list variable that stores all previous weights\n prev_weights = []\n\n # Initiate list that stores all the errors. \n errors = []\n \n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\n k_loss_iteration = 1\n\n # Learning loop\n for i in range(self.max_iter):\n\n # Append current weights\n prev_weights.append(np.array(self.weights))\n \n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\n\n # Compute the error of the Cost Function and store it in a list\n current_loss = self.cost(x,y)\n\n if len(errors) > 1 and current_loss > errors[-1]:\n k_loss_iteration += 1\n else: \n k_loss_iteration = 1\n\n errors.append(current_loss)\n \n # Track smallest loss\n if current_loss < lowest_loss:\n lowest_loss = current_loss\n\n # Compute the L2 Norm of the difference between current weights and previous weights\n norm = np.linalg.norm(self.weights - prev_weights[-1])\n\n # Track smallest step size and set it as error threshold\n if norm < smallest_norm:\n smallest_norm = norm\n\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\n if self.error_threshold != None and norm < self.error_threshold:\n print(\"Converged after {} iterations!\".format(i))\n break\n\n # stop if error hasn't gone down in k iterations\n if k_loss_iteration >= 10:\n print(k_loss_iteration + \" iterations of loss not decreasing on {}th itertion.\".format(i))\n break\n\n # Log final weights\n print(\"Final norm: \" + str(norm) + \"\\nSmallest step size recorded: \" + str(smallest_norm) + \"\\nFinal error: \" + str(current_loss) + \"\\nLowest error recorded: \" + str(lowest_loss) + \"\\nNumber of epochs: \" + str(len(errors)) + \"\\nFinal weights: \" + str(self.weights))","def step(self, closure: Optional[Callable[[], float]] = None):\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data\n if grad.is_sparse:\n raise RuntimeError(\n \"Adam does not support sparse gradients, please \"\n \"consider SparseAdam instead\")\n\n state = self.state[p]\n # State initialization\n if len(state) == 0:\n # Exponential moving average of gradient values\n state['next_m'] = torch.zeros_like(p.data)\n # Exponential moving average of squared gradient values\n state['next_v'] = torch.zeros_like(p.data)\n\n next_m, next_v = state['next_m'], state['next_v']\n beta1, beta2 = group['betas']\n\n # Add grad clipping\n if group['max_grad_norm'] > 0:\n clip_grad_norm_(p, group['max_grad_norm'])\n\n # Decay the first and second moment running average coefficient\n # In-place operations to update the averages at the same time\n next_m.mul_(beta1).add_(1 - beta1, grad)\n next_v.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n update = next_m / (next_v.sqrt() + group['eps'])\n\n # Just adding the square of the weights to the loss function is\n # *not* # the correct way of using L2 regularization or weight\n # decay with Adam, since that will interact with the m and v\n # parameters in strange ways.\n #\n # Instead we want to decay the weights in a manner that doesn't\n # interact with the m/v parameters. This is equivalent to adding\n # the square of the weights to the loss with plain\n # (non-momentum) SGD.\n if group['weight_decay'] > 0.0:\n update += group['weight_decay'] * p.data\n\n lr = group['lr']\n update_with_lr = lr * update\n p.data.add_(-update_with_lr)\n\n # No bias correction\n # bias_correction1 = 1 - beta1 ** state['step']\n # bias_correction2 = 1 - beta2 ** state['step']\n\n return loss","def _train(self, loss):\n config = ConfigParser.ConfigParser()\n config.read(\"config/conf.cfg\")\n\n learning_rate =float(config.get(\"Common Params\", \"learning_rate\"))\n moment = float(config.get(\"Common Params\", \"moment\"))\n opt = tf.train.AdamOptimizer()\n train_step = opt.minimize(loss)\n return train_step\n\n # grads = opt.compute_gradients(self.total_loss)\n\n # apply_gradient_op = opt.apply_gradients(grads, global_step=self.global_step)\n\n #return apply_gradient_op","def run_gradient_descent(data,theta,alpha,num_iters):\n population = data[:,0]\n prices = data[:,1]\n x = ones(shape=(len(population),2)) #add ones for theta0 \n x[:,1] = population\n x = transpose(x)\n error_history = zeros(shape=(num_iters,1))\n \n for i in range(num_iters):\n predictions = theta.dot(x)\n errors_x1 = (predictions - prices) * x[0,:]\n errors_x2 = (predictions - prices) * x[1,:]\n theta[0][0] = theta[0][0] - alpha*(1.0/len(population))*errors_x1.sum()\n theta[0][1] = theta[0][1] - alpha*(1.0/len(population))*errors_x2.sum()\n error_history[i,0] = calculate_cost(theta,data)\n \n return theta, error_history","def optimize(self,gradients):\n\n for k in range(self.size):\n delta_weight = self.learningRate * gradients[k]\n full_change = delta_weight + self.momentum*self.last_change[k]\n self.weights[k] -= full_change\n self.last_change[k] = 1*gradients[k] #copy gradient mat","def step(self, closure=None):\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data\n if grad.is_sparse:\n raise RuntimeError('Adam does not support sparse gradients, please consider SparseAdam instead')\n amsgrad = group['amsgrad']\n\n # state = self.state[p]\n\n # # State initialization\n # if len(state) == 0:\n # state['step'] = 0\n # # Exponential moving average of gradient values\n # state['exp_avg'] = torch.zeros_like(p.data)\n # # Exponential moving average of squared gradient values\n # state['exp_avg_sq'] = torch.zeros_like(p.data)\n # if amsgrad:\n # # Maintains max of all exp. moving avg. of sq. grad. values\n # state['max_exp_avg_sq'] = torch.zeros_like(p.data)\n\n # exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n # if amsgrad:\n # max_exp_avg_sq = state['max_exp_avg_sq']\n # beta1, beta2 = group['betas']\n\n # state['step'] += 1\n # bias_correction1 = 1 - beta1 ** state['step']\n # bias_correction2 = 1 - beta2 ** state['step']\n\n # if group['weight_decay'] != 0:\n # grad.add_(group['weight_decay'], p.data)\n\n # # Decay the first and second moment running average coefficient\n # exp_avg.mul_(beta1).add_(1 - beta1, grad)\n # exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n # if amsgrad:\n # # Maintains the maximum of all 2nd moment running avg. till now\n # torch.max(max_exp_avg_sq, exp_avg_sq, out=max_exp_avg_sq)\n # # Use the max. for normalizing running avg. of gradient\n # denom = (max_exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps'])\n # else:\n # denom = (exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps'])\n\n # step_size = group['lr'] / bias_correction1\n\n # p.data.addcdiv_(-step_size, exp_avg, denom)\n\n return loss","def training_iteration(self, num_epochs):\n # Initialize metrics container\n metrics = {'train_loss': [],\n 'train_accuracy': [],\n 'val_loss': [],\n 'val_accuracy': []}\n\n # Create pytorch's train data_loader\n train_loader = self.dm.get_train_set()\n # train num_epochs times\n for epoch in range(num_epochs):\n print(\"Epoch: {} of {}\".format(epoch + 1, num_epochs))\n train_loss = 0.0\n\n with tqdm(range(len(train_loader))) as t:\n train_losses = []\n train_accuracies = []\n for i, data in enumerate(train_loader, 0):\n # transfer tensors to selected device\n train_inputs, _ = data[0].to(self.device), data[1].to(self.device)\n\n # zero the parameter gradients\n self.optimizer.zero_grad()\n\n # forward pass\n code, x_hat, cosim, z_error, gamma = self.model(train_inputs)\n phi, mu, cov_mat = self.model.compute_params(z_error, gamma)\n energy_result, pen_cov_mat = self.model.estimate_sample_energy(z_error, phi, mu, cov_mat,\n device=self.device)\n\n loss = self.model.compute_loss(train_inputs, x_hat, energy_result, pen_cov_mat)\n\n # # Use autograd to compute the backward pass.\n loss.backward()\n\n # updates the weights using gradient descent\n self.optimizer.step()\n\n # Save losses for plotting purposes\n train_losses.append(loss.item())\n # train_accuracies.append(accuracy(train_outputs, train_labels))\n\n # print metrics along progress bar\n train_loss += loss.item()\n t.set_postfix(loss='{:05.3f}'.format(train_loss / (i + 1)))\n t.update()\n\n # evaluate the model on validation data after each epoch\n mean_train_loss = np.mean(train_losses)\n metrics['train_loss'].append(mean_train_loss)\n # TODO\n # Add other metrics to plot\n\n return metrics","def epoch_diagnostics(self, train_loss, train_err, test_loss, test_err):\n m = self.nbatches\n logging.info(\"Epoch diagnostics computation\")\n\n layernum = 0\n layer_gradient_norm_sqs = []\n gavg_norm_acum = 0.0\n gavg_acum = []\n for group in self.param_groups:\n for p in group['params']:\n\n layer_gradient_norm_sqs.append([])\n gavg = self.state[p]['gavg'].cpu()\n gavg_acum.append(gavg.numpy())\n gavg_norm_acum += gavg.norm()**2 #torch.dot(gavg, gavg)\n layernum += 1\n\n gradient_norm_sqs = []\n vr_step_variance = []\n cos_acums = []\n variances = []\n\n for batch_id in range(m):\n norm_acum = 0.0\n ginorm_acum = 0.0\n vr_acum = 0.0\n layernum = 0\n cos_acum = 0.0\n var_acum = 0.0\n for group in self.param_groups:\n for p in group['params']:\n param_state = self.state[p]\n\n gktbl = param_state['gktbl']\n gavg = param_state['gavg'].type_as(p.data).cpu()\n\n gi = gktbl[batch_id, :]\n var_norm_sq = (gi-gavg).norm()**2 #torch.dot(gi-gavg, gi-gavg)\n norm_acum += var_norm_sq\n ginorm_acum += gi.norm()**2 #torch.dot(gi, gi)\n layer_gradient_norm_sqs[layernum].append(var_norm_sq)\n\n gktbl_old = param_state['gktbl_old']\n gavg_old = param_state['gavg_old'].type_as(p.data).cpu()\n gi_old = gktbl_old[batch_id, :]\n #pdb.set_trace()\n vr_step = gi - gi_old + gavg_old\n vr_acum += (vr_step - gavg).norm()**2 #torch.dot(vr_step - gavg, vr_step - gavg)\n cos_acum += torch.sum(gavg*gi)\n\n var_acum += (gi - gavg).norm()**2\n\n layernum += 1\n gradient_norm_sqs.append(norm_acum)\n vr_step_variance.append(vr_acum)\n cosim = cos_acum/math.sqrt(ginorm_acum*gavg_norm_acum)\n #pdb.set_trace()\n cos_acums.append(cosim)\n variances.append(var_acum)\n\n variance = sum(variances)/len(variances)\n\n print(\"mean cosine: {}\".format(sum(cos_acums)/len(cos_acums)))\n\n #pdb.set_trace()\n\n with open('stats/{}fastdiagnostics_epoch{}.pkl'.format(self.test_name, self.epoch), 'wb') as output:\n pickle.dump({\n 'train_loss': train_loss,\n 'train_err': train_err,\n 'test_loss': test_loss,\n 'test_err': test_err,\n 'epoch': self.epoch,\n #'layer_gradient_norm_sqs': layer_gradient_norm_sqs,\n #'gradient_norm_sqs': gradient_norm_sqs,\n #'vr_step_variance': vr_step_variance,\n #'cosine_distances': cos_acums,\n #'variances': variances,\n 'variance': variance,\n #'gavg_norm': gavg_norm_acum,\n #'gavg': gavg_acum,\n #'iterate_distances': self.inrun_iterate_distances,\n #'grad_distances': self.inrun_grad_distances,\n }, output)\n print(\"Epoch diagnostics saved\")\n #pdb.set_trace()\n\n self.inrun_iterate_distances = []\n self.inrun_grad_distances = []","def _compute_func_grad(self, w):\n W = w.reshape((self.X.shape[1], self.Y.shape[1]))\n self.nll_, self.grad_ = calculate_gradient(self.X, self.Y, W, self.prior, self.weighted,0)","def train(model, train_iter, dev_iter):\n \n optim = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)\n\n loss = []\n\n for eidx in range(1, NUM_EPOCHS + 1):\n model.train()\n\n epoch_loss = 0\n epoch_items = 0\n # Start training\n for batch_idx, batch in enumerate(train_iter):\n\n # Clear the gradients\n optim.zero_grad()\n en, de = prepare_batch_strategy_3(batch)\n # loss will be a vector of size (batch_size, ) with losses per every sample\n y_pred = model.forward(en.float(), de.float()).view(-1)\n loss = F.mse_loss(y_pred.double(), batch.score.double(), reduction='none')\n \n # Backprop the average loss and update parameters\n loss.sum().backward()\n optim.step()\n\n # sum the loss for reporting, along with the denominator\n epoch_loss += loss.detach().sum()\n epoch_items += loss.numel()\n\n if batch_idx % 10 == 0:\n # Print progress\n loss_per_token = epoch_loss / epoch_items\n print('[Epoch {:<3}] loss: {:6.2f}'.format(eidx, loss_per_token))\n\n\n print('\\n[Epoch {:<3}] ended with train_loss: {:6.2f}'.format(eidx, loss_per_token))\n \n # Evaluate on valid set\n model.eval()\n check_pearson_value(model, dev_iter)\n torch.save(model, './models/model_strategy_3_epoch_{}'.format(eidx))","def gradient_descent(x_data, starting_b, starting_w, learning_rate, num_iterations):\n\n b = starting_b\n w = starting_w\n\n for i in range(num_iterations):\n b, w = step_gradient(b, w, x_data, learning_rate)\n b_history.append(b) # stores bias approximations to plot\n w_history.append(w) # stores weight approximations to plot\n err = error(b, w, x_data)\n if err <= .6: # if the error is acceptable exit iterations loop\n print('error = % f' % err)\n break\n return [b, w]","def compute_gradients(self, loss, params):\n # check asserts\n assert isinstance(params, list), '\"params\" should be a list type.'\n \n # compute gradients\n grads = T.grad(loss, params)\n if self.clipnorm is not None:\n grad_l2norm = T.sqrt(sum([T.sum(T.square(gg)) for gg in grads]))\n grads = [T.switch(grad_l2norm > self.clipnorm, g * self.clipnorm / (grad_l2norm + 1e-7), g) for g in grads]\n if self.clipvalue is not None:\n grads = [T.clip(g, -self.clipvalue, self.clipvalue) for g in grads]\n return grads","def loss(self, X_batch, y_batch, learning_rate=1e-3, one_vs_all_index=-1, reg=True):\n #########################################################################\n # TODO: #\n # calculate the loss and the derivative #\n #########################################################################\n loss = 0\n for i in range(X_batch.shape[0]):\n if one_vs_all_index == -1:\n loss += -(y_batch[i] * (np.dot(self.w.T, X_batch[i]))) + np.log(\n 1 + np.exp(np.dot(self.w.T, X_batch[i])))\n else:\n if reg:\n reg = (learning_rate / 2 * X_batch.shape[0]) * np.sum(np.power(self.ws[one_vs_all_index], 2))\n loss += -(y_batch[i] * (np.dot(self.ws[one_vs_all_index].T, X_batch[i]))) + np.log(\n 1 + np.exp(np.dot(self.ws[one_vs_all_index].T, X_batch[i]))) + reg\n else:\n loss += -(y_batch[i] * (np.dot(self.ws[one_vs_all_index].T, X_batch[i]))) + np.log(\n 1 + np.exp(np.dot(self.ws[one_vs_all_index].T, X_batch[i])))\n gradients = np.zeros(X_batch.shape[1])\n if one_vs_all_index == -1:\n dot = np.dot(X_batch, self.w)\n else:\n dot = np.dot(X_batch, self.ws[one_vs_all_index])\n logists = sigmod(dot)\n diff = y_batch - logists\n for index in range(X_batch.shape[0]):\n if one_vs_all_index != -1:\n if reg:\n dot = np.dot(X_batch[index], diff[index])\n gradients[1:] += dot[1:] + (learning_rate / X_batch.shape[0]) * self.ws[one_vs_all_index][1:]\n gradients[0] += dot[0]\n else:\n gradients += np.dot(X_batch[index], diff[index])\n else:\n gradients += np.dot(X_batch[index], diff[index])\n\n return loss, gradients / X_batch.shape[0] # 取均值免得步长过大直接nan\n #########################################################################\n # END OF YOUR CODE #\n #########################################################################","def backpropagation(self):\n\n print \"backpropagation in Convlayer\"\n\n if self.__nextLayer.__class__.__name__ is 'FCLayer':\n WF = self.__nextLayer.numberOfNeuronsInLayer\n dNext = np.reshape(self.__nextLayer.getDeltas(), (1, 1, 1, WF))\n else:\n dNext = self.__nextLayer.getDeltas()\n\n self.deltas = np.zeros(self.outputValues.shape)\n\n # Compute Deltas\n if self.__nextLayer.__class__.__name__ is 'FCLayer':\n for n in range(self.outputValues.shape[0]):\n for nf in range(self.numberOfFilters):\n for h in range(self.outputValues.shape[2]):\n for w in range(self.outputValues.shape[3]):\n deltas_i = self.activationFunctionDerivative(self.outputValues)[n, nf, h, w] * dNext[\n :, :, :, nf]\n self.deltas[n, nf, h, w] += deltas_i\n\n elif self.__previousLayer is None:\n for n in range(self.outputValues.shape[0]):\n deltas_i = self.activationFunctionDerivative(self.outputValues)[n] * dNext\n self.deltas[n] += deltas_i[0]\n\n else:\n for n in range(self.outputValues.shape[0]):\n deltas_i = self.activationFunctionDerivative(self.outputValues)[n] * dNext\n self.deltas[n] += deltas_i[n]\n\n # print \"shape of delta is \" + str(self.deltas.shape)\n\n if self.spaceConv is True:\n self.deltas = np.transpose(self.deltas, (3, 1, 2, 0))\n else:\n pass\n\n # Compute delta Biases\n deltaBiases = (np.sum(self.deltas, axis=(0, 2, 3)))\n assert deltaBiases.shape == self.bias.shape\n\n # Compute delta Kernels\n\n deltaKernel = np.zeros(self.weights.shape)\n\n for ninp in range(self.inputShape[0]):\n for nf in range(self.numberOfFilters):\n flippedDelta = self.flipArray(self.deltas[ninp, nf, :, :]) # Flips Kernel for the convolution\n for cin in range(self.inputShape[1]):\n nh = 0\n for h in np.arange(0, self.inputs.shape[2] - flippedDelta.shape[0] + 1, self.stride[0]):\n nw = 0\n for w in np.arange(0, self.inputs.shape[3] - flippedDelta.shape[1] + 1, self.stride[1]):\n activationMap = self.inputs[ninp, cin,\n h:h + flippedDelta.shape[0],\n w:w + flippedDelta.shape[1]] # Input Map used for the convolution\n deltaKernel[nf, nh, nw] = np.sum(activationMap * flippedDelta) # Convolution\n nw += 1\n nh += 1\n\n if self.spaceConv is True:\n self.deltas = np.transpose(self.deltas, (3, 1, 2, 0))\n else:\n pass\n\n self.deltaWeights = deltaKernel\n self.deltaBiases = deltaBiases\n\n if self.__previousLayer is None:\n return self.deltas, self.deltaWeights, self.deltaBiases\n else:\n return self.__previousLayer.backpropagation()","def train(X, Y=[], hidden_layer_sizes=[], error_deriv=\"default\", n_outputs=\"default\", n_loops=100,\n eta=.1, output_transformation=\"default\", error_function=\"default\"):\n \n # the default error function will be the squared error function, whose derivative is just\n # the output minus the target values\n def square_error_deriv(output, x, y):\n return output - y\n if error_deriv == \"default\":\n error_deriv = square_error_deriv\n \n # the default error function is the squared error \n def square_error(Y, Y_hat):\n return np.linalg.norm(Y_hat - Y, ord='fro') / (Y.shape[0]*Y.shape[1])\n if error_function == \"default\":\n error_function = square_error\n\n # the default output transformatoin is none\n def none_transformation(output):\n return output\n if output_transformation == \"default\":\n output_transformation = none_transformation\n\n if len(Y) > 0:\n if n_outputs == \"default\":\n n_outputs = Y.shape[0]\n else:\n # setting one y value for the rest of the training\n y = \"None\"\n layer_sizes = [X.shape[0]] + hidden_layer_sizes + [n_outputs]\n weights = construct_network(layer_sizes)\n \n errorvec = np.empty((n_loops))\n for loop in np.arange(n_loops):\n delta_W = []\n # initiazlizing delta Ws\n for weight_mat_idx in range(len(weights)):\n delta_W.append(np.zeros((weights[weight_mat_idx].shape)))\n \n for data_idx in np.arange(n_data):\n x = X[:, data_idx]\n y = Y[:, data_idx]\n layer_activations, output = forward_propagate(x, weights)\n \n errors = [error_deriv(output, x, y)]\n # go from the output layer towards the input layer and calculate error values\n for idx in np.arange(1, len(weights)):\n # prepend the newest error layer to the errors list:\n errors = [-np.multiply(deriv_sigmoid(layer_activations[-idx-1]), \\\n weights[-idx].T @ errors[-idx])] \\\n + errors\n errors[-idx-1] = errors[-idx-1][:-1,0] # removing bias\n # go from input layer towards output layer and calculate weight updates\n for idx in range(len(weights)):\n delta_W[idx] -= errors[idx] @ layer_activations[idx].T\n delta_W[idx][:,:-1] = np.mean(layer_activations[idx])\n \n # update all weight matrices\n for idx in range(len(weights)): \n weights[idx] += eta/n_data * delta_W[idx]\n \n Y_hat = classify(X, weights, output_transformation)\n errorvec[loop] = error_function(Y, Y_hat)\n return weights, errorvec","def compute(self, step: int) -> None:\n if self.episode >= self._wp.training_delay:\n # Transfer network parameters if episode 0 or 100 * n.\n if self.episode % 100 == 0:\n self._policy.transfer_parameters()\n\n self.get_logger().info('Computing gradients...')\n if self.atype in ['REINFORCE', 'A2C']:\n batch = self._db.sample_batch(step, 'all')\n self._policy.train(batch, step)\n\n else:\n batch = self._db.sample_batch(self._wp.batch_size)\n self._policy.train(batch, self._wp.batch_size)\n\n else:\n self.get_logger().warn(\n 'Skipping computing gradients till episode ' +\n f'{self._wp.training_delay}!'\n )\n\n # Move to `push` section\n self.flag.shift_to_push_cycle()","def step(self, closure=None):\n loss = None\n if closure is not None:\n with torch.enable_grad():\n loss = closure()\n\n for group in self.param_groups:\n beta1, beta2 = group['betas']\n base_lr = group['lr']\n max_norm = group['max_norm']\n fixed_norm = group['fixed_norm']\n zero_mean = group['zero_mean']\n normalizing_grad_by_norm = group['normalizing_grad_by_norm']\n eps = group['eps']\n weight_decay = group['weight_decay']\n l2_regularization = group['l2_regularization']\n bias_correction1 = 1\n for p in group['params']:\n if p.grad is None:\n continue\n pmax_norm, pfixed_norm, pzero_mean = _get_opt_args(\n p, max_norm, fixed_norm, zero_mean)\n lr = get_opt_arg(p, 'lr', base_lr)\n lr_scale = get_opt_arg(p, 'lr_scale', 1)\n state = self.state[p]\n state['step'] += 1\n bias_correction2 = 1 - beta2**state['step']\n grad = p.grad\n pweight_decay = get_opt_arg(p, 'weight_decay', weight_decay)\n pl2_regularization = get_opt_arg(p, 'l2_regularization',\n l2_regularization)\n if pl2_regularization != 0:\n grad = grad.add(p, alpha=pl2_regularization)\n if beta1 > 0:\n bias_correction1 = 1 - beta1**state['step']\n exp_avg = state['exp_avg']\n exp_avg.lerp_(grad, 1 - beta1)\n else:\n exp_avg = grad\n if normalizing_grad_by_norm:\n sq = _norm(grad)**2\n else:\n sq = grad**2\n state['exp_avg_sq'].lerp_(sq, 1 - beta2)\n denom = state['exp_avg_sq'].sqrt().add_(eps)\n if pweight_decay > 0:\n p.mul_(1 - lr_scale * lr * pweight_decay)\n # the exponential moving average of exp_avg and exp_avg_sq are not\n # unbiased estimate of the mean. Correct them using bas_correction1\n # and bias_correct2 as suggest by the original Adam paper.\n step_size = lr_scale * lr * math.sqrt(\n bias_correction2) / bias_correction1\n # p <- p - step_size * exp_avg / denom\n p.addcdiv_(exp_avg, denom, value=-step_size)\n _normalize(p, pmax_norm, pfixed_norm, pzero_mean)\n\n return loss","def step(self, closure=None):\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n lr = group[\"lr\"]\n weight_decay = group[\"weight_decay\"]\n momentum = group['momentum']\n dampening = group[\"dampening\"]\n nesterov = group[\"nesterov\"]\n maximize = group[\"maximize\"]\n\n for p in group[\"params\"]:\n if p.grad is None:\n continue\n\n grad = p.grad\n\n if grad.is_sparse:\n raise RuntimeError(\"SGD does not support sparse gradients.\")\n\n grad = grad if not maximize else -grad\n\n if weight_decay != 0:\n grad = grad.add(p, alpha=weight_decay)\n\n if momentum != 0:\n buf = self.state[p][\"momentum_buffer\"]\n\n buf.mul_(momentum).add_(grad, alpha=1.0 - dampening)\n\n if nesterov:\n grad.add_(buf, alpha=momentum)\n else:\n grad = buf\n\n p.add_(-lr * grad)\n\n return loss","def step(self, closure: Optional[Callable[[], float]] = None) -> Optional[float]:\n loss = None\n if closure is not None:\n with torch.enable_grad():\n loss = closure()\n\n for group in self.param_groups:\n for p in group[\"params\"]:\n if p.grad is None:\n continue\n grad = p.grad\n if grad.is_sparse:\n raise RuntimeError(\"RMSpropTF does not support sparse gradients\")\n state = self.state[p]\n\n # State initialization\n if len(state) == 0:\n state[\"step\"] = 0\n # PyTorch initialized to zeros here\n state[\"square_avg\"] = torch.ones_like(p, memory_format=torch.preserve_format)\n if group[\"momentum\"] > 0:\n state[\"momentum_buffer\"] = torch.zeros_like(p, memory_format=torch.preserve_format)\n if group[\"centered\"]:\n state[\"grad_avg\"] = torch.zeros_like(p, memory_format=torch.preserve_format)\n\n square_avg = state[\"square_avg\"]\n alpha = group[\"alpha\"]\n\n state[\"step\"] += 1\n\n if group[\"weight_decay\"] != 0:\n grad = grad.add(p, alpha=group[\"weight_decay\"])\n\n square_avg.mul_(alpha).addcmul_(grad, grad, value=1 - alpha)\n\n if group[\"centered\"]:\n grad_avg = state[\"grad_avg\"]\n grad_avg.mul_(alpha).add_(grad, alpha=1 - alpha)\n # PyTorch added epsilon after square root\n # avg = square_avg.addcmul(grad_avg, grad_avg, value=-1).sqrt_().add_(group['eps'])\n avg = square_avg.addcmul(grad_avg, grad_avg, value=-1).add_(group[\"eps\"]).sqrt_()\n else:\n # PyTorch added epsilon after square root\n # avg = square_avg.sqrt().add_(group['eps'])\n avg = square_avg.add(group[\"eps\"]).sqrt_()\n\n if group[\"momentum\"] > 0:\n buf = state[\"momentum_buffer\"]\n buf.mul_(group[\"momentum\"]).addcdiv_(grad, avg)\n p.add_(buf, alpha=-group[\"lr\"])\n else:\n p.addcdiv_(grad, avg, value=-group[\"lr\"])\n\n return loss","def step(self, closure=None):\n loss = None\n if closure is not None:\n with torch.enable_grad():\n loss = closure()\n\n for group in self.param_groups:\n momentum = group['momentum']\n beta = group['beta']\n eps = group['eps']\n clip_threshold = group['clip_threshold']\n for p in group['params']:\n if p is None:\n continue\n grad = p.grad\n\n state = self.state[p]\n shape = grad.shape\n rank = len(shape)\n\n # State initialization\n if len(state) == 0:\n state['step'] = 0\n state['momentum_buffer'] = 0.\n _add_initial_accumulators(state, grad)\n\n if grad.is_sparse:\n # the update is non-linear so indices must be unique\n grad.coalesce()\n grad_indices = grad._indices()\n grad_values = grad._values()\n\n # Transform update_values into sparse tensor\n def make_sparse(values):\n constructor = grad.new\n if grad_indices.dim() == 0 or values.dim() == 0:\n return constructor().resize_as_(grad)\n return constructor(grad_indices, values, grad.size())\n\n acc = state[_key(0)]\n update_values = _compute_sparse_update(beta, acc, grad_values, grad_indices)\n self._update_sparse_accumulator(beta, acc, make_sparse(update_values))\n\n # Add small amount for numerical stability\n update_values.add_(eps).rsqrt_().mul_(grad_values)\n\n update = make_sparse(update_values)\n else:\n # Get previous accumulators mu_{t-1}\n if rank > 1:\n acc_list = [state[_key(i)] for i in range(rank)]\n else:\n acc_list = [state[_key(0)]]\n\n # Get update from accumulators and gradients\n update = _compute_update(beta, acc_list, grad, clip_threshold)\n\n # Update accumulators.\n self._update_accumulator(beta, acc_list, update)\n\n # Add small amount for numerical stability\n update.add_(eps).rsqrt_().mul_(grad)\n\n if momentum > 0.:\n m = state['momentum_buffer']\n update.mul_(1. - momentum).add_(m, alpha=momentum)\n state['momentum_buffer'] = update.detach()\n\n p.sub_(update, alpha=group['lr'])\n state['step'] += 1\n return loss","def add_grad_updates(self):\n \n gradients = T.grad(self.cost, self.theta)\n \n for target_param, grad in zip(self.theta, gradients):\n \n if target_param.name ==\"W\" and self.num_hidden ==0\\\n and self.zero_diag:\n \n grad = grad - T.diag(T.diag(grad)) # no x i - xi connections\n # for all i = 1, ..., D\n ##############################################################\n if target_param.name ==\"b\" and self.learn_biases == False:\n print(\"Will not learn bias terms\")\n pass\n \n elif target_param.name ==\"bhid\" and self.learn_biases == False:\n print(\"Will not learn bias terms\")\n pass\n \n else:\n \n if self.use_momentum:\n \n # alternative definition (mostly seen):\n #g_tilda = self.momentum*self.grad_vec[target_param.name] - \\\n #T.cast(self.learning_rate, dtype = theano.config.floatX)*grad\n #self.updates[target_param] = target_param + g_tilda\n \n g_tilda = self.momentum*self.grad_vec[target_param.name] - \\\n (1-self.momentum)*grad\n \n self.updates[target_param] = target_param +\\\n T.cast(self.learning_rate, dtype = theano.config.floatX)*g_tilda\n \n # store g_tilda for next iteration:\n self.updates[self.grad_vec[target_param.name]] = g_tilda\n \n else:\n \n self.updates[target_param] = target_param -\\\n T.cast(self.learning_rate, dtype = theano.config.floatX)*grad\n \n if (\"PCD\" in self.algorithm) and self.num_hidden > 0:\n \n self.updates[self.persistent_gibbs] = self.hid_samples","def calc_gradient(self):\n \n self.setup()\n\n # Create our 2D dictionary the first time we execute.\n if not self.gradient:\n for name in self.param_names:\n self.gradient[name] = {}\n \n # Pull initial state and stepsizes from driver's parameters\n base_param = OrderedDict()\n stepsize = {}\n for key, item in self._parent.get_parameters().iteritems():\n base_param[key] = item.evaluate()\n \n if item.fd_step:\n stepsize[key] = item.fd_step\n else:\n stepsize[key] = self.default_stepsize\n\n # For Forward or Backward diff, we want to save the baseline\n # objective and constraints. These are also needed for the\n # on-diagonal Hessian terms, so we will save them in the class\n # later.\n base_data = self._run_point(base_param)\n \n # Set up problem based on Finite Difference type\n if self.form == 'central':\n deltas = [1, -1]\n func = diff_1st_central\n elif self.form == 'forward':\n deltas = [1, 0]\n func = diff_1st_fwrdbwrd\n else:\n deltas = [0, -1]\n func = diff_1st_fwrdbwrd\n\n self.gradient_case = OrderedDict()\n\n # Assemble input data\n for param in self.param_names:\n \n pcase = []\n for j_step, delta in enumerate(deltas):\n \n case = base_param.copy()\n case[param] += delta*stepsize[param]\n pcase.append({ 'param': case })\n \n self.gradient_case[param] = pcase\n \n # Run all \"cases\".\n # TODO - Integrate OpenMDAO's concurrent processing capability once it\n # is formalized. This operation is inherently paralellizable.\n for key, case in self.gradient_case.iteritems():\n for ipcase, pcase in enumerate(case):\n if deltas[ipcase]:\n pcase['data'] = self._run_point(pcase['param'])\n else:\n pcase['data'] = base_data\n \n \n # Calculate gradients\n for key, case in self.gradient_case.iteritems():\n \n eps = stepsize[key]\n \n for name in list(self.objective_names + \\\n self.eqconst_names + \\\n self.ineqconst_names):\n self.gradient[key][name] = \\\n func(case[0]['data'][name],\n case[1]['data'][name], eps)\n\n # Save these for Hessian calculation\n self.base_param = base_param\n self.base_data = base_data","def _compute(self, global_step, params, batch_loss):\n individual_losses = get_individual_losses(global_step)\n individual_gradients = autograd_individual_gradients(individual_losses, params)\n layerwise = [\n self._compute_histogram(p, igrad)\n for p, igrad in zip(params, individual_gradients)\n ]\n\n hist = sum(out[0] for out in layerwise)\n edges = layerwise[0][1]\n\n result = {\"hist\": hist, \"edges\": edges}\n\n if self._keep_individual:\n result[\"param_groups\"] = len(params)\n\n for idx, (hist, edges) in enumerate(layerwise):\n result[f\"param_{idx}\"] = {\"hist\": hist, \"edges\": edges}\n\n return result","def train_LR(self, X, y, eta=1e-3, batch_size=1, num_iters=1000) :\n loss_history = []\n N,d = X.shape\n for t in np.arange(num_iters):\n X_batch = None\n y_batch = None\n # ================================================================ #\n # YOUR CODE HERE:\n # Sample batch_size elements from the training data for use in gradient descent. \n # After sampling, X_batch should have shape: (batch_size,1), y_batch should have shape: (batch_size,)\n # The indices should be randomly generated to reduce correlations in the dataset. \n # Use np.random.choice. It is better to user WITHOUT replacement.\n # ================================================================ #\n \n # sample indices without replacement\n batch_idx = np.random.choice(N, batch_size, replace = False)\n X_batch = X[batch_idx]\n y_batch = y[batch_idx]\n \n \n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n loss = 0.0\n grad = np.zeros_like(self.w)\n # ================================================================ #\n # YOUR CODE HERE: \n # evaluate loss and gradient for batch data\n # save loss as loss and gradient as grad\n # update the weights self.w\n # ================================================================ #\n \n # compute the loss and gradient\n # loss_and_grad will take responsible for these\n \n loss, grad = self.loss_and_grad(X_batch, y_batch)\n \n self.w = self.w - eta * grad\n \n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n loss_history.append(loss)\n return loss_history, self.w","def _evaluate_gradient(self, **variables):\n pass","def _train_step(self, params, sim_data):\n \n # Compute loss and store gradients\n with tf.GradientTape() as tape:\n loss = self.loss(self.network, params, sim_data)\n \n # One step backprop\n gradients = tape.gradient(loss, self.network.trainable_variables)\n self._apply_gradients(gradients, self.network.trainable_variables) \n \n return loss.numpy()","def step(self, closure=None):\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n lr = group[\"lr\"]\n weight_decay = group[\"weight_decay\"]\n lr_decay = group[\"lr_decay\"]\n eps = group[\"eps\"]\n maximize = group[\"maximize\"]\n\n for p in group[\"params\"]:\n if p.grad is None:\n continue\n\n grad = p.grad\n\n if grad.is_sparse:\n raise RuntimeError(\n \"Adagrad does not support sparse gradients.\"\n )\n\n state = self.state[p]\n state_sum = state[\"sum\"]\n\n global_step = self._get_global_step(p)\n\n grad = grad if not maximize else -grad\n\n if group[\"weight_decay\"] > 0:\n grad = grad.add(p, alpha=weight_decay)\n\n state_sum.addcmul_(grad, grad, value=1.0)\n std = state_sum.sqrt().add_(eps)\n\n grad.div_(1.0 + (global_step - 1.0) * lr_decay)\n p.addcdiv_(-lr * grad, std)\n\n return loss","def _apply_gradient_descent(self, gradients):\n updated_sd = {}\n global_model = self._get_global_model()\n \n for name, param, grad in zip(global_model.keys(), global_model.values(), gradients):\n updated_sd[name] = param - self.global_lr * grad\n \n self._load_global_model(updated_sd)","def step(self, closure=None):\n loss = None\n if closure is not None:\n loss = closure()\n\n for group in self.param_groups:\n for p in group['params']:\n if p.grad is None:\n continue\n grad = p.grad.data\n if grad.is_sparse:\n raise RuntimeError('Lamb does not support sparse gradients, consider SparseAdam instad.')\n\n state = self.state[p]\n\n # State initialization\n if len(state) == 0:\n state['step'] = 0\n # Exponential moving average of gradient values\n state['exp_avg'] = torch.zeros_like(p.data)\n # Exponential moving average of squared gradient values\n state['exp_avg_sq'] = torch.zeros_like(p.data)\n\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\n beta1, beta2 = group['betas']\n\n state['step'] += 1\n\n # Decay the first and second moment running average coefficient\n # m_t\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\n # v_t\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\n\n # Paper v3 does not use debiasing.\n # bias_correction1 = 1 - beta1 ** state['step']\n # bias_correction2 = 1 - beta2 ** state['step']\n # Apply bias to lr to avoid broadcast.\n step_size = group['lr'] # * math.sqrt(bias_correction2) / bias_correction1\n\n weight_norm = p.data.pow(2).sum().sqrt().clamp(0, 10)\n\n adam_step = exp_avg / exp_avg_sq.sqrt().add(group['eps'])\n if group['weight_decay'] != 0:\n adam_step.add_(group['weight_decay'], p.data)\n\n adam_norm = adam_step.pow(2).sum().sqrt()\n if weight_norm == 0 or adam_norm == 0:\n trust_ratio = 1\n else:\n trust_ratio = weight_norm / adam_norm\n state['weight_norm'] = weight_norm\n state['adam_norm'] = adam_norm\n state['trust_ratio'] = trust_ratio\n if self.adam:\n trust_ratio = 1\n\n p.data.add_(-step_size * trust_ratio, adam_step)\n\n return loss","def train(self, X, y, X_val, y_val,\n alpha=1e-3, alpha_decay=0.95,\n reg=1e-5, num_iters=100,\n batch_size=100):\n num_train = X.shape[0]\n iteration = max(num_train / batch_size, 1)\n\n loss_train = []\n train_acc = []\n val_acc = []\n\n for it in range(num_iters):\n print('iteration '+str(it))\n data_batch = None\n label_batch = None\n \n #########################################################################\n # create a random batch of data and labels for\n indx = np.random.permutation(len(X))\n data, labels = X[indx], y[indx]\n data_batch = data[0:batch_size]\n label_batch = labels[0:batch_size]\n #########################################################################\n pass\n #########################################################################\n # END OF YOUR CODE #\n #########################################################################\n # calculate loss and gradients\n loss, gradient = self.loss(data_batch, y=label_batch, reg=reg)\n loss_train.append(loss)\n #########################################################################\n # update weights and biases which stored in the slef.p_net regarding \n # to gradient dictionary.\n self.p_net['W1'] -= alpha * gradient['W1']\n self.p_net['b1'] -= alpha * gradient['b1']\n self.p_net['W2'] -= alpha * gradient['W2']\n self.p_net['b2'] -= alpha * gradient['b2']\n #########################################################################\n pass\n #########################################################################\n # END OF YOUR CODE #\n #########################################################################\n if it % 100 == 0:\n print ('iteration %d / %d: loss %f' % (it, num_iters, loss))\n \n if it % iteration == 0:\n # Check accuracy\n train_acc_ = (self.predict(data_batch) == label_batch).mean()\n val_acc_ = (self.predict(X_val) == y_val).mean()\n train_acc.append(train_acc_)\n val_acc.append(val_acc_)\n\n alpha *= alpha_decay\n\n return {\n 'loss_train': loss_train,\n 'train_acc': train_acc,\n 'val_acc': val_acc,\n }","def backward_pass(architecture,gradient_layerwise,grad_weights,grad_bias):\n \n for layer in range(len(architecture)-1,-1,-1):\n X_input,X_output,weightsi,biasi,X_input_im2col,imi,output_shapei,kernel_shapei,stridei,operationi,imxi = architecture['layer{}'.format(layer+1)]\n# print(\"Operation is:{} and Layer is: {}\".format(operationi,layer+1))\n if operationi == 'softmax': # Last layer -> Dont apply softmax in any layer other than the last layer!\n # not taking gradients here because we need dz_dX(secondlastlayer) which is y_pred - y\n continue\n \n if operationi == 'conv_bn_relu' or operationi == 'conv_relu' or operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\n if operationi__1 == 'softmax':\n y_pred = architecture['layer{}'.format(layer+2)][1]\n y_pred = torch.reshape(y_pred,y.shape)\n dz_dXi = y_pred - y\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\n X_output = torch.reshape(X_output,dz_dXi.shape)\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n elif 'relu' in operationi:\n dz_dXi[X_output <= 0] = 0\n else:\n None\n \n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # .\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # .\n try:\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input_im2col)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\n except:\n dz_dweightsi = (dz_dXi).mm(X_input_im2col)\n \n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi #\n elif operationi__1 == 'maxpool': # need to do something here to fix the problem\n None\n\n elif 'flatten' in operationi__1:\n # we currently have dz_doutput of flatten -> we want dz_doutput of the conv_bn_relu before flatten\n \n weightsi__1 = architecture['layer{}'.format(layer+2)][2] # weights2\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput of flatten\n if len(dz_dXi__1.shape) == 3:\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\n imi__1 = architecture['layer{}'.format(layer+2)][5] # i\n try:\n dz_dXi = torch.t(weightsi__1).mm(dz_dXi__1)\n except:\n dz_dXi = weightsi__1.mm(dz_dXi__1)\n X_output = torch.reshape(X_output,dz_dXi.shape)\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n elif 'relu' in operationi:\n dz_dXi[X_output <= 0] = 0\n else:\n None\n\n dz_dXi = torch.reshape(dz_dXi,(output_shapei[1]*output_shapei[2],-1))\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\n dz_dweightsi = X_input_im2col.mm(dz_dXi)\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\n dz_dbi = dz_dXi\n \n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)# Can also set this to layer like in line ~800\n \n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi) # Can also set this to layer like in line ~800\n \n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi) # Can also set this to layer like in line ~800\n \n else:\n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dX2 -> backpropagated from maxpool\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\n if len(dz_dXi__1.shape) == 3:\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\n imi__1 = architecture['layer{}'.format(layer+2)][5]\n try:\n Y = weightsi__1.mm(dz_dXi__1)\n except:\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\n dz_dXi = torch.zeros(X_output.shape)\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\n for i in range(np.shape(X_output)[0]):\n for j in range(np.shape(X_output)[1]):\n for k in range(np.shape(X_output)[2]):\n idxs = getIndexes(imi__1,(i,j,k))\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\n \n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\n if 'sigmoid' in operationi__1: # ...\n X_output = torch.reshape(X_output,dz_dXi.shape)\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n elif 'relu' in operationi__1: # ...\n dz_dXi[X_output <= 0] = 0\n else:\n None\n \n dz_dXi = torch.reshape(dz_dXi,(output_shape_current_layer[1]*output_shape_current_layer[2],-1))\n dz_dbi = torch.reshape(dz_dXi,bias_current_layer.shape)\n dz_dweightsi = X_im2col_current_layer.mm(dz_dXi)\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\n \n if operationi == 'maxpool':\n \n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput -> backpropagated from maxpool\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\n \n if len(dz_dXi__1.shape) == 3:\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\n imi__1 = architecture['layer{}'.format(layer+2)][5]\n try:\n Y = weightsi__1.mm(dz_dXi__1)\n except:\n try:\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\n except:\n Y = torch.t(weightsi__1).mm(dz_dXi__1) # Ensuring valid matrix multiplication here\n \n dz_dXi = torch.zeros(X_output.shape)\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\n for i in range(np.shape(X_output)[0]):\n for j in range(np.shape(X_output)[1]):\n for k in range(np.shape(X_output)[2]):\n idxs = getIndexes(imi__1,(i,j,k))\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\n\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\n \n if operationi__1 == 'conv_sigmoid' or operationi__1 == 'conv_bn_sigmoid': # ...\n X_output = torch.reshape(X_output,dz_dXi.shape)\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n else:\n dz_dXi[X_output <= 0] = 0\n\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\n \n dz_dXinput = torch.zeros((X_input.shape))\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+1)][0] # output = output of maxpool\n\n dz_dXoutput = torch.reshape(dz_dXoutput,(output_shapei[0],X_input_im2col.shape[2]))\n \n for i in range(output_shapei[0]):\n for j in range(X_input_im2col.shape[2]):\n Xi2ci = X_im2col_current_layer[i,:,:]\n idx = torch.argmax(Xi2ci[:,j]).item()\n value = imxi[i][(idx,j)]\n dz_dXinput[value[0],value[1],value[2]] += float(dz_dXoutput[i,j])\n\n# dz_dXinput = torch.reshape(dz_dXinput,output_shapei)\n \n X_prev_im2col = architecture['layer{}'.format(layer)][4]\n X_output_prev = architecture['layer{}'.format(layer)][1]\n X_output_prev = torch.reshape(X_output_prev,dz_dXinput.shape)\n X_input_prev = architecture['layer{}'.format(layer)][0]\n prev_bias = architecture['layer{}'.format(layer)][3]\n output_shape_prev = architecture['layer{}'.format(layer)][6]\n prev_operation = architecture['layer{}'.format(layer)][9]\n \n if prev_operation == 'conv_sigmoid' or prev_operation == 'conv_bn_sigmoid':\n dz_dXinput *= sigmoid(X_output_prev)*(1-sigmoid(X_output_prev)) # Taking the derivative of the sigmoid function\n else:\n dz_dXinput[X_output_prev <= 0] = 0\n \n if len(dz_dXinput.shape) == 3:\n dz_dXinput = torch.reshape(dz_dXinput,(-1,output_shape_prev[0]))\n \n dz_dbi = torch.reshape(dz_dXinput,prev_bias.shape)\n dz_dweightsi = X_prev_im2col.mm(dz_dXinput)\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0\n \n gradient_layerwise['layer{}'.format(layer)][2] = torch.Tensor(dz_dbi)\n gradient_layerwise['layer{}'.format(layer)][1] = torch.Tensor(dz_dweightsi)\n gradient_layerwise['layer{}'.format(layer)][0] = torch.Tensor(dz_dXinput) # ...\n \n if 'flatten_dense' in operationi:\n \n operationi__1 = architecture['layer{}'.format(layer+2)][9]\n \n if operationi__1 == 'softmax':\n \n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\n X_output = torch.reshape(X_output,(-1,1))\n y_pred = architecture['layer{}'.format(layer+2)][1]\n y_pred = torch.reshape(y_pred,y.shape)\n dz_dXi = y_pred - y\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\n X_output = torch.reshape(X_output,dz_dXi.shape)\n if 'sigmoid' in operationi:\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n elif 'relu' in operationi:\n dz_dXi[X_output <= 0] = 0\n else:\n None\n \n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\n try:\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\n except:\n dz_dweightsi = (dz_dXi).mm(X_input)\n \n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0\n \n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # Can also set this to layer like in line ~800\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi # Can also set this to layer like in line ~800\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # Can also set this to layer like in line ~800\n \n else:\n # Have to modify and test this before implementation -> Specifically\n # the backprop implementation is not consistent with the ones above\n #\n X_output = torch.reshape(X_output,(-1,1))\n weights__i = architecture['layer{}'.format(layer+2)][2]\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+2)][0]\n dz_dXoutput = torch.reshape(torch.Tensor(dz_dXoutput),X_output.shape)\n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\n\n if 'relu' in operationi:\n dz_dXoutput[X_output<0] = 0\n try:\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\n except:\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\n try:\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\n except:\n dz_dweightsi = dz_dXoutput.mm(X_input)\n dz_dbi = dz_dXoutput\n if 'sigmoid' in operationi:\n dz_dXoutput*= sigmoid(X_output)*(1-sigmoid(X_output))\n try:\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\n except:\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\n try:\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\n except:\n dz_dweightsi = dz_dXoutput.mm(X_input)\n dz_dbi = dz_dXoutput\n else:\n try:\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\n except:\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\n try:\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\n except:\n dz_dweightsi = dz_dXoutput.mm(X_input)\n dz_dbi = dz_dXoutput\n \n unflattened_Xinput = architecture['layer{}'.format(layer+1)][0]\n dz_dXinput = torch.reshape(dz_dXinput,unflattened_Xinput.shape)\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXinput)\n \n if gradient_layerwise['layer{}'.format(layer+1)][1] is not None:\n try:\n grad_weights['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][1]\n except:\n grad_weights['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][1])\n if gradient_layerwise['layer{}'.format(layer+1)][2] is not None:\n try:\n grad_bias['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][2]\n except:\n grad_bias['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][2])\n \n gc.collect()\n return","def compute_gradients(self,\n loss,\n var_list=None,\n gate_gradients=optimizer.Optimizer.GATE_OP,\n aggregation_method=None,\n colocate_gradients_with_ops=False,\n grad_loss=None):\n if not var_list:\n var_list = variables.trainable_variables()\n\n elastic_difference = [\n math_ops.subtract(v, lv)\n for v, lv in zip(variables.trainable_variables(),\n [self._local_map[var] for var in var_list])\n ]\n\n distance_loss = self._rho * math_ops.add_n(\n [gen_nn_ops.l2_loss(ed) for ed in elastic_difference])\n\n total_loss = loss + distance_loss\n return self._opt.compute_gradients(total_loss, var_list, gate_gradients,\n aggregation_method,\n colocate_gradients_with_ops, grad_loss)","def optimize(w, b, X, Y, num_iterations,learning_rate,print_cost = False):\n costs = []\n for i in range(num_iterations):\n\n # Cost and gradient calculation (≈ 1-4 lines of code)\n ### START CODE HERE ###\n grads,cost = propagate(w,b,X,Y)\n ### END CODE HERE ###\n\n # Retrieve derivatives from grads\n dw = grads[\"dw\"]\n db = grads[\"db\"]\n\n # update rule (≈ 2 lines of code)\n ### START CODE HERE ###\n w = w - learning_rate*dw\n b = b - learning_rate*db\n ### END CODE HERE ###\n\n # Record the costs\n if i % 100 == 0:\n costs.append(cost)\n\n # Print the cost every 100 training examples\n if print_cost and i%100==0:\n print(\"Cost after iteration %i: %f\"%(i,cost))\n\n params = {\n \"w\":w,\n \"b\":b\n }\n grads = {\n \"dw\":dw,\n \"db\":db\n }\n return params,grads,costs","def solve(self):\n max_iter = 1000\n iter_count = 0\n yhat = self.predict()\n loss = self.cross_entropy(yhat)\n gradloss = self.cross_entropy_gradient(yhat)\n while la.norm(gradloss) > 1e-6 and iter_count < max_iter:\n alpha = 1.0\n slope = la.norm(gradloss)**2\n beta_new = self.beta + alpha * gradloss\n yhat = self.predict(beta=beta_new)\n loss_new = self.cross_entropy(yhat)\n while loss_new < loss + 1e-4 * alpha * slope:\n alpha = alpha / 2\n beta_new = self.beta + alpha * gradloss\n yhat = self.predict(beta=beta_new)\n loss_new = self.cross_entropy(yhat)\n self.beta = beta_new\n loss = loss_new\n gradloss = self.cross_entropy_gradient(yhat)\n iter_count += 1","def run(self):\n if self.graph is None:\n raise ValueError(\"Create TensorFlow graph before running a session.\")\n with tf.Session(graph=self.graph) as session:\n tf.global_variables_initializer().run()\n\n # Stochastic gradient descent: train the data with a mini-batch each iteration\n batch_size = self.options['batch_size']\n for epoch_idx in range(self.options['num_epoch']):\n training_epoch = self.training_data[epoch_idx]\n label_epoch = self.training_label[epoch_idx]\n batch_count = training_epoch.shape[0] // batch_size\n\n learning_rate = self.options['learning_rate']\n if self.options['learning_rate_decay_coeff'] > 0.:\n learning_rate *= self.options['learning_rate_decay_coeff'] ** \\\n max(float(epoch_idx + 1 - self.options['init_epoch']), 0.0)\n for batch in range(batch_count):\n try:\n batch_data = training_epoch[batch*batch_size:(batch+1)*batch_size, :, :]\n batch_labels = label_epoch[batch*batch_size:(batch+1)*batch_size, :]\n except KeyError:\n batch_data = training_epoch[batch*batch_size:, :, :]\n batch_labels = label_epoch[batch*batch_size:, :]\n feed_dict = {\n self.tf_dataset: batch_data,\n self.tf_labels: batch_labels,\n self.learning_rate: learning_rate}\n\n p, l, _, = session.run([self.predict, self.loss, self.minimise], feed_dict=feed_dict)\n self.train_losses.append(l)\n self.train_accuracies.append(self.get_accuracy(batch_labels, p))\n\n # Finally run the data on test data\n final_feed_dict = {\n self.tf_dataset: self.test_data,\n self.tf_labels: self.test_label,\n self.learning_rate: 0.,\n }\n self.predict, final_loss = session.run([self.predict, self.minimise], feed_dict=final_feed_dict)\n return self.predict","def verify_gradients(self):\n\n print 'WARNING: calling verify_gradients reinitializes the learner'\n\n rng = np.random.mtrand.RandomState(1234)\n\n self.seed = 1234\n self.sizes = [4, 5]\n self.initialize(20, 3)\n example = (rng.rand(20) < 0.5, 2)\n input, target = example\n epsilon = 1e-6\n self.lr = 0.1\n self.decrease_constant = 0\n\n self.fprop(input, target)\n self.bprop(input, target) # compute gradients\n\n import copy\n emp_grad_weights = copy.deepcopy(self.weights)\n\n for h in range(len(self.weights)):\n for i in range(self.weights[h].shape[0]):\n for j in range(self.weights[h].shape[1]):\n self.weights[h][i, j] += epsilon\n a = self.fprop(input, target)\n self.weights[h][i, j] -= epsilon\n\n self.weights[h][i, j] -= epsilon\n b = self.fprop(input, target)\n self.weights[h][i, j] += epsilon\n\n emp_grad_weights[h][i, j] = (a - b) / (2. * epsilon)\n\n print 'grad_weights[0] diff.:', np.sum(np.abs(self.grad_weights[0].ravel() - emp_grad_weights[0].ravel())) / \\\n self.weights[0].ravel().shape[0]\n print 'grad_weights[1] diff.:', np.sum(np.abs(self.grad_weights[1].ravel() - emp_grad_weights[1].ravel())) / \\\n self.weights[1].ravel().shape[0]\n print 'grad_weights[2] diff.:', np.sum(np.abs(self.grad_weights[2].ravel() - emp_grad_weights[2].ravel())) / \\\n self.weights[2].ravel().shape[0]\n\n emp_grad_biases = copy.deepcopy(self.biases)\n for h in range(len(self.biases)):\n for i in range(self.biases[h].shape[0]):\n self.biases[h][i] += epsilon\n a = self.fprop(input, target)\n self.biases[h][i] -= epsilon\n\n self.biases[h][i] -= epsilon\n b = self.fprop(input, target)\n self.biases[h][i] += epsilon\n\n emp_grad_biases[h][i] = (a - b) / (2. * epsilon)\n\n print 'grad_biases[0] diff.:', np.sum(np.abs(self.grad_biases[0].ravel() - emp_grad_biases[0].ravel())) / \\\n self.biases[0].ravel().shape[0]\n print 'grad_biases[1] diff.:', np.sum(np.abs(self.grad_biases[1].ravel() - emp_grad_biases[1].ravel())) / \\\n self.biases[1].ravel().shape[0]\n print 'grad_biases[2] diff.:', np.sum(np.abs(self.grad_biases[2].ravel() - emp_grad_biases[2].ravel())) / \\\n self.biases[2].ravel().shape[0]","def step_mine(self, iter=1):\n for i in range(iter):\n self.XY_optimizer_mine.zero_grad()\n batch_XY = _resample(self.XY, batch_size=self.batch_size)\n batch_X, batch_Y = self.split(batch_XY)\n # batch_X = _resample(self.X, batch_size=self.batch_size)\n # batch_Y = _resample(self.Y, batch_size=self.batch_size)\n batch_X_ref_mine = _resample(self.X, batch_size=self.batch_size)\n batch_Y_ref_mine = _resample(self.Y, batch_size=self.batch_size)\n batch_XY_ref_mine = self.cat(batch_X_ref_mine, batch_Y_ref_mine)\n # batch_XY_ref_mine = torch.cat(\n # (batch_X_ref_mine, batch_Y_ref_mine), dim=1)\n # define the loss function with moving average in the gradient estimate\n mean_fXY = self.XY_net(batch_XY).mean(\n ) - self.X_net(batch_X).mean() - self.Y_net(batch_Y).mean()\n # mean_efXY_ref_mine = torch.logsumexp(self.XY_net(batch_XY_ref_mine) - self.X_net(batch_X_ref_mine) - self.Y_net(batch_Y_ref_mine), 0) - np.log(batch_XY_ref_mine.shape[0])\n mean_efXY_ref_mine = torch.exp(\n self.XY_net(batch_XY_ref_mine) - self.X_net(batch_X_ref_mine) - self.Y_net(batch_Y_ref_mine)).mean()\n self.ma_ef = (1-self.ma_rate)*self.ma_ef + \\\n self.ma_rate*mean_efXY_ref_mine\n batch_loss_XY = - mean_fXY + \\\n (1 / self.ma_ef.mean()).detach() * mean_efXY_ref_mine\n batch_loss_XY.backward()\n self.XY_optimizer_mine.step()","def step(self, closure=None):\n orig_loss,err,pred = closure()\n loss = orig_loss\n\n group = self.param_groups[0]\n lr = group['lr']\n decay_lr = group['decay_lr']\n max_iter = group['max_iter']\n reg = group['reg']\n backtrack = group['backtrack']\n bt_alpha = group['bt_alpha']\n bt_beta = group['bt_beta']\n sketch_size = group['sketch_size']\n tolerance = group['tolerance']\n\n #import pdb; pdb.set_trace()\n n = err.shape[0] #batch size\n #If sketching the jacobian, randomly select [sketch_size] samples\n \n if sketch_size is not None:\n idx = torch.randperm(n)[:sketch_size]\n else:\n idx = torch.arange(n) #Don't sketch, use all samples\n \n w0 = nn.utils.parameters_to_vector(self._params) #weight parameters in vector form\n \n #Compute Gauss-Newton vector product \n grad, ggnvp = _make_ggnvp(err,self._params,w0,n,reg,idx) #return gradient in vector form + ggnvp function\n #Solve for the Conjugate Gradient Direction\n dw, cost_log = _conjugate_gradient(ggnvp, grad, max_iter, tolerance)\n\n #Perform backtracking line search\n val = loss + 0.5 * reg * torch.norm(w0)**2\n fprime = -1*dw @ grad\n \n self.grad_update += 1\n if backtrack > 0:\n t = lr\n\n #TODO: If using backtracking, get new loss with (w0 - t*dw) as network parameters\n bts = 0\n alpha = bt_alpha\n beta = bt_beta \n while (loss + 0.5 * reg * torch.norm(w0 - t*dw)**2 > val + alpha * t * fprime):\n t = beta * t\n bts += 1\n if bts > backtrack:\n print('Maximum backtracking reached, accuracy not guaranteed')\n break\n elif decay_lr: #decay lr\n t = lr/np.maximum(1, self.grad_update-10)\n else: #use lr step-size\n t = lr\n\n print('step size: {}'.format(t))\n\n #Update the model parameters\n self._add_grad(-t, dw)\n \n return val, pred","def __SGD(self, X_train, Y_train):\n \n display_step = 100\n iters = len(X_train) // batch_size\n all_loss = []\n\n for e in range(epochs):\n indices = np.random.permutation(len(X_train))\n X_train, Y_train = X_train[indices], Y_train[indices]\n loss = 0\n for i in range(iters):\n batch_x = X_train[i * self.batch_size : min((i + 1) * self.batch_size, len(X_train))]\n batch_y = Y_train[i * self.batch_size : min((i + 1) * self.batch_size, len(Y_train))]\n outputs = self.__forward_propagate(batch_x)\n loss += self.compute_loss(batch_y, all_X[-1])\n grad_list = self.__backward_propagate(batch_y, outputs)\n self.update_weight(grad_list)\n\n if (e + 1) % display_step == 0:\n print(\"Epoch: {}, Loss: {}\".format(e + 1, loss))","def update(network: nn.Module, data: DataLoader, loss: nn.Module, \n opt: optim.Optimizer) -> list:\n error_list = []\n counter = 0\n for x, y in data:\n \n print(x.float()[0])\n pred = network(x.float())\n print(pred, y.float())\n\n le = loss(pred, y.float())\n error_list.append(le)\n opt.zero_grad()\n le.backward()\n opt.step()\n counter += 1\n \n print(\"Loss: \", torch.mean(torch.tensor(error_list)) )\n \n return torch.tensor(error_list)","def step(self, closure=None):\n loss = None\n if closure is not None:\n loss = closure()\n for group in self.param_groups:\n weight_decay = group['weight_decay']\n for p in group['params']:\n if p.grad is None:\n continue\n d_p = p.grad.data\n if weight_decay != 0:\n d_p.add_(weight_decay, p.data)\n p.data.add_(-group['lr'], d_p)\n return loss","def update_network(self, loss_dict):\r\n loss = sum(loss_dict.values())\r\n self.optimizer.zero_grad()\r\n loss.backward()\r\n self.optimizer.step()","def gradient_descend(self, X, y, state_generators, operator_programs=None,\r\n qvm=None):\r\n history_theta, history_loss, history_grad = [], [], []\r\n coeff, theta = 1.0, self.initial_theta\r\n \r\n prog_input_gen = state_generators['input']\r\n prog_output_gen = state_generators['output']\r\n prog_output_grad = state_generators['grad']\r\n \r\n n_samples = len(X)\r\n n_theta = len(theta)\r\n \r\n if qvm is None:\r\n self.qvm = api.QVMConnection()\r\n else:\r\n self.qvm = qvm\r\n \r\n # Check operators\r\n if not isinstance(operator_programs, list):\r\n operator_programs = [operator_programs]\r\n n_operators = len(operator_programs)\r\n \r\n # Check batch size\r\n if self.batch_size is None:\r\n self.batch_size = n_samples\r\n self.batch_size = min(self.batch_size, n_samples)\r\n \r\n # Loop over epochs\r\n for e in range(self.epochs): \r\n \r\n # Loop over batches\r\n batches = self.generate_batches(X, y, self.batch_size)\r\n n_batches = len(batches)\r\n for i, batch in enumerate(batches):\r\n \r\n batch_X, batch_y = batch\r\n n_samples_in_batch = len(batch_X)\r\n \r\n # Predictions\r\n batch_y_pred = np.zeros((n_samples_in_batch, n_operators))\r\n for k in range(n_samples_in_batch):\r\n prog = prog_input_gen(batch_X[k,:])\r\n prog += prog_output_gen(theta)\r\n batch_y_pred[k,:] = coeff * np.array(qvm.expectation(prog, operator_programs))\r\n if self.loss == self.loss_entropy:\r\n batch_y_pred[k,:] = np.exp(batch_y_pred[k,:]) / np.sum(np.exp(batch_y_pred[k,:]))\r\n \r\n # Comput loss\r\n loss_value = self._compute_loss(batch_y, batch_y_pred)\r\n \r\n # Display status\r\n if self.verbose:\r\n print('Epoch: {}/{} ::: Batch: {}/{} ::: Loss: {:.5f}'.format(e+1, self.epochs, i+1, n_batches, loss_value)) \r\n \r\n # Gradient\r\n if not (e == self.epochs - 1 and i == n_batches - 1):\r\n grad = np.zeros((n_samples_in_batch, n_operators, n_theta))\r\n for k in range(n_samples_in_batch):\r\n \r\n # Define input state \r\n prog_input = prog_input_gen(batch_X[k,:])\r\n \r\n # Caclulate gradient for each theta_j\r\n for j in range(n_theta):\r\n \r\n # Gradient +/- \r\n for sign in [1,-1]:\r\n grad_sign = np.zeros(n_operators)\r\n grad_progs = prog_output_grad(theta, j, sign)\r\n # Generally, the gradient programs could return\r\n # a program or list of programs (in case the \r\n # gradient +/- is the sum of expectations)\r\n if not isinstance(grad_progs, list):\r\n grad_progs = [grad_progs]\r\n for grad_prog in grad_progs:\r\n prog = prog_input\r\n prog += grad_prog\r\n # B_j +/- expectation\r\n grad_sign += np.array(qvm.expectation(prog, operator_programs))\r\n # Gradient = (B_j+ - B_j-) / 2\r\n grad[k, :, j] += sign / 2.0 * grad_sign\r\n \r\n # Gradient update\r\n grad_full = self._compute_grad_full(batch_y, batch_y_pred, grad)\r\n if self.loss == self.loss_mse:\r\n grad_full_coeff = -2.0 * np.mean((batch_y - batch_y_pred) * batch_y_pred)\r\n \r\n # Update theta\r\n theta -= self.learning_rate * grad_full\r\n if self.loss == self.loss_mse:\r\n coeff -= self.learning_rate * grad_full_coeff\r\n \r\n # Append to history\r\n history_loss.append(loss_value)\r\n history_theta.append(theta)\r\n history_grad.append(grad)\r\n \r\n # Prepare results\r\n results = OptResults()\r\n results.theta, results.coeff = theta, coeff\r\n results.loss = loss_value\r\n results.history_loss = history_loss\r\n results.history_theta = history_theta\r\n results.history_grad = history_grad\r\n \r\n return results","def get_gradients(self, images, labels):\n # Push to gpu\n images = Variable(images, requires_grad = True) if self.gpu == False else Variable(images.cuda(), requires_grad = True)\n labels = labels if self.gpu == False else labels.cuda()\n\n # Make images require gradients\n images.requires_grad_(True)\n\n # Clear Gradients\n self.net.zero_grad()\n images.grad = None\n\n #Forward pass\n outputs = self.net(images)\n soft_max_output = self.soft_max(outputs)\n loss = self.criterion(outputs, labels)\n losses = self.indv_criterion(outputs, labels)\n _, predicted = torch.max(outputs.data, 1)\n \n # Find size parameters\n batch_size = outputs.size(0)\n num_classes = outputs.size(1)\n\n # Find gradients\n loss.cpu().backward(retain_graph = True)\n gradients = images.grad.data.view(batch_size, 28*28, 1) \n \n return gradients, batch_size, num_classes, losses, predicted","def evaluate_loss(net, data_iter, loss):\n metric = Accumulator(2) # Sum of losses, no. of examples\n for X, y in data_iter:\n out = net(X)\n y = torch.reshape(y, out.shape)\n l = loss(out, y)\n metric.add(torch.sum(l), l.numel())\n return metric[0] / metric[1]","def evaluate_loss(net, data_iter, loss):\n metric = Accumulator(2) # Sum of losses, no. of examples\n for X, y in data_iter:\n out = net(X)\n y = torch.reshape(y, out.shape)\n l = loss(out, y)\n metric.add(torch.sum(l), l.numel())\n return metric[0] / metric[1]","def step(self, closure):\r\n self.state['step'] += 1\r\n for y_ind in range(self.dim_out):\r\n err = closure(y_ind)\r\n for group_ind in range(len(self.param_groups)):\r\n group = self.param_groups[group_ind]\r\n iekf_mat = self.state['iekf_groups'][group_ind]\r\n for ii, w in enumerate(group['params']):\r\n if w.grad is None:\r\n continue\r\n H_n = iekf_mat[ii]['H']\r\n grad = w.grad.data.detach()\r\n if len(w.size()) > 1:\r\n grad = grad.transpose(1, 0)\r\n grad = grad.contiguous().view((1, -1))\r\n if y_ind == 0:\r\n H_n = grad\r\n else:\r\n H_n = torch.cat([H_n, grad], dim=0)\r\n self.state['iekf_groups'][group_ind][ii]['H'] = H_n\r\n\r\n err_T = err.transpose(0, 1)\r\n\r\n for group_ind in range(len(self.param_groups)):\r\n group = self.param_groups[group_ind]\r\n iekf_mat = self.state['iekf_groups'][group_ind]\r\n for ii, w in enumerate(group['params']):\r\n if w.grad is None:\r\n continue\r\n\r\n lbd_n = iekf_mat[ii]['lbd']\r\n P_n = iekf_mat[ii]['P']\r\n EPS = iekf_mat[ii]['EPS']\r\n H_n = iekf_mat[ii]['H']\r\n H_n_T = H_n.transpose(0, 1)\r\n if group['lbd_decay']:\r\n miu = 1.0 / min(self.state['step'], group['lbd_max_step'])\r\n lbd_n = lbd_n + miu * (err_T.mm(err).flatten()[0] / self.dim_out - lbd_n)\r\n self.state['iekf_groups'][group_ind][ii]['lbd'] = lbd_n\r\n R_n = lbd_n * torch.eye(self.dim_out, dtype=torch.float, device=iekf_mat[ii]['device'],\r\n requires_grad=False)\r\n\r\n g_n = R_n + H_n.mm(P_n).mm(H_n_T)\r\n g_n = g_n.inverse()\r\n\r\n K_n = P_n.mm(H_n_T).mm(g_n)\r\n delta_w = K_n.mm(err)\r\n if len(w.size()) > 1:\r\n delta_w = delta_w.view((w.size(1), w.size(0))).transpose(1, 0)\r\n else:\r\n delta_w = delta_w.view(w.size())\r\n\r\n new_P = (group['alpha'] + 1) * (P_n - K_n.mm(H_n).mm(P_n) + EPS)\r\n self.state['iekf_groups'][group_ind][ii]['P'] = new_P\r\n\r\n w.data.add_(delta_w)\r\n\r\n return err","def gradient_descent(features, values, theta, alpha, num_iterations):\r\n \r\n m = len(values)\r\n cost_history = []\r\n\r\n for i in range(num_iterations):\r\n # your code here\r\n cost = compute_cost(features, values, theta)/(2.0*m)\r\n cost_history.append([cost])\r\n \r\n error = features.dot(theta) - values\r\n error = np.reshape(error,(error.shape[0], 1))\r\n errorWeighted = features*error\r\n errorSum = (np.sum(errorWeighted,0))/(m*1.0)\r\n theta = theta - alpha*errorSum \r\n \r\n return theta, pandas.Series(cost_history)","def __call__(self):\n #Losses and optimizers\n for epoch in range(self.nb_epochs): # loop over the dataset multiple times\n self.train_loss = 0.0\n self.gan_loss = 0.0\n self.loss_discrim = 0.0\n val_loss = 0.0\n nb_data = 0.\n nb_data_val = 0.\n for i, data in enumerate(self.trainloader, 0):\n # get the batch; data is a list of [inputs, labels]\n inputs, real = data\n inputs, real = inputs.to(device), real.to(device)\n if i%self.discrimTrainPeriod==0:\n self.trainDiscrim(inputs, real)\n else:\n self.trainGen(inputs, real)\n nb_data += 1.\n #occasionnally save an example target/generated\n if i%self.displayPeriod==0:\n self.gen.eval()\n real = self.unNormalize(real[0,:,:,:].detach().cpu())\n self.transformToImage(real).save(self.targetFile)\n fake = self.gen(inputs)\n fake = self.unNormalize(fake[0,:,:,:].detach().cpu())\n self.transformToImage(fake).save(self.generatedFile)\n\n self.gen.eval()\n for i, data in enumerate(self.valloader, 0):\n with torch.no_grad():\n # get the inputs; data is a list of [inputs, labels]\n inputs, real = data\n inputs, real = inputs.to(device), real.to(device)\n #compute L1 loss\n fake = self.gen(inputs)\n lossGenL1 = self.criterionL1(fake, real)\n #statistics\n val_loss += lossGenL1.item()\n nb_data_val += 1.\n self.gan_loss = self.gan_loss / nb_data\n self.train_loss = self.train_loss / nb_data\n self.loss_discrim = self.loss_discrim / nb_data\n val_loss = val_loss / nb_data_val\n self.gan_loss_list.append(self.gan_loss)\n self.train_loss_list.append(self.train_loss)\n self.val_loss_list.append(val_loss)\n print(\"Epoch \", epoch, \"; train loss = \", self.train_loss,\n \"; val loss = \", val_loss, \"; gan loss = \", self.gan_loss,\n \"; loss discrim = \", self.loss_discrim)\n\n plt.plot(range(len(self.train_loss_list)), self.train_loss_list,\n self.val_loss_list, self.gan_loss_list)\n plt.xlabel(\"Epochs\")\n plt.ylabel(\"Generator Loss\")\n plt.savefig(self.graphFile)\n #save the weights\n torch.save(self.gen.state_dict(), self.savefileGen)\n torch.save(self.discrim.state_dict(), self.savefileDiscrim)","def _validation_loss(self) -> Tuple[float, int]:\n logger.info(\"Validating\")\n\n self.model.eval()\n\n # Replace parameter values with the shadow values from the moving averages.\n if self._moving_average is not None:\n self._moving_average.assign_average_value()\n\n if self._validation_iterator is not None:\n val_iterator = self._validation_iterator\n else:\n val_iterator = self.iterator\n\n num_gpus = len(self._cuda_devices)\n\n raw_val_generator = val_iterator(self._validation_data,\n num_epochs=1,\n shuffle=False)\n val_generator = lazy_groups_of(raw_val_generator, num_gpus)\n num_validation_batches = math.ceil(val_iterator.get_num_batches(self._validation_data)/num_gpus)\n val_generator_tqdm = Tqdm.tqdm(val_generator,\n total=num_validation_batches)\n batches_this_epoch = 0\n val_loss = 0\n for batch_group in val_generator_tqdm:\n\n output_dict = self.get_output_dict(batch_group, for_training=False)\n loss = self.get_batch_loss(output_dict, for_training=False)\n\n if loss is not None:\n # You shouldn't necessarily have to compute a loss for validation, so we allow for\n # `loss` to be None. We need to be careful, though - `batches_this_epoch` is\n # currently only used as the divisor for the loss function, so we can safely only\n # count those batches for which we actually have a loss. If this variable ever\n # gets used for something else, we might need to change things around a bit.\n batches_this_epoch += 1\n val_loss += loss.detach().cpu().numpy()\n\n # Update the description with the latest metrics\n val_metrics = training_util.get_metrics(self.model, val_loss, batches_this_epoch)\n description = training_util.description_from_metrics(val_metrics)\n val_generator_tqdm.set_description(description, refresh=False)\n\n # Now restore the original parameter values.\n if self._moving_average is not None:\n self._moving_average.restore()\n\n return val_loss, batches_this_epoch","def train(epoch, model, loss_fn, optimizer, dataloder,pair_generation_tnf):\n model.train()\n train_loss =0\n for batch_idx, batch in enumerate(tqdm(dataloder, desc='Epoch {}'.format(epoch))):\n optimizer.zero_grad()\n #batch = pair_generation_tnf(batch)\n \n theta = model(batch)\n print()\n loss= loss_fn(theta, batch['theta'])\n \n \n \n loss.backward()\n optimizer.step()\n train_loss += loss.data.cpu().numpy().item()\n train_loss /= len(dataloader)\n print('Train set: Average loss: {:.4f}'.format(train_loss))\n return train_loss","def svm_loss_forloop(W, X, y, reg, delta=1):\n\n ################################################################################\n # You implementation #\n # Use the ahove svm_loss_bias_forloop implementation as reference #\n ################################################################################\n\n # initialize the returned results\n loss = 0.0\n d_W = np.zeros(W.shape)\n\n # compute the loss and the gradient\n num_classes = W.shape[1]\n num_train = X.shape[0]\n\n for i in xrange(num_train):\n # compute the classification scores for a single image\n scores = X[i].dot(W)\n correct_class_score = scores[y[i]]\n for j in xrange(num_classes):\n # compute the loss for this image\n if j == y[i]:\n continue\n margin = scores[j] - correct_class_score + delta\n if margin > 0:\n loss += margin\n # compute the gradient for this image\n d_W[:, j] += X[i, :].T\n d_W[:, y[i]] -= X[i, :].T\n\n # Right now the loss is a sum over all training examples\n # We need it to be an average instead so we divide by num_train.\n loss /= num_train\n # Add regularization to the loss.\n #no reg on bias\n loss += 0.5 * reg * np.sum(W[:-1,:] * W[:-1,:])\n\n # Do the same for d_W and d_b\n d_W /= num_train\n d_W[:-1,:] += reg * W[:-1,:]\n\n\n return loss, d_W"],"string":"[\n \"def train(self) -> None:\\n for _ in range(self.epochs):\\n for x, y in zip(self.x_train, self.y_train):\\n\\n weights_gradient = [\\n None for weight in self.weights\\n ] # Initializing weight gradients for each layer which are going to be used to update the weights in the network.\\n\\n biases_gradient = [\\n None for bias in self.biases\\n ] # Initializing bias gradients for each layer which are going to be used to update the biases in the network.\\n\\n activation = np.expand_dims(x, axis=1)\\n activations = [\\n activation\\n ] # A list for storing all the activations when doing forward propagation\\n\\n values = (\\n []\\n ) # A list for storing weight * x + bias values without applying the activation function.\\n\\n for weight, bias in zip(self.weights, self.biases):\\n value = np.dot(weight, activation) + bias\\n values.append(value)\\n\\n activation = self.sigmoid(value)\\n activations.append(activation)\\n\\n \\\"\\\"\\\"\\n Calculating the error delta from output layer to be propagated backwards in the network. It is calculated\\n by taking the derivative of the loss function, which in our case is MSE, and multiply with derivate of\\n the sigmoid function applied on the value that entered the last layer of the network.\\n \\\"\\\"\\\"\\n\\n error_delta = (activations[-1] - y) * self.sigmoid_derivative(\\n values[-1]\\n )\\n\\n weights_gradient[-1] = np.dot(\\n error_delta, activations[-2].T\\n ) # Setting error delta multiplied with the second last layer activations as weight gradient for last layer.\\n\\n biases_gradient[-1] = error_delta # Setting error delta as bias gradient for last layer.\\n\\n \\\"\\\"\\\"\\n This for-loop does the same as the code from line 128 - 136, but for each layer in the network.\\n Thus, the error is propagated backwards in the network, and the gradients for each layer are set.\\n \\\"\\\"\\\"\\n for layer in range(2, self.total_layers):\\n error_delta = np.dot(\\n self.weights[-layer + 1].T, error_delta\\n ) * self.sigmoid_derivative(values[-layer])\\n\\n weights_gradient[-layer] = np.dot(\\n error_delta, activations[-layer - 1].T\\n )\\n\\n biases_gradient[-layer] = error_delta\\n\\n self.weights = [\\n weight - self.lr * weight_gradient\\n for weight, weight_gradient in zip(self.weights, weights_gradient)\\n ] # Updating the weights of the network by w_i - learning_rate * nabla w_i (w_i is the weight matrix at layer i, and nabla w_i is weight gradient.)\\n\\n self.biases = [\\n bias - self.lr * bias_gradient\\n for bias, bias_gradient in zip(self.biases, biases_gradient)\\n ] # Updating the biases of the network by b_i - learning_rate * nabla b_i (b_i is the bias vector at layer i, and nabla b_i is weight gradient.)\",\n \"def train_step(self):\\n\\n # Custom gradient\\n if self.model.computed_gradient:\\n outputs = self.model.compute_all(next(self.dataset_it))\\n gradients = outputs[\\\"gradients\\\"]\\n\\n # Compute\\n else:\\n with tf.GradientTape() as tape:\\n outputs = self.model.compute_all(next(self.dataset_it))\\n gradients = tape.gradient(outputs[\\\"loss\\\"], self.params)\\n\\n # Apply\\n self.optimizer.apply_gradients(zip(gradients, self.params))\\n\\n return outputs\",\n \"def grad_step(self, data, optimizer):\\n\\n running_loss = 0\\n \\n for i, batch in enumerate(data):\\n optimizer.zero_grad()\\n \\n # print(batch)\\n\\n nums, labels = batch\\n nums = nums.transpose(0,1)\\n # nums = nums.squeeze(1).reshape((-1, 784))\\n hidden = self.init_hidden(nums.size(1))\\n # print(nums.shape)\\n # # forward\\n out, _ = self(nums, hidden)\\n # loss = -self.obs.distr(out).log_prob(labels).mean()\\n # print(out.shape)\\n # print(labels.shape)\\n loss = nn.BCEWithLogitsLoss()(out.squeeze(), labels.squeeze())\\n # loss = -self.obs.distr(out).log_prob(labels).sum()\\n \\n # loss = -loglihood(self, nums, labels)\\n # foo = self(nums)[0]\\n # loss = nn.NLLLoss(reduction='sum')(foo, labels)\\n\\n # optimise\\n loss.backward()\\n optimizer.step()\\n \\n running_loss += loss.item()\\n \\n return running_loss/(i+1)\",\n \"def _optimization_closure(self, iteration, step):\\n aug = self._get_augmentation(iteration)\\n if iteration == self.num_iter_per_step - 1:\\n reg_noise_std = 0\\n aug = 0\\n else:\\n reg_noise_std = (1 / 1000.) * (iteration // 400)\\n # creates left_net_inputs and right_net_inputs by adding small noise\\n clean_nets_inputs = [clean_net_input[aug] + (clean_net_input[aug].clone().normal_() * reg_noise_std)\\n for clean_net_input in self.clean_nets_inputs]\\n watermark_net_input = self.watermark_net_input[aug] # + (self.watermark_net_input[aug].clone().normal_() * reg_noise_std)\\n mask_net_input = self.mask_net_input[aug]\\n # applies the nets\\n self.clean_nets_outputs = [clean_net(clean_net_input) for clean_net, clean_net_input\\n in zip(self.clean_nets, clean_nets_inputs)]\\n self.watermark_net_output = self.watermark_net(watermark_net_input)\\n self.mask_net_output = self.mask_net(mask_net_input)\\n self.total_loss = 0\\n self.blur = 0\\n\\n self.total_loss += sum(self.l1_loss(self.watermark_net_output * self.mask_net_output +\\n clean_net_output * (1 - self.mask_net_output), image_torch[aug])\\n for clean_net_output, image_torch in zip(self.clean_nets_outputs, self.images_torch))\\n self.total_loss.backward(retain_graph=True)\",\n \"def compute_gradients(self):\\n wlist = self._neural_net.weights()\\n blist = self._neural_net.biases()\\n\\n nmatrices = len(wlist)\\n weight_grad = []\\n bias_grad = []\\n\\n cost_function = self._cost_function\\n weight_der = WeightDerivative(neural_net=self._neural_net,\\n data_src=self._data_src,\\n cost_function=cost_function)\\n biase_der = BiasDerivative(neural_net=self._neural_net,\\n data_src=self._data_src,\\n cost_function=cost_function)\\n for layer in range(nmatrices):\\n weight_grad.append(np.zeros(wlist[layer].shape))\\n bias_grad.append(np.zeros(blist[layer].shape))\\n\\n rows, cols = wlist[layer].shape\\n for i in range(rows):\\n for j in range(cols):\\n loc = ParameterLocation(layer=layer, row=i, column=j)\\n weight_grad[layer][i][j] = weight_der.partial_derivative(loc)\\n\\n for row in range(rows):\\n loc = ParameterLocation(layer=layer, row=row, column=0)\\n bias_grad[layer][row] = biase_der.partial_derivative(loc)\\n\\n return weight_grad, bias_grad\",\n \"def update_grhs():\\n init_gradient()\\n costs_per_batch = []\\n for i in range(n_train_batches):\\n c = update_gradient_batch(i,*args)\\n costs_per_batch.append(c)\\n return numpy.mean(costs_per_batch,axis=0)\",\n \"def compute_gradients(self):\\n raise NotImplementedError()\",\n \"def compute_gradient(self, verbose):\\n from inversionson.helpers.autoinverter_helpers import IterationListener\\n\\n # Attempt to dispatch model smoothing right at the beginning.\\n # So there is no smoothing bottleneck when updates are not smoothed.\\n it_listen = IterationListener(\\n self.comm,\\n events=self.comm.project.events_in_iteration)\\n it_listen.listen()\\n\\n self.task_dict[\\\"forward_submitted\\\"] = True\\n self.task_dict[\\\"misfit_completed\\\"] = True\\n self.task_dict[\\\"gradient_completed\\\"] = True\\n self._update_task_file()\\n self.finish_task()\",\n \"def optimizer(self):\\n \\n # taken from https://github.com/germain-hug/Deep-RL-Keras/blob/master/DDPG/actor.py\\n # I believe this is a work around to get keras to learn **given a gradient**\\n # As opposed to bunch of x_train, y_trains?\\n \\n #Inputs\\n state_pl = self.model.input\\n action_grads_pl = K.placeholder(shape=(None,1)) \\n \\n #Find grad_(pars) mu(state)\\n mu_pl = self.model.output\\n pars = self.model.trainable_weights\\n pars_grad_mu = tf.gradients(mu_pl, pars, -action_grads_pl)\\n \\n #grads_and_pars = zip(pars_grad_mu, pars) #keras needs this form\\n #updates = tf.train.AdamOptimizer(self.lr).apply_gradients(grads_and_pars)\\n\\n # The gradients as defined above work on my mac, but not ubuntu.\\n # Below I am trying a workaround. I changed the keras source code \\n # To get this working. Specifically, I make the optimizer.get_updates()\\n # function accept custom gradients. It was easy to do.\\n \\n opt = Adam(self.lr)\\n loss = pars_grad_mu #placeholder, I won't use it\\n updates = opt.get_updates(loss = loss, params = pars, grads = pars_grad_mu)\\n\\n return K.function(inputs = [state_pl, action_grads_pl], outputs = [], updates = updates)\\n #return K.function(inputs = [state_pl, action_grads_pl], outputs = [updates])\",\n \"def compute_loss_and_gradients(self, X, y):\\n # TODO Compute loss and fill param gradients\\n # by running forward and backward passes through the model\",\n \"def eval_one_iteration(sess, model, cv_num_batch, iteration):\\n counter = 0\\n cv_g_mse_loss = 0.0\\n cv_g_l2_loss = 0.0\\n cv_g_loss = 0.0\\n for batch in range(int(cv_num_batch/FLAGS.num_gpu)):\\n g_mse_losses, g_l2_losses, \\\\\\n g_losses = sess.run([model.g_mse_losses,\\n model.g_l2_losses,\\n model.g_losses])\\n g_mse_loss = np.mean(g_mse_losses)\\n g_l2_loss = np.mean(g_l2_losses)\\n g_loss = np.mean(g_losses)\\n counter += FLAGS.num_gpu\\n cv_g_mse_loss += g_mse_loss\\n cv_g_l2_loss += g_l2_loss\\n cv_g_loss += g_loss\\n\\n _summaries = sess.run(model.summaries)\\n model.writer.add_summary(_summaries, iteration * cv_num_batch)\\n\\n cv_g_mse_loss = cv_g_mse_loss / counter * FLAGS.num_gpu\\n cv_g_l2_loss = cv_g_l2_loss / counter * FLAGS.num_gpu\\n cv_g_loss = cv_g_loss / counter * FLAGS.num_gpu\\n\\n return cv_g_mse_loss, cv_g_l2_loss, cv_g_loss\",\n \"def compute_loss_and_gradients(self, X, y):\\n # Before running forward and backward pass through the model,\\n # clear parameter gradients aggregated from the previous pass\\n # TODO Set parameter gradient to zeros\\n # Hint: using self.params() might be useful!\\n self.fulllayer1.W.grad = np.zeros_like(self.fulllayer1.W.grad)\\n self.fulllayer1.B.grad = np.zeros_like(self.fulllayer1.B.grad)\\n self.fulllayer2.W.grad = np.zeros_like(self.fulllayer2.W.grad)\\n self.fulllayer2.B.grad = np.zeros_like(self.fulllayer2.B.grad)\\n\\n\\n # TODO Compute loss and fill param gradients\\n # by running forward and backward passes through the model\\n res = self.fulllayer1.forward(X)\\n res2 = self.reglayer1.forward(res)\\n res3 = self.fulllayer2.forward(res2)\\n\\n loss, grad = softmax_with_cross_entropy(res3, y)\\n\\n back3 = self.fulllayer2.backward(grad)\\n back2 = self.reglayer1.backward(back3)\\n back = self.fulllayer1.backward(back2)\\n \\n # After that, implement l2 regularization on all params\\n # Hint: self.params() is useful again!\\n\\n for params in self.params().keys():\\n # print(params)\\n # print(self.params()[params].value)\\n loc_loss, loc_grad = l2_regularization(self.params()[params].value, self.reg)\\n loss += loc_loss\\n self.params()[params].grad += loc_grad\\n\\n return loss\",\n \"def compute_gradients(self, inputs, targets, hprev):\\n n = len(inputs)\\n loss = 0\\n\\n # Dictionaries for storing values during the forward pass\\n aa, xx, hh, oo, pp = {}, {}, {}, {}, {}\\n hh[-1] = np.copy(hprev)\\n\\n # Forward pass\\n for t in range(n):\\n xx[t] = np.zeros((self.vocab_len, 1))\\n xx[t][inputs[t]] = 1 # 1-hot-encoding\\n\\n aa[t], hh[t], oo[t], pp[t] = self.evaluate_classifier(hh[t-1], xx[t])\\n\\n loss += -np.log(pp[t][targets[t]][0]) # update the loss\\n\\n # Dictionary for storing the gradients\\n grads = {\\\"W\\\": np.zeros_like(self.W), \\\"U\\\": np.zeros_like(self.U),\\n \\\"V\\\": np.zeros_like(self.V), \\\"b\\\": np.zeros_like(self.b),\\n \\\"c\\\": np.zeros_like(self.c), \\\"o\\\": np.zeros_like(pp[0]),\\n \\\"h\\\": np.zeros_like(hh[0]), \\\"h_next\\\": np.zeros_like(hh[0]),\\n \\\"a\\\": np.zeros_like(aa[0])}\\n\\n # Backward pass\\n for t in reversed(range(n)):\\n grads[\\\"o\\\"] = np.copy(pp[t])\\n grads[\\\"o\\\"][targets[t]] -= 1\\n\\n grads[\\\"V\\\"] += grads[\\\"o\\\"]@hh[t].T\\n grads[\\\"c\\\"] += grads[\\\"o\\\"]\\n\\n grads[\\\"h\\\"] = np.matmul(self.V.T , grads[\\\"o\\\"] )+ grads[\\\"h_next\\\"]\\n grads[\\\"a\\\"] = np.multiply(grads[\\\"h\\\"], (1 - np.square(hh[t])))\\n\\n grads[\\\"U\\\"] += np.matmul(grads[\\\"a\\\"], xx[t].T)\\n grads[\\\"W\\\"] += np.matmul(grads[\\\"a\\\"], hh[t-1].T)\\n grads[\\\"b\\\"] += grads[\\\"a\\\"]\\n\\n grads[\\\"h_next\\\"] = np.matmul(self.W.T, grads[\\\"a\\\"])\\n\\n # Drop redundant gradients\\n grads = {k: grads[k] for k in grads if k not in [\\\"o\\\", \\\"h\\\", \\\"h_next\\\", \\\"a\\\"]}\\n\\n # Clip the gradients\\n for grad in grads:\\n grads[grad] = np.clip(grads[grad], -5, 5)\\n\\n # Update the hidden state sequence\\n h = hh[n-1]\\n\\n return grads, loss, h\",\n \"def _compute_gradients(self, config):\\n with tf.GradientTape() as tape:\\n all_loss = self._compute_loss(**config)\\n # Compute gradients wrt input image\\n total_loss = all_loss[0]\\n return tape.gradient(total_loss, config['init_image']), all_loss\",\n \"def compute_gradients_and_update(batch_y0, batch_yN):\\n with tf.GradientTape() as g:\\n pred_y = node_network(tb, batch_y0)\\n loss = tf.reduce_mean(tf.abs(pred_y - batch_yN))\\n grads = g.gradient(loss, var_list)\\n optimizer.apply_gradients(zip(grads, var_list))\\n return loss\",\n \"def _compute(self, global_step, params, batch_loss):\\n individual_losses = get_individual_losses(global_step)\\n individual_gradients = autograd_individual_gradients(\\n individual_losses, params, concat=True\\n )\\n hist, edges = self._compute_histogram(individual_gradients)\\n\\n return {\\\"hist\\\": hist.float(), \\\"edges\\\": edges}\",\n \"def calculate_per_sample_gradients(self):\\n if not self._forward_succesful:\\n raise RuntimeError(\\n \\\"An error occured during model training. Please ascertain that the\\\"\\n \\\" model.forward() method was called before calculating per sample gradients\\\"\\n )\\n\\n for model in self.models:\\n for param in model.parameters():\\n if param.requires_grad and param.grad is None:\\n raise RuntimeError(\\n \\\"No gradients have been calculated yet! This method should be\\\"\\n \\\" called after .backward() was called on the loss.\\\"\\n )\\n\\n model_grads = zip(\\n *[\\n [param.grad for param in m.parameters() if param.requires_grad]\\n for m in self.models\\n ]\\n ) # a list of length = self.replicas which holds lists of parameter gradients\\n\\n for param, gradient_source in zip(\\n [param for param in self.wrapped_model.parameters() if param.requires_grad],\\n model_grads,\\n ):\\n if param.requires_grad:\\n setattr(\\n param,\\n \\\"accumulated_gradients\\\",\\n torch.stack(gradient_source),\\n )\",\n \"def compute_loss(self, inputs):\\r\\n outputs = self.net.compute_outputs(inputs)\\r\\n loss_grad = self.net.compute_loss_grad(outputs - inputs)\\r\\n loss = np.sum((inputs - outputs) ** 2, axis=0).mean() / 2.0\\r\\n return loss, loss_grad\",\n \"def _batch_gradient_descent(self, X, y, lr, epochs):\\n\\n # Initialize the bias and weights.\\n _, n = X.shape\\n self.bias = 0\\n self.weights = np.random.normal(size=n)\\n\\n for i in range(epochs):\\n # Calculate and sum the gradient delta of each sample\\n grad_bias, grad_weights = self._get_gradient(X, y)\\n\\n # Show the gradient of each epoch.\\n grad = (grad_bias + grad_weights.mean()) / 2\\n print(\\\"Epochs %d gradient %.3f\\\" % (i + 1, grad), flush=True)\\n\\n # Update the bias and weight by gradient of current epoch\\n self.bias += lr * grad_bias\\n self.weights += lr * grad_weights\",\n \"def backward(self, i):\\n \\n #Compute gradient for w1, w2, w3\\n w1_grad = np.zeros((2, 3))\\n w2_grad = np.zeros((3, 3))\\n w3_grad = np.zeros((3, 1))\\n \\n \\n w3_backward_pass = np.zeros((1, 1))\\n w2_backward_pass = np.zeros((1, 3))\\n \\n #print(\\\"self.error shape\\\",self.error.shape)\\n #Compute w3 gradient\\n for i, w in enumerate(w3_grad): # 3 x 1 \\n w3_forward_pass = self.a2[0][i]\\n w3_backward_pass = self.error * der_sigmoid(self.y)\\n w3_grad[i] = w3_forward_pass * w3_backward_pass\\n \\n #Compute w2 gradient\\n for i, w_row in enumerate(w2_grad): # 3 x 3 \\n for j, w in enumerate(w2_grad[i]):# 1 x 3 \\n w2_forward_pass = self.a1[0][i]\\n w2_backward_pass[0][i] = der_sigmoid(self.a2[0][i]) * self.w3[i][0] * w3_backward_pass\\n w2_grad[i][j] = w2_forward_pass * w2_backward_pass[0][i]\\n \\n \\n #Compute w1 gradient \\n for i, w_rol in enumerate(w1_grad): # 2 x 3\\n for j, w in enumerate(w1_grad[i]): # 1 x 3\\n w1_forward_pass = self.input[0][i]\\n w1_backward_pass = der_sigmoid(self.a1[0][i]) * self.w2[i][j] * w2_backward_pass[0][i]\\n w1_grad[i][j] = w1_forward_pass * w1_backward_pass\\n \\n \\n #Update \\n for i, w in enumerate(w3_grad): \\n self.w3[i] -= self.learning_rate * w3_grad[i]\\n \\n for i, w_row in enumerate(w2_grad): # 3 x 3 \\n for j, w in enumerate(w2_grad[i]):# 1 x 3 \\n self.w2[i][j] -= self.learning_rate * w2_grad[i][j]\\n \\n for i, w_rol in enumerate(w1_grad): # 2 x 3\\n for j, w in enumerate(w1_grad[i]): # 1 x 3\\n self.w1[i][j] -= self.learning_rate * w1_grad[i][j]\\n \\n #print(\\\"w3 grad : \\\", w3_grad)\\n #print(\\\"w3.shape :\\\", self.w3.shape)\",\n \"def _optimize(self):\\n # Retrieve all trainable variables\\n train_variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES)\\n\\n # Compute the gradient (return a pair of variable and their respective gradient)\\n grads = self.optimizer.compute_gradients(loss=self.loss, var_list=train_variables)\\n self.train_dis = self.optimizer.apply_gradients(grads, global_step=self.global_step)\",\n \"def evaluate_loss(net, data_iter, loss): #@save\\n metric = d2l.Accumulator(2) # Sum of losses, no. of examples\\n for X, y in data_iter:\\n l = loss(net(X), y)\\n metric.add(d2l.reduce_sum(l), d2l.size(l))\\n return metric[0] / metric[1]\",\n \"def ComputeGradients(self, input_data: list, target_output_data: list):\\n delta = 1e-6\\n normal_cost = self.Cost(input_data, target_output_data)\\n\\n # Evaluate Gradient for Hidden Layer Biases\\n for i in range(self.hidden_layer_biases.shape[0]):\\n original_bias_value = self.hidden_layer_biases[i]\\n self.hidden_layer_biases[i] += delta\\n plusdelta_cost = self.Cost(input_data, target_output_data)\\n self.hidden_layer_biases[i] = original_bias_value\\n self.hidden_biases_gradient[i] = (plusdelta_cost - normal_cost) / delta\\n\\n # Evaluate Gradient for Output Layer Biases\\n for i in range(self.output_layer_biases.shape[0]):\\n original_bias_value = self.output_layer_biases[i]\\n self.output_layer_biases[i] += delta\\n plusdelta_cost = self.Cost(input_data, target_output_data)\\n self.output_layer_biases[i] = original_bias_value\\n self.output_biases_gradient[i] = (plusdelta_cost - normal_cost) / delta\\n\\n # Evaluate Gradient for Input Layer to Hidden Layer Weights\\n for i in range(self.input_to_hidden_weights.shape[0]):\\n for h in range(self.input_to_hidden_weights.shape[1]):\\n original_bias_value = self.input_to_hidden_weights[i, h]\\n self.input_to_hidden_weights[i, h] += delta\\n plusdelta_cost = self.Cost(input_data, target_output_data)\\n self.input_to_hidden_weights[i, h] = original_bias_value\\n self.input_to_hidden_weights_gradient[i, h] = (plusdelta_cost - normal_cost) / delta\\n\\n # Evaluate Gradient for Input Layer to Hidden Layer Weights\\n for h in range(self.hidden_to_output_weights.shape[0]):\\n for o in range(self.hidden_to_output_weights.shape[1]):\\n original_bias_value = self.hidden_to_output_weights[h, o]\\n self.hidden_to_output_weights[h, o] += delta\\n plusdelta_cost = self.Cost(input_data, target_output_data)\\n self.hidden_to_output_weights[h, o] = original_bias_value\\n self.hidden_to_output_weights_gradient[h, o] = (plusdelta_cost - normal_cost) / delta\",\n \"def compute_loss(self):\",\n \"def step(self):\\n for p, grad, v, square_grad_avg, delta_x_acc in self.params:\\n # Compute the running average of the squared gradients \\n square_grad_avg.mul_(self.rho)\\n square_grad_avg.addcmul_(grad, grad, value = 1 - self.rho)\\n # Compute the RMS of the previous squared gradients (eps to avoid numerical issues later for division)\\n std = (square_grad_avg.add_(self.eps)).sqrt_()\\n # Compute the accumulated update\\n delta_x = ((delta_x_acc.add_(self.eps)).sqrt_()) * grad / std\\n # Accumulate the updates\\n delta_x_acc.mul_(self.rho)\\n delta_x_acc.addcmul_(delta_x, delta_x, value = 1 - self.rho) \\n # Update the parameters\\n p.add_(delta_x, alpha = - self.lr)\",\n \"def update(self):\\n\\n # Update W (gradient should be up-to-date)\\n _projected_step(self.W, self.gW, 1.0 / self.lipschitz_W())\\n\\n # Update H (need to recompute residuals since W was updated).\\n self.cache_resids()\\n self.cache_gH()\\n _projected_step(self.H, self.gH, self.step_size)\\n\\n # Update residuals and gradient computation for W (for next iteration).\\n self.cache_resids()\\n self.cache_gW()\\n\\n # Return loss\\n return self.loss\",\n \"def _calc_gradients_chunked(self, batch_data, training_settings=None):\\n\\n if not is_chunkable(batch_data):\\n raise BatchNotChunkableException()\\n\\n auxiliary_results = BatchChunkingResults()\\n\\n loss = 0\\n # Will be set when we have the trainable variables\\n accumulated_grads = None\\n\\n batch_size = len(batch_data)\\n num_chunks = math.ceil(batch_size / self.batch_chunk_size)\\n for chunk_idx in range(num_chunks):\\n chunk_start = chunk_idx*self.batch_chunk_size\\n chunk_end = min((chunk_idx+1)*self.batch_chunk_size, batch_size)\\n\\n chunk_len = chunk_end-chunk_start\\n\\n chunk = batch_data[chunk_start:chunk_end]\\n\\n with tf.GradientTape() as tape:\\n results = self.evaluate_loss(chunk,\\n inference_mode=False,\\n evaluate_settings=training_settings)\\n\\n if 'loss' not in results:\\n raise LossNotAvailableException()\\n\\n if self.trainable_variables is None:\\n # We now have evaluated the model and the trainable variables should be available\\n self._retrieve_trainable_variables()\\n\\n if accumulated_grads is None:\\n if self.trainable_variables is None:\\n raise MLPugException(\\\"Unexpected state : trainable variables not found. Please file an issue.\\\")\\n\\n accumulated_grads = {}\\n for optimizer_name, tvs in self.trainable_variables.item():\\n accumulated_grads[optimizer_name] = [tf.zeros_like(tv) for tv in tvs]\\n\\n loss = results['loss']\\n aux_results = get_value_at('auxiliary_results', results, warn_on_failure=False)\\n\\n # loss is assumed to be the average over the sample loss for the chunk\\n # Divide through batch size to factor in that this loss is part of a larger batch.\\n last_chunk = chunk_idx == (num_chunks-1)\\n chunk_loss = chunk_len*loss/batch_size\\n chunk_gradients = self._back_propagate_from(chunk_loss, tape, last_chunk=last_chunk)\\n\\n loss += chunk_loss\\n\\n for optimizer_name, chunk_grads in chunk_gradients.items():\\n accu_grads = accumulated_grads[optimizer_name]\\n accumulated_grads[optimizer_name] = [(accu_grad+chunk_grad)\\n for accu_grad, chunk_grad in zip(accu_grads, chunk_grads)]\\n\\n auxiliary_results += [{\\n \\\"results\\\": aux_results,\\n \\\"num_samples\\\": chunk_len\\n }]\\n\\n return loss, auxiliary_results, accumulated_grads\",\n \"def step(self, closure=None):\\n self.steps += 1\\n loss = None\\n if closure is not None:\\n loss = closure()\\n\\n for group in self.param_groups:\\n k = group['k']\\n alpha_k = group['alpha_k']\\n for p in group['params']:\\n if p.grad is None:\\n continue\\n grad = p.grad.data\\n if grad.is_sparse:\\n raise RuntimeError('RMSprop does not support sparse gradients')\\n state = self.state[p]\\n\\n # State initialization\\n if len(state) == 0:\\n state['step'] = 0\\n state['square_avg'] = torch.zeros_like(p.data)\\n if group['momentum'] > 0:\\n state['momentum_buffer'] = torch.zeros_like(p.data)\\n if group['centered']:\\n state['grad_avg'] = torch.zeros_like(p.data)\\n\\n square_avg = state['square_avg']\\n alpha = group['alpha']\\n\\n state['step'] += 1\\n\\n if group['weight_decay'] != 0:\\n grad = grad.add(group['weight_decay'], p.data)\\n\\n square_avg.mul_(alpha).addcmul_(1 - alpha, grad, grad)\\n\\n if group['centered']:\\n grad_avg = state['grad_avg']\\n grad_avg.mul_(alpha).add_(1 - alpha, grad)\\n avg = square_avg.addcmul(-1, grad_avg, grad_avg).sqrt_().add_(group['eps'])\\n else:\\n avg = square_avg.sqrt().add_(group['eps'])\\n\\n if group['momentum'] > 0:\\n buf = state['momentum_buffer']\\n buf.mul_(group['momentum']).addcdiv_(grad, avg)\\n p.data.add_(-group['lr'], buf)\\n else:\\n p.data.addcdiv_(-group['lr'], grad, avg)\\n # ---- Lookahead Algorithm ----\\n if 'slow_weight' not in state:\\n state['slow_weight'] = p.data.clone().detach()\\n if self.steps % k == 0:\\n p.data = state['slow_weight'] + alpha_k * (p.data - state['slow_weight'])\\n state['slow_weight'] = p.data.clone().detach()\",\n \"def loss_and_grad(self, X, y):\\n\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n grad = np.zeros_like(self.W)\\n grad_tmp = np.zeros_like(self.W)\\n num_classes = self.W.shape[0] # C = num_classes\\n num_train = X.shape[0]\\n \\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Calculate the softmax loss and the gradient. Store the gradient\\n # as the variable grad.\\n # ================================================================ #\\n \\n exp_a = np.zeros((num_classes,num_train))\\n for i in np.arange(num_train):\\n \\n Loss = 0.0\\n\\n class_scores = np.dot(self.W,X[i,:].T) # calculating class scores (C x 1 vector)\\n class_scores -= np.max(class_scores) # considering the possible issue for numerical instability and account for it\\n\\n exp_a[:,i] = np.exp(class_scores) # turning class scores to probabilities (C x 1 vector), without normalization\\n\\n Loss -= np.log(exp_a[y[i],i]/np.sum(exp_a[:,i]))\\n \\n \\n #if i==0:\\n grada = np.zeros(X.shape[1])\\n \\n for j in range(num_classes):\\n if j != y[i]:\\n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) \\n else: \\n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) - X[i,:].T \\n\\n grad += grad_tmp\\n loss += Loss \\n \\n pass\\n\\n\\n loss /= num_train\\n grad /= num_train\\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n\\n return loss, grad\",\n \"def _gradient_descent(self, X, y, epochs, learning_rate, batch_size):\\n num_feats = X.shape[1]\\n num_samples = X.shape[0]\\n\\n y = y.reshape(num_samples, 1)\\n W = np.random.rand(num_feats, 1)\\n training_loss_epochs = []\\n\\n for ix in range(epochs):\\n shuffled_ix = (np.arange(0, len(X)))\\n np.random.shuffle(shuffled_ix)\\n X = X[shuffled_ix, :]\\n y = y[shuffled_ix, :]\\n\\n for batch_ix in np.arange(0, X.shape[0], batch_size):\\n dW = self._compute_gradient(W, X[batch_ix:batch_ix + batch_size], y[batch_ix:batch_ix + batch_size])\\n W -= learning_rate * dW\\n\\n if ix % 10 == 0:\\n y_pred = np.dot(X, W)\\n training_loss = self.mse(y, y_pred)\\n print('epoch {0} : training loss {1}'.format(ix, training_loss))\\n training_loss_epochs.append(training_loss[0])\\n\\n self.weights = W\\n self.training_loss = training_loss_epochs\\n return None\",\n \"def step(self, closure=None):\\n loss = None\\n if closure is not None:\\n loss = closure()\\n\\n for group in self.param_groups:\\n\\n for p in group['params']:\\n if p.grad is None:\\n grad = p.grad\\n continue\\n else:\\n grad =p.grad\\n\\n # s = self.spikes.popitem()\\n #grad = jnp.matmul(p.grad, s.data)\\n\\n\\n state = self.state[p]\\n\\n # State initialization\\n if len(state) == 0:\\n state['step'] = 0\\n # Exponential moving average of gradient values\\n state['exp_avg'] = jnp.zeros(grad.shape)\\n # Exponential moving average of squared gradient values\\n state['exp_avg_sq'] = jnp.zeros(grad.shape)\\n\\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\\n beta1, beta2 = group['betas']\\n\\n state['step'] += 1\\n\\n if group['weight_decay'] != 0:\\n grad += group['weight_decay'] * p.data\\n\\n # Decay the first and second moment running average coefficient\\n exp_avg = exp_avg * beta1 + (1 - beta1) * grad\\n exp_avg_sq = exp_avg_sq * beta2 + (1 - beta2) * grad * grad\\n denom = jnp.sqrt(exp_avg_sq) + group['eps']\\n\\n bias_correction1 = 1 - beta1 ** state['step']\\n bias_correction2 = 1 - beta2 ** state['step']\\n step_size = group['lr'] * jmath.sqrt(bias_correction2) / bias_correction1\\n\\n p.data += -step_size * exp_avg / denom\\n\\n return loss\",\n \"def gradient_descent(y, tx, initial_w, max_iters, gamma, compute_loss, compute_grad, verbose=False):\\n \\n w = initial_w.copy()\\n loss = 0\\n\\n for n_iter in range(max_iters):\\n grad = compute_grad(y, tx, w)\\n loss = compute_loss(y, tx, w)\\n\\n w -= gamma * grad\\n\\n if verbose:\\n print(f\\\"Gradient Descent ({n_iter}/{max_iters - 1}): loss={loss}, w={w}\\\")\\n \\n return w, loss\",\n \"def step(self, closure=None):\\n loss = None\\n if closure is not None:\\n loss = closure()\\n\\n for group in self.param_groups:\\n for p in group['params']:\\n if p.grad is None:\\n continue\\n grad = p.grad.data\\n if grad.dtype in {torch.float16, torch.bfloat16}:\\n grad = grad.float()\\n if grad.is_sparse:\\n raise RuntimeError('Adafactor does not support sparse gradients.')\\n\\n state = self.state[p]\\n grad_shape = grad.shape\\n\\n factored, use_first_moment = self._get_options(group, grad_shape)\\n # State Initialization\\n if len(state) == 0:\\n state['step'] = 0\\n\\n if use_first_moment:\\n # Exponential moving average of gradient values\\n state['exp_avg'] = torch.zeros_like(grad)\\n if factored:\\n state['exp_avg_sq_row'] = torch.zeros(grad_shape[:-1]).to(grad)\\n state['exp_avg_sq_col'] = torch.zeros(grad_shape[:-2] + grad_shape[-1:]).to(grad)\\n else:\\n state['exp_avg_sq'] = torch.zeros_like(grad)\\n\\n state['RMS'] = 0\\n else:\\n if use_first_moment:\\n state['exp_avg'] = state['exp_avg'].to(grad)\\n if factored:\\n state['exp_avg_sq_row'] = state['exp_avg_sq_row'].to(grad)\\n state['exp_avg_sq_col'] = state['exp_avg_sq_col'].to(grad)\\n else:\\n state['exp_avg_sq'] = state['exp_avg_sq'].to(grad)\\n\\n p_data_fp32 = p.data\\n if p.data.dtype in {torch.float16, torch.bfloat16}:\\n p_data_fp32 = p_data_fp32.float()\\n\\n state['step'] += 1\\n state['RMS'] = self._rms(p_data_fp32)\\n group['lr'] = self._get_lr(group, state)\\n\\n beta2t = 1.0 - math.pow(state['step'], group['decay_rate'])\\n update = (grad**2) + group['eps'][0]\\n if factored:\\n exp_avg_sq_row = state['exp_avg_sq_row']\\n exp_avg_sq_col = state['exp_avg_sq_col']\\n\\n exp_avg_sq_row.mul_(beta2t).add_(1.0 - beta2t, update.mean(dim=-1))\\n exp_avg_sq_col.mul_(beta2t).add_(1.0 - beta2t, update.mean(dim=-2))\\n\\n # Approximation of exponential moving average of square of gradient\\n update = self._approx_sq_grad(exp_avg_sq_row, exp_avg_sq_col)\\n update.mul_(grad)\\n else:\\n exp_avg_sq = state['exp_avg_sq']\\n\\n exp_avg_sq.mul_(beta2t).add_(1.0 - beta2t, update)\\n update = exp_avg_sq.rsqrt().mul_(grad)\\n\\n update.div_(\\n (self._rms(update) / group['clip_threshold']).clamp_(min=1.0)\\n )\\n update.mul_(group['lr'])\\n\\n if use_first_moment:\\n exp_avg = state['exp_avg']\\n exp_avg.mul_(group['beta1']).add_(1 - group['beta1'], update)\\n update = exp_avg\\n\\n if group['weight_decay'] != 0:\\n p_data_fp32.add_(-group['weight_decay'] * group['lr'], p_data_fp32)\\n\\n p_data_fp32.add_(-update)\\n\\n if p.data.dtype in {torch.float16, torch.bfloat16}:\\n p.data.copy_(p_data_fp32)\\n\\n return loss\",\n \"def step(self, closure=None):\\n loss = None\\n if closure is not None:\\n loss = closure()\\n\\n for group in self.param_groups:\\n for p in group['params']:\\n if p.grad is None:\\n continue\\n grad = p.grad.data\\n state = self.state[p]\\n\\n # State initialization\\n if len(state) == 0:\\n state['step'] = 0\\n # Exponential moving average of gradient values\\n state['exp_avg'] = grad.new().resize_as_(grad).zero_()\\n # Exponential moving average of squared gradient values\\n state['exp_avg_sq'] = grad.new().resize_as_(grad).zero_()\\n\\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\\n beta1, beta2 = group['betas']\\n\\n state['step'] += 1\\n\\n if group['l1_weight_decay'] != 0:\\n grad = grad.add(group['l1_weight_decay'], torch.sign(p.data))\\n if group['l2_weight_decay'] != 0:\\n grad = grad.add(group['l2_weight_decay'], p.data)\\n\\n # Decay the first and second moment running average coefficient\\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\\n\\n denom = exp_avg_sq.sqrt().add_(group['eps'])\\n\\n bias_correction1 = 1 - beta1 ** state['step']\\n bias_correction2 = 1 - beta2 ** state['step']\\n step_size = group['lr'] * math.sqrt(bias_correction2) / bias_correction1\\n\\n p.data.addcdiv_(-step_size, exp_avg, denom)\\n\\n # custom clamping\\n if group['lower_bound'] is not None:\\n p.data.clamp_(min=group['lower_bound'])\\n if group['upper_bound'] is not None:\\n p.data.clamp_(max=group['upper_bound'])\\n\\n return loss\",\n \"def gradient_descent(self, alpha, batch, weight_gradients, bias_gradients):\\n self._dwg = [0] * 8\\n self._dbg = [0] * 8\\n self._cost = 0\\n\\n workers = []\\n for i in range(batch[0].shape[0]-1):\\n p = Process(target=self.mp_gd, args=(batch, weight_gradients, bias_gradients, i))\\n workers.append(p)\\n p.start()\\n\\n\\n for p in workers:\\n self._cost += self._q.get()\\n\\n self._dwg = list(map(add, self._dwg, self._dwgq.get()))\\n self._dbg = list(map(add, self._dbg, self._dbgq.get()))\\n\\n p.join()\\n\\n for j in range(len(self._dwg)):\\n weight_gradients[j] = weight_gradients[j] - alpha * self._dwg[j]\\n bias_gradients[j] = bias_gradients[j] - alpha * self._dbg[j]\\n cost = self._cost/len(batch)\\n self._cost_history.append(cost)\\n\\n return weight_gradients, bias_gradients\",\n \"def step(self, closure=None):\\n self.steps += 1\\n loss = None\\n if closure is not None:\\n loss = closure()\\n\\n for group in self.param_groups:\\n k = group['k']\\n alpha = group['alpha']\\n for p in group['params']:\\n if p.grad is None:\\n continue\\n\\n # Perform stepweight decay\\n p.data.mul_(1 - group['lr'] * group['weight_decay'])\\n\\n # Perform optimization step\\n grad = p.grad.data\\n if grad.is_sparse:\\n raise RuntimeError('Adam does not support sparse gradients, please consider SparseAdam instead')\\n amsgrad = group['amsgrad']\\n\\n state = self.state[p]\\n\\n # State initialization\\n if len(state) == 0:\\n state['step'] = 0\\n # Exponential moving average of gradient values\\n state['exp_avg'] = torch.zeros_like(p.data)\\n # Exponential moving average of squared gradient values\\n state['exp_avg_sq'] = torch.zeros_like(p.data)\\n if amsgrad:\\n # Maintains max of all exp. moving avg. of sq. grad. values\\n state['max_exp_avg_sq'] = torch.zeros_like(p.data)\\n\\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\\n if amsgrad:\\n max_exp_avg_sq = state['max_exp_avg_sq']\\n beta1, beta2 = group['betas']\\n\\n state['step'] += 1\\n bias_correction1 = 1 - beta1 ** state['step']\\n bias_correction2 = 1 - beta2 ** state['step']\\n\\n # Decay the first and second moment running average coefficient\\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\\n if amsgrad:\\n # Maintains the maximum of all 2nd moment running avg. till now\\n torch.max(max_exp_avg_sq, exp_avg_sq, out=max_exp_avg_sq)\\n # Use the max. for normalizing running avg. of gradient\\n denom = (max_exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps'])\\n else:\\n denom = (exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps'])\\n\\n step_size = group['lr'] / bias_correction1\\n\\n p.data.addcdiv_(-step_size, exp_avg, denom)\\n # ---- Lookahead Algorithm ----\\n if 'slow_weight' not in state:\\n state['slow_weight'] = p.data.clone().detach()\\n if self.steps % k == 0:\\n p.data = state['slow_weight'] + alpha * (p.data - state['slow_weight'])\\n state['slow_weight'] = p.data.clone().detach()\\n state['exp_avg'].fill_(0)\\n state['exp_avg_sq'].fill_(0)\\n\\n return loss\",\n \"def train(self, inputs, targets, eta, niterations):\\n ndata = np.shape(inputs)[0] # number of data samples\\n # adding the bias\\n inputs = np.concatenate((inputs, -np.ones((ndata, 1))), axis=1)\\n\\n # numpy array to store the update weights\\n updatew1 = np.zeros((np.shape(self.weights1)))\\n updatew2 = np.zeros((np.shape(self.weights2)))\\n updatew3 = np.zeros((np.shape(self.weights3)))\\n\\n self.Errors = []\\n for n in range(niterations):\\n\\n #############################################################################\\n # TODO: implement the training phase of one iteration which consists of two phases:\\n # the forward phase and the backward phase. you will implement the forward phase in \\n # the self.forwardPass method and return the outputs to self.outputs. Then compute \\n # the error (hints: similar to what we did in the lab). Next is to implement the \\n # backward phase where you will compute the derivative of the layers and update \\n # their weights. \\n #############################################################################\\n\\n # forward phase \\n self.outputs = self.forwardPass(inputs)\\n\\n # Error using the sum-of-squares error function\\n error = 0.5 * np.sum((self.outputs - targets) ** 2)\\n\\n if np.mod(n, 100) == 0:\\n self.Errors.append(error)\\n print(\\\"Iteration: \\\", n, \\\" Error: \\\", error)\\n\\n # backward phase \\n # Compute the derivative of the output layer. NOTE: you will need to compute the derivative of \\n # the softmax function. Hints: equation 4.55 in the book. \\n # deltao = (self.outputs - targets) * (self.outputs - self.outputs ** 2)\\n deltao = (self.outputs - targets) * self.outputs * (1 - self.outputs)\\n\\n # compute the derivative of the second hidden layer\\n\\n deltah2 = self.beta * self.hidden2 * (1.0 - self.hidden2) * (np.dot(deltao, np.transpose(self.weights3)))\\n\\n\\n # compute the derivative of the first hidden layer\\n deltah1 = self.beta * self.hidden1 * (1.0 - self.hidden1) * (np.dot(deltah2[:, :-1], np.transpose(self.weights2)))\\n\\n # update the weights of the three layers: self.weights1, self.weights2 and self.weights3\\n # here you can update the weights as we did in the week 4 lab (using gradient descent) \\n # but you can also add the momentum\\n\\n updatew1 = eta * np.dot(np.transpose(inputs), deltah1[:, :-1]) + self.momentum * updatew1\\n updatew2 = eta * np.dot(np.transpose(self.hidden1), deltah2[:, :-1]) + self.momentum * updatew2\\n updatew3 = eta * np.dot(np.transpose(self.hidden2), deltao) + self.momentum * updatew3\\n\\n self.weights1 -= updatew1\\n self.weights2 -= updatew2\\n self.weights3 -= updatew3\\n\\n #############################################################################\\n # END of YOUR CODE \\n #############################################################################\",\n \"def step(self, closure=None):\\n loss = None\\n if closure is not None:\\n loss = closure()\\n for group in self.param_groups:\\n for p in group['params']:\\n if p.grad is None:\\n continue\\n grad = p.grad.data\\n if grad.is_sparse:\\n raise RuntimeError('Adam does not support sparse gradients, please consider SparseAdam instead')\\n\\n state = self.state[p]\\n\\n # State initialization\\n if len(state) == 0:\\n state['step'] = 0\\n # Exponential moving average of gradient values\\n state['next_m'] = torch.zeros_like(p.data)\\n # Exponential moving average of squared gradient values\\n state['next_v'] = torch.zeros_like(p.data)\\n\\n next_m, next_v = state['next_m'], state['next_v']\\n beta1, beta2 = group['b1'], group['b2']\\n\\n # Add grad clipping\\n if group['max_grad_norm'] > 0:\\n clip_grad_norm_(p, group['max_grad_norm'])\\n\\n # Decay the first and second moment running average coefficient\\n # In-place operations to update the averages at the same time\\n next_m.mul_(beta1).add_(1 - beta1, grad)\\n next_v.mul_(beta2).addcmul_(1 - beta2, grad, grad)\\n update = next_m / (next_v.sqrt() + group['e'])\\n\\n # Just adding the square of the weights to the loss function is *not*\\n # the correct way of using L2 regularization/weight decay with Adam,\\n # since that will interact with the m and v parameters in strange ways.\\n #\\n # Instead we want to decay the weights in a manner that doesn't interact\\n # with the m/v parameters. This is equivalent to adding the square\\n # of the weights to the loss with plain (non-momentum) SGD.\\n if group['weight_decay'] > 0.0:\\n update += group['weight_decay'] * p.data\\n\\n if group['t_total'] != -1:\\n schedule_fct = SCHEDULES[group['schedule']]\\n lr_scheduled = group['lr'] * schedule_fct(state['step']/group['t_total'], group['warmup'])\\n else:\\n lr_scheduled = group['lr']\\n\\n update_with_lr = lr_scheduled * update\\n p.data.add_(-update_with_lr)\\n\\n state['step'] += 1\\n\\n return loss\",\n \"def compute_gradients(self, *args, **kwargs):\\n gradients = self._optimizer.compute_gradients(*args, **kwargs)\\n if size() > 1 and not self._enable_async:\\n grads, vars = zip(*gradients)\\n avg_grads = self._push_pull_grads(grads)\\n return list(zip(avg_grads, vars))\\n else:\\n return gradients\",\n \"def backpropagate(self, error, learning_rate):\\n #assert isinstance(error, np.ndarray)\\n #assert isinstance(self._prev_layer._outputs, np.ndarray)\\n #assert isinstance(self._outputs, np.ndarray) \\n\\n # Compute deltas. \\n deltas = np.dot(error, self._activation_function.derivative_given_y(self._outputs))\\n \\n # Compute gradient.\\n synapse = np.dot(np.dot(error, self._prev_layer._outputs), learning_rate)\\n \\n # Adjust weights.\\n self._weights = np.add(self._weights, synapse)\\n \\n # Adjust bias weights.\\n if self._use_bias:\\n self._bias = np.add(self._bias, synapse)\\n \\n return deltas\",\n \"def batchGD(self, x, y, epochs):\\n print(\\\"Training using batch gradient descent\\\")\\n epoch = 0\\n #output training progress ten times in run\\n outputChunk = int ( epochs / 10 )\\n\\n while epoch <= epochs:\\n\\n #output progress? \\n if epoch % outputChunk is 0:\\n J = self.costFunction(x,y)\\n print(\\\"Epoch=\\\", epoch, \\\"J=\\\", J)\\n\\n #get analytic gradients \\n partial_J_w_ih, partial_J_w_ho, partial_J_b_h, partial_J_b_o = \\\\\\n self.deriv_costFunction( x, y )\\n #take a GD step\\n #To-do - implement variable learning rate\\n self.w_ih -= partial_J_w_ih\\n self.w_ho -= partial_J_w_ho\\n self.b_h -= partial_J_b_h\\n self.b_o -= partial_J_b_o\\n \\n epoch += 1\",\n \"def epoch_iter(model, data, optimizer, epoch):\\n total_bpd = 0.0\\n for i, (inputs, _targets) in enumerate(data):\\n log_px = model.forward(inputs)\\n loss = -log_px.mean()\\n\\n if model.training:\\n # update gradients\\n model.zero_grad()\\n loss.backward()\\n optimizer.step()\\n\\n # per dimension\\n bpd = loss.item() / (x_dim * np.log(2))\\n print({'epoch': epoch, 'i':i, 'loss':loss.item(), 'bpd':bpd})\\n total_bpd += bpd\\n\\n avg_bpd = total_bpd / len(data)\\n return avg_bpd\",\n \"def step(self, closure=None):\\n loss = None\\n if closure is not None:\\n loss = closure()\\n\\n for group in self.param_groups:\\n for p in group['params']:\\n if p.grad is None:\\n continue\\n grad = p.grad.data\\n if grad.is_sparse:\\n raise RuntimeError('NAdam does not support sparse gradients')\\n\\n state = self.state[p]\\n\\n # State initialization\\n if len(state) == 0:\\n state['step'] = 0\\n # Exponential moving average of gradient values\\n state['exp_avg'] = torch.zeros_like(p.data)\\n # Exponential moving average of squared gradient values\\n state['exp_avg_sq'] = torch.zeros_like(p.data)\\n # \\\\mu^{t}\\n state['m_schedule'] = 1.\\n\\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\\n\\n beta1, beta2 = group['betas']\\n\\n schedule_decay = group['schedule_decay']\\n\\n state['step'] += 1\\n\\n if group['weight_decay'] != 0:\\n grad = grad.add(group['weight_decay'], p.data)\\n\\n # calculate the momentum cache \\\\mu^{t} and \\\\mu^{t+1}\\n momentum_cache_t = beta1 * (\\n 1. - 0.5 * (pow(0.96, state['step'] * schedule_decay)))\\n momentum_cache_t_1 = beta1 * (\\n 1. - 0.5 * (pow(0.96, (state['step'] + 1) * schedule_decay)))\\n m_schedule_new = state['m_schedule'] * momentum_cache_t\\n m_schedule_next = state['m_schedule'] * momentum_cache_t * momentum_cache_t_1\\n\\n # Decay the first and second moment running average coefficient\\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\\n\\n g_prime = torch.div(grad, 1. - m_schedule_new)\\n exp_avg_prime = torch.div(exp_avg, 1. - m_schedule_next)\\n exp_avg_sq_prime = torch.div(exp_avg_sq, 1. - pow(beta2, state['step']))\\n\\n exp_avg_bar = torch.add((1. - momentum_cache_t) * g_prime,\\n momentum_cache_t_1, exp_avg_prime)\\n\\n denom = exp_avg_sq_prime.sqrt().add_(group['eps'])\\n\\n step_size = group['lr']\\n\\n p.data.addcdiv_(-step_size, exp_avg_bar, denom)\\n\\n return loss\",\n \"def gradients(self):\\n error = self.error()\\n input_ = self.get_cache('input')\\n error_stacked = np.reshape(error, (error.shape[0], 1, error.shape[1]))\\n input_stacked = np.reshape(input_, (input_.shape[0], input_.shape[1], 1))\\n return {\\n 'bias': np.sum(error, axis=0),\\n 'weight': np.sum(np.matmul(input_stacked, error_stacked), axis=0)\\n }\",\n \"def step(self, closure=None):\\n loss = None\\n if closure is not None:\\n loss = closure()\\n\\n for group in self.param_groups:\\n for p in group['params']:\\n if p.grad is None:\\n continue\\n grad = p.grad.data\\n if grad.is_sparse:\\n raise RuntimeError('Adam does not support sparse gradients, please consider SparseAdam instead')\\n amsgrad = group['amsgrad']\\n\\n state = self.state[p]\\n\\n # State initialization\\n if len(state) == 0:\\n state['step'] = 0\\n # Exponential moving average of gradient values\\n state['exp_avg'] = torch.zeros_like(p.data)\\n # Exponential moving average of squared gradient values\\n state['exp_avg_sq'] = torch.zeros_like(p.data)\\n if amsgrad:\\n # Maintains max of all exp. moving avg. of sq. grad. values\\n state['max_exp_avg_sq'] = torch.zeros_like(p.data)\\n\\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\\n if amsgrad:\\n max_exp_avg_sq = state['max_exp_avg_sq']\\n beta1, beta2 = group['betas']\\n\\n state['step'] += 1\\n\\n if group['weight_decay'] != 0:\\n grad.add_(group['weight_decay'], p.data)\\n\\n # Decay the first and second moment running average coefficient\\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\\n if amsgrad:\\n # Maintains the maximum of all 2nd moment running avg. till now\\n torch.max(max_exp_avg_sq, exp_avg_sq, out=max_exp_avg_sq)\\n # Use the max. for normalizing running avg. of gradient\\n denom = max_exp_avg_sq.sqrt().add_(group['eps'])\\n else:\\n denom = exp_avg_sq.sqrt().add_(group['eps'])\\n\\n bias_correction1 = 1 - beta1 ** state['step']\\n bias_correction2 = 1 - beta2 ** state['step']\\n step_size = -group['lr'] * math.sqrt(bias_correction2) / bias_correction1 * exp_avg / denom\\n\\n if group[\\\"hyperboloid\\\"]:\\n self.expm(p.data, step_size)\\n else:\\n p.data.add_(step_size)\\n\\n return loss\",\n \"def step(self, closure=None):\\n loss = None\\n if closure is not None:\\n loss = closure()\\n\\n for group in self.param_groups:\\n for p in group['params']:\\n if p.grad is None:\\n continue\\n grad = p.grad.data\\n if grad.is_sparse:\\n raise RuntimeError('Adam does not support sparse gradients, please consider SparseAdam instead')\\n\\n state = self.state[p]\\n\\n # State initialization\\n if len(state) == 0:\\n state['step'] = 0\\n # Exponential moving average of gradient values\\n state['next_m'] = torch.zeros_like(p.data)\\n # Exponential moving average of squared gradient values\\n state['next_v'] = torch.zeros_like(p.data)\\n\\n next_m, next_v = state['next_m'], state['next_v']\\n beta1, beta2 = group['b1'], group['b2']\\n\\n # Add grad clipping\\n if group['max_grad_norm'] > 0:\\n clip_grad_norm_(p, group['max_grad_norm'])\\n\\n # Decay the first and second moment running average coefficient\\n # In-place operations to update the averages at the same time\\n next_m.mul_(beta1).add_(1 - beta1, grad)\\n next_v.mul_(beta2).addcmul_(1 - beta2, grad, grad)\\n update = next_m / (next_v.sqrt() + group['e'])\\n\\n # Just adding the square of the weights to the loss function is *not*\\n # the correct way of using L2 regularization/weight decay with Adam,\\n # since that will interact with the m and v parameters in strange ways.\\n #\\n # Instead we want to decay the weights in a manner that doesn't interact\\n # with the m/v parameters. This is equivalent to adding the square\\n # of the weights to the loss with plain (non-momentum) SGD.\\n if group['weight_decay'] > 0.0:\\n update += group['weight_decay'] * p.data\\n\\n if group['t_total'] != -1:\\n schedule_fct = SCHEDULES[group['schedule']]\\n lr_scheduled = group['lr'] * schedule_fct(state['step']/group['t_total'], group['warmup'])\\n else:\\n lr_scheduled = group['lr']\\n\\n update_with_lr = lr_scheduled * update\\n p.data.add_(-update_with_lr)\\n\\n state['step'] += 1\\n\\n # step_size = lr_scheduled * math.sqrt(bias_correction2) / bias_correction1\\n # No bias correction\\n # bias_correction1 = 1 - beta1 ** state['step']\\n # bias_correction2 = 1 - beta2 ** state['step']\\n\\n return loss\",\n \"def train_one_iteration(sess, model, tr_num_batch, iteration):\\n counter = 0\\n duration = 0.0\\n tr_g_mse_loss = 0.0\\n tr_g_l2_loss = 0.0\\n tr_g_loss = 0.0\\n for batch in range(int(tr_num_batch/FLAGS.num_gpu)):\\n _g_opt, \\\\\\n g_mse_losses, g_l2_losses, \\\\\\n g_losses = sess.run([model.g_opt,\\n model.g_mse_losses,\\n model.g_l2_losses,\\n model.g_losses])\\n g_mse_loss = np.mean(g_mse_losses)\\n g_l2_loss = np.mean(g_l2_losses)\\n g_loss = np.mean(g_losses)\\n if model.g_disturb_weights:\\n sess.run(model.g_disturb)\\n counter += FLAGS.num_gpu\\n tr_g_mse_loss += g_mse_loss\\n tr_g_l2_loss += g_l2_loss\\n tr_g_loss += g_loss\\n\\n _summaries = sess.run(model.summaries)\\n model.writer.add_summary(_summaries, iteration * tr_num_batch)\\n\\n tr_g_mse_loss = tr_g_mse_loss / counter * FLAGS.num_gpu\\n tr_g_l2_loss = tr_g_l2_loss / counter * FLAGS.num_gpu\\n tr_g_loss = tr_g_loss / counter * FLAGS.num_gpu\\n\\n return tr_g_mse_loss, tr_g_l2_loss, tr_g_loss\",\n \"def step(self, batch_id, closure):\\n loss = closure()\\n dist_sq_acum = 0.0\\n grad_dist_sq_acum = 0.0\\n\\n #print(\\\"step loss: \\\", loss)\\n\\n for group in self.param_groups:\\n momentum = group['momentum']\\n weight_decay = group['weight_decay']\\n learning_rate = group['lr']\\n\\n for p in group['params']:\\n if p.grad is None:\\n continue\\n gk = p.grad.data\\n\\n param_state = self.state[p]\\n\\n gktbl = param_state['gktbl']\\n gavg = param_state['gavg'].type_as(p.data)\\n tilde_x = param_state['tilde_x']\\n\\n if momentum != 0:\\n buf = param_state['momentum_buffer']\\n\\n #########\\n\\n if self.vr_from_epoch is None or self.epoch < self.vr_from_epoch:\\n vr_gradient = gk.clone() # Just do sgd steps\\n else:\\n gi = gktbl[batch_id, :].cuda()\\n\\n vr_gradient = gk.clone().sub_(gi - gavg)\\n\\n # Some diagnostics\\n iterate_diff = p.data - tilde_x\\n #pdb.set_trace()\\n dist_sq_acum += iterate_diff.norm()**2 #torch.dot(iterate_diff,iterate_diff)\\n grad_diff = gi - gk\\n grad_dist_sq_acum += grad_diff.norm()**2 #torch.dot(grad_diff,grad_diff)\\n\\n if weight_decay != 0:\\n vr_gradient.add_(weight_decay, p.data)\\n\\n if momentum != 0:\\n dampening = 0.0\\n vr_gradient = buf.mul_(momentum).add_(1 - dampening, vr_gradient)\\n\\n # Take step.\\n p.data.add_(-learning_rate, vr_gradient)\\n\\n # Update running iterate mean:\\n param_state['running_x'].mul_(self.running_interp).add_(1-self.running_interp, p.data)\\n\\n # track number of minibatches seen\\n self.batches_processed += 1\\n\\n dist = math.sqrt(dist_sq_acum)\\n grad_dist = math.sqrt(grad_dist_sq_acum)\\n\\n self.inrun_iterate_distances.append(dist)\\n self.inrun_grad_distances.append(grad_dist)\\n\\n return loss\",\n \"def build_loss(self):\\n import tensorflow as tf\\n\\n y_1d = [tf.reduce_sum(tf.multiply(self.variables[\\\"y\\\"][i], self.variables[\\\"y_action\\\"][i]), axis=1) for i in range(len(self.variables[\\\"y\\\"]))]\\n loss = np.sum([tf.nn.l2_loss(y_1d[i] - self.variables[\\\"y_true\\\"]) for i in range(len(y_1d))])\\n\\n l1_reg = 0\\n l2_reg = 0\\n\\n keys = sorted(self.variables.keys())\\n keys = [key for key in keys if critere_keys(key) and \\\"W\\\" in key]\\n for key in keys:\\n l1_reg += tf.reduce_sum(tf.abs(self.variables[key]))\\n l2_reg += tf.nn.l2_loss(self.variables[key])\\n\\n self.loss = loss + self.alpha_reg * l1_reg + self.beta_reg * l2_reg\\n\\n self.train_step = tf.train.RMSPropOptimizer(self.decay_learning_rate,\\n decay=0.99, momentum=0., centered=True).minimize(self.loss, global_step=self.global_step)\",\n \"def gradient_descent(self, x, y):\\n # Initialize weights vector\\n self.weights = np.zeros(len(x[0]))\\n\\n # Storing number of training example in a variable \\n n = len(x)\\n\\n # Initiate variables to keep track of the current and smallest loss recorded\\n lowest_loss = sys.float_info.max\\n current_loss = sys.float_info.max\\n\\n # Initiate variables to keep track of step sizes\\n norm = sys.float_info.max\\n smallest_norm = sys.float_info.max\\n\\n # Initiate list variable that stores all previous weights\\n prev_weights = []\\n\\n # Initiate list that stores all the errors. \\n errors = []\\n \\n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\\n k_loss_iteration = 1\\n\\n # Learning loop\\n for i in range(self.max_iter):\\n\\n # Append current weights\\n prev_weights.append(np.array(self.weights))\\n \\n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\\n\\n # Compute the error of the Cost Function and store it in a list\\n current_loss = self.cost(x,y)\\n\\n if len(errors) > 1 and current_loss > errors[-1]:\\n k_loss_iteration += 1\\n else: \\n k_loss_iteration = 1\\n\\n errors.append(current_loss)\\n \\n # Track smallest loss\\n if current_loss < lowest_loss:\\n lowest_loss = current_loss\\n\\n # Compute the L2 Norm of the difference between current weights and previous weights\\n norm = np.linalg.norm(self.weights - prev_weights[-1])\\n\\n # Track smallest step size and set it as error threshold\\n if norm < smallest_norm:\\n smallest_norm = norm\\n\\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\\n if self.error_threshold != None and norm < self.error_threshold:\\n print(\\\"Converged after {} iterations!\\\".format(i))\\n break\\n\\n # stop if error hasn't gone down in k iterations\\n if k_loss_iteration >= 10:\\n print(k_loss_iteration + \\\" iterations of loss not decreasing on {}th itertion.\\\".format(i))\\n break\\n\\n # Log final weights\\n print(\\\"Final norm: \\\" + str(norm) + \\\"\\\\nSmallest step size recorded: \\\" + str(smallest_norm) + \\\"\\\\nFinal error: \\\" + str(current_loss) + \\\"\\\\nLowest error recorded: \\\" + str(lowest_loss) + \\\"\\\\nNumber of epochs: \\\" + str(len(errors)) + \\\"\\\\nFinal weights: \\\" + str(self.weights))\",\n \"def step(self, closure: Optional[Callable[[], float]] = None):\\n loss = None\\n if closure is not None:\\n loss = closure()\\n\\n for group in self.param_groups:\\n for p in group['params']:\\n if p.grad is None:\\n continue\\n grad = p.grad.data\\n if grad.is_sparse:\\n raise RuntimeError(\\n \\\"Adam does not support sparse gradients, please \\\"\\n \\\"consider SparseAdam instead\\\")\\n\\n state = self.state[p]\\n # State initialization\\n if len(state) == 0:\\n # Exponential moving average of gradient values\\n state['next_m'] = torch.zeros_like(p.data)\\n # Exponential moving average of squared gradient values\\n state['next_v'] = torch.zeros_like(p.data)\\n\\n next_m, next_v = state['next_m'], state['next_v']\\n beta1, beta2 = group['betas']\\n\\n # Add grad clipping\\n if group['max_grad_norm'] > 0:\\n clip_grad_norm_(p, group['max_grad_norm'])\\n\\n # Decay the first and second moment running average coefficient\\n # In-place operations to update the averages at the same time\\n next_m.mul_(beta1).add_(1 - beta1, grad)\\n next_v.mul_(beta2).addcmul_(1 - beta2, grad, grad)\\n update = next_m / (next_v.sqrt() + group['eps'])\\n\\n # Just adding the square of the weights to the loss function is\\n # *not* # the correct way of using L2 regularization or weight\\n # decay with Adam, since that will interact with the m and v\\n # parameters in strange ways.\\n #\\n # Instead we want to decay the weights in a manner that doesn't\\n # interact with the m/v parameters. This is equivalent to adding\\n # the square of the weights to the loss with plain\\n # (non-momentum) SGD.\\n if group['weight_decay'] > 0.0:\\n update += group['weight_decay'] * p.data\\n\\n lr = group['lr']\\n update_with_lr = lr * update\\n p.data.add_(-update_with_lr)\\n\\n # No bias correction\\n # bias_correction1 = 1 - beta1 ** state['step']\\n # bias_correction2 = 1 - beta2 ** state['step']\\n\\n return loss\",\n \"def _train(self, loss):\\n config = ConfigParser.ConfigParser()\\n config.read(\\\"config/conf.cfg\\\")\\n\\n learning_rate =float(config.get(\\\"Common Params\\\", \\\"learning_rate\\\"))\\n moment = float(config.get(\\\"Common Params\\\", \\\"moment\\\"))\\n opt = tf.train.AdamOptimizer()\\n train_step = opt.minimize(loss)\\n return train_step\\n\\n # grads = opt.compute_gradients(self.total_loss)\\n\\n # apply_gradient_op = opt.apply_gradients(grads, global_step=self.global_step)\\n\\n #return apply_gradient_op\",\n \"def run_gradient_descent(data,theta,alpha,num_iters):\\n population = data[:,0]\\n prices = data[:,1]\\n x = ones(shape=(len(population),2)) #add ones for theta0 \\n x[:,1] = population\\n x = transpose(x)\\n error_history = zeros(shape=(num_iters,1))\\n \\n for i in range(num_iters):\\n predictions = theta.dot(x)\\n errors_x1 = (predictions - prices) * x[0,:]\\n errors_x2 = (predictions - prices) * x[1,:]\\n theta[0][0] = theta[0][0] - alpha*(1.0/len(population))*errors_x1.sum()\\n theta[0][1] = theta[0][1] - alpha*(1.0/len(population))*errors_x2.sum()\\n error_history[i,0] = calculate_cost(theta,data)\\n \\n return theta, error_history\",\n \"def optimize(self,gradients):\\n\\n for k in range(self.size):\\n delta_weight = self.learningRate * gradients[k]\\n full_change = delta_weight + self.momentum*self.last_change[k]\\n self.weights[k] -= full_change\\n self.last_change[k] = 1*gradients[k] #copy gradient mat\",\n \"def step(self, closure=None):\\n loss = None\\n if closure is not None:\\n loss = closure()\\n\\n for group in self.param_groups:\\n for p in group['params']:\\n if p.grad is None:\\n continue\\n grad = p.grad.data\\n if grad.is_sparse:\\n raise RuntimeError('Adam does not support sparse gradients, please consider SparseAdam instead')\\n amsgrad = group['amsgrad']\\n\\n # state = self.state[p]\\n\\n # # State initialization\\n # if len(state) == 0:\\n # state['step'] = 0\\n # # Exponential moving average of gradient values\\n # state['exp_avg'] = torch.zeros_like(p.data)\\n # # Exponential moving average of squared gradient values\\n # state['exp_avg_sq'] = torch.zeros_like(p.data)\\n # if amsgrad:\\n # # Maintains max of all exp. moving avg. of sq. grad. values\\n # state['max_exp_avg_sq'] = torch.zeros_like(p.data)\\n\\n # exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\\n # if amsgrad:\\n # max_exp_avg_sq = state['max_exp_avg_sq']\\n # beta1, beta2 = group['betas']\\n\\n # state['step'] += 1\\n # bias_correction1 = 1 - beta1 ** state['step']\\n # bias_correction2 = 1 - beta2 ** state['step']\\n\\n # if group['weight_decay'] != 0:\\n # grad.add_(group['weight_decay'], p.data)\\n\\n # # Decay the first and second moment running average coefficient\\n # exp_avg.mul_(beta1).add_(1 - beta1, grad)\\n # exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\\n # if amsgrad:\\n # # Maintains the maximum of all 2nd moment running avg. till now\\n # torch.max(max_exp_avg_sq, exp_avg_sq, out=max_exp_avg_sq)\\n # # Use the max. for normalizing running avg. of gradient\\n # denom = (max_exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps'])\\n # else:\\n # denom = (exp_avg_sq.sqrt() / math.sqrt(bias_correction2)).add_(group['eps'])\\n\\n # step_size = group['lr'] / bias_correction1\\n\\n # p.data.addcdiv_(-step_size, exp_avg, denom)\\n\\n return loss\",\n \"def training_iteration(self, num_epochs):\\n # Initialize metrics container\\n metrics = {'train_loss': [],\\n 'train_accuracy': [],\\n 'val_loss': [],\\n 'val_accuracy': []}\\n\\n # Create pytorch's train data_loader\\n train_loader = self.dm.get_train_set()\\n # train num_epochs times\\n for epoch in range(num_epochs):\\n print(\\\"Epoch: {} of {}\\\".format(epoch + 1, num_epochs))\\n train_loss = 0.0\\n\\n with tqdm(range(len(train_loader))) as t:\\n train_losses = []\\n train_accuracies = []\\n for i, data in enumerate(train_loader, 0):\\n # transfer tensors to selected device\\n train_inputs, _ = data[0].to(self.device), data[1].to(self.device)\\n\\n # zero the parameter gradients\\n self.optimizer.zero_grad()\\n\\n # forward pass\\n code, x_hat, cosim, z_error, gamma = self.model(train_inputs)\\n phi, mu, cov_mat = self.model.compute_params(z_error, gamma)\\n energy_result, pen_cov_mat = self.model.estimate_sample_energy(z_error, phi, mu, cov_mat,\\n device=self.device)\\n\\n loss = self.model.compute_loss(train_inputs, x_hat, energy_result, pen_cov_mat)\\n\\n # # Use autograd to compute the backward pass.\\n loss.backward()\\n\\n # updates the weights using gradient descent\\n self.optimizer.step()\\n\\n # Save losses for plotting purposes\\n train_losses.append(loss.item())\\n # train_accuracies.append(accuracy(train_outputs, train_labels))\\n\\n # print metrics along progress bar\\n train_loss += loss.item()\\n t.set_postfix(loss='{:05.3f}'.format(train_loss / (i + 1)))\\n t.update()\\n\\n # evaluate the model on validation data after each epoch\\n mean_train_loss = np.mean(train_losses)\\n metrics['train_loss'].append(mean_train_loss)\\n # TODO\\n # Add other metrics to plot\\n\\n return metrics\",\n \"def epoch_diagnostics(self, train_loss, train_err, test_loss, test_err):\\n m = self.nbatches\\n logging.info(\\\"Epoch diagnostics computation\\\")\\n\\n layernum = 0\\n layer_gradient_norm_sqs = []\\n gavg_norm_acum = 0.0\\n gavg_acum = []\\n for group in self.param_groups:\\n for p in group['params']:\\n\\n layer_gradient_norm_sqs.append([])\\n gavg = self.state[p]['gavg'].cpu()\\n gavg_acum.append(gavg.numpy())\\n gavg_norm_acum += gavg.norm()**2 #torch.dot(gavg, gavg)\\n layernum += 1\\n\\n gradient_norm_sqs = []\\n vr_step_variance = []\\n cos_acums = []\\n variances = []\\n\\n for batch_id in range(m):\\n norm_acum = 0.0\\n ginorm_acum = 0.0\\n vr_acum = 0.0\\n layernum = 0\\n cos_acum = 0.0\\n var_acum = 0.0\\n for group in self.param_groups:\\n for p in group['params']:\\n param_state = self.state[p]\\n\\n gktbl = param_state['gktbl']\\n gavg = param_state['gavg'].type_as(p.data).cpu()\\n\\n gi = gktbl[batch_id, :]\\n var_norm_sq = (gi-gavg).norm()**2 #torch.dot(gi-gavg, gi-gavg)\\n norm_acum += var_norm_sq\\n ginorm_acum += gi.norm()**2 #torch.dot(gi, gi)\\n layer_gradient_norm_sqs[layernum].append(var_norm_sq)\\n\\n gktbl_old = param_state['gktbl_old']\\n gavg_old = param_state['gavg_old'].type_as(p.data).cpu()\\n gi_old = gktbl_old[batch_id, :]\\n #pdb.set_trace()\\n vr_step = gi - gi_old + gavg_old\\n vr_acum += (vr_step - gavg).norm()**2 #torch.dot(vr_step - gavg, vr_step - gavg)\\n cos_acum += torch.sum(gavg*gi)\\n\\n var_acum += (gi - gavg).norm()**2\\n\\n layernum += 1\\n gradient_norm_sqs.append(norm_acum)\\n vr_step_variance.append(vr_acum)\\n cosim = cos_acum/math.sqrt(ginorm_acum*gavg_norm_acum)\\n #pdb.set_trace()\\n cos_acums.append(cosim)\\n variances.append(var_acum)\\n\\n variance = sum(variances)/len(variances)\\n\\n print(\\\"mean cosine: {}\\\".format(sum(cos_acums)/len(cos_acums)))\\n\\n #pdb.set_trace()\\n\\n with open('stats/{}fastdiagnostics_epoch{}.pkl'.format(self.test_name, self.epoch), 'wb') as output:\\n pickle.dump({\\n 'train_loss': train_loss,\\n 'train_err': train_err,\\n 'test_loss': test_loss,\\n 'test_err': test_err,\\n 'epoch': self.epoch,\\n #'layer_gradient_norm_sqs': layer_gradient_norm_sqs,\\n #'gradient_norm_sqs': gradient_norm_sqs,\\n #'vr_step_variance': vr_step_variance,\\n #'cosine_distances': cos_acums,\\n #'variances': variances,\\n 'variance': variance,\\n #'gavg_norm': gavg_norm_acum,\\n #'gavg': gavg_acum,\\n #'iterate_distances': self.inrun_iterate_distances,\\n #'grad_distances': self.inrun_grad_distances,\\n }, output)\\n print(\\\"Epoch diagnostics saved\\\")\\n #pdb.set_trace()\\n\\n self.inrun_iterate_distances = []\\n self.inrun_grad_distances = []\",\n \"def _compute_func_grad(self, w):\\n W = w.reshape((self.X.shape[1], self.Y.shape[1]))\\n self.nll_, self.grad_ = calculate_gradient(self.X, self.Y, W, self.prior, self.weighted,0)\",\n \"def train(model, train_iter, dev_iter):\\n \\n optim = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE)\\n\\n loss = []\\n\\n for eidx in range(1, NUM_EPOCHS + 1):\\n model.train()\\n\\n epoch_loss = 0\\n epoch_items = 0\\n # Start training\\n for batch_idx, batch in enumerate(train_iter):\\n\\n # Clear the gradients\\n optim.zero_grad()\\n en, de = prepare_batch_strategy_3(batch)\\n # loss will be a vector of size (batch_size, ) with losses per every sample\\n y_pred = model.forward(en.float(), de.float()).view(-1)\\n loss = F.mse_loss(y_pred.double(), batch.score.double(), reduction='none')\\n \\n # Backprop the average loss and update parameters\\n loss.sum().backward()\\n optim.step()\\n\\n # sum the loss for reporting, along with the denominator\\n epoch_loss += loss.detach().sum()\\n epoch_items += loss.numel()\\n\\n if batch_idx % 10 == 0:\\n # Print progress\\n loss_per_token = epoch_loss / epoch_items\\n print('[Epoch {:<3}] loss: {:6.2f}'.format(eidx, loss_per_token))\\n\\n\\n print('\\\\n[Epoch {:<3}] ended with train_loss: {:6.2f}'.format(eidx, loss_per_token))\\n \\n # Evaluate on valid set\\n model.eval()\\n check_pearson_value(model, dev_iter)\\n torch.save(model, './models/model_strategy_3_epoch_{}'.format(eidx))\",\n \"def gradient_descent(x_data, starting_b, starting_w, learning_rate, num_iterations):\\n\\n b = starting_b\\n w = starting_w\\n\\n for i in range(num_iterations):\\n b, w = step_gradient(b, w, x_data, learning_rate)\\n b_history.append(b) # stores bias approximations to plot\\n w_history.append(w) # stores weight approximations to plot\\n err = error(b, w, x_data)\\n if err <= .6: # if the error is acceptable exit iterations loop\\n print('error = % f' % err)\\n break\\n return [b, w]\",\n \"def compute_gradients(self, loss, params):\\n # check asserts\\n assert isinstance(params, list), '\\\"params\\\" should be a list type.'\\n \\n # compute gradients\\n grads = T.grad(loss, params)\\n if self.clipnorm is not None:\\n grad_l2norm = T.sqrt(sum([T.sum(T.square(gg)) for gg in grads]))\\n grads = [T.switch(grad_l2norm > self.clipnorm, g * self.clipnorm / (grad_l2norm + 1e-7), g) for g in grads]\\n if self.clipvalue is not None:\\n grads = [T.clip(g, -self.clipvalue, self.clipvalue) for g in grads]\\n return grads\",\n \"def loss(self, X_batch, y_batch, learning_rate=1e-3, one_vs_all_index=-1, reg=True):\\n #########################################################################\\n # TODO: #\\n # calculate the loss and the derivative #\\n #########################################################################\\n loss = 0\\n for i in range(X_batch.shape[0]):\\n if one_vs_all_index == -1:\\n loss += -(y_batch[i] * (np.dot(self.w.T, X_batch[i]))) + np.log(\\n 1 + np.exp(np.dot(self.w.T, X_batch[i])))\\n else:\\n if reg:\\n reg = (learning_rate / 2 * X_batch.shape[0]) * np.sum(np.power(self.ws[one_vs_all_index], 2))\\n loss += -(y_batch[i] * (np.dot(self.ws[one_vs_all_index].T, X_batch[i]))) + np.log(\\n 1 + np.exp(np.dot(self.ws[one_vs_all_index].T, X_batch[i]))) + reg\\n else:\\n loss += -(y_batch[i] * (np.dot(self.ws[one_vs_all_index].T, X_batch[i]))) + np.log(\\n 1 + np.exp(np.dot(self.ws[one_vs_all_index].T, X_batch[i])))\\n gradients = np.zeros(X_batch.shape[1])\\n if one_vs_all_index == -1:\\n dot = np.dot(X_batch, self.w)\\n else:\\n dot = np.dot(X_batch, self.ws[one_vs_all_index])\\n logists = sigmod(dot)\\n diff = y_batch - logists\\n for index in range(X_batch.shape[0]):\\n if one_vs_all_index != -1:\\n if reg:\\n dot = np.dot(X_batch[index], diff[index])\\n gradients[1:] += dot[1:] + (learning_rate / X_batch.shape[0]) * self.ws[one_vs_all_index][1:]\\n gradients[0] += dot[0]\\n else:\\n gradients += np.dot(X_batch[index], diff[index])\\n else:\\n gradients += np.dot(X_batch[index], diff[index])\\n\\n return loss, gradients / X_batch.shape[0] # 取均值免得步长过大直接nan\\n #########################################################################\\n # END OF YOUR CODE #\\n #########################################################################\",\n \"def backpropagation(self):\\n\\n print \\\"backpropagation in Convlayer\\\"\\n\\n if self.__nextLayer.__class__.__name__ is 'FCLayer':\\n WF = self.__nextLayer.numberOfNeuronsInLayer\\n dNext = np.reshape(self.__nextLayer.getDeltas(), (1, 1, 1, WF))\\n else:\\n dNext = self.__nextLayer.getDeltas()\\n\\n self.deltas = np.zeros(self.outputValues.shape)\\n\\n # Compute Deltas\\n if self.__nextLayer.__class__.__name__ is 'FCLayer':\\n for n in range(self.outputValues.shape[0]):\\n for nf in range(self.numberOfFilters):\\n for h in range(self.outputValues.shape[2]):\\n for w in range(self.outputValues.shape[3]):\\n deltas_i = self.activationFunctionDerivative(self.outputValues)[n, nf, h, w] * dNext[\\n :, :, :, nf]\\n self.deltas[n, nf, h, w] += deltas_i\\n\\n elif self.__previousLayer is None:\\n for n in range(self.outputValues.shape[0]):\\n deltas_i = self.activationFunctionDerivative(self.outputValues)[n] * dNext\\n self.deltas[n] += deltas_i[0]\\n\\n else:\\n for n in range(self.outputValues.shape[0]):\\n deltas_i = self.activationFunctionDerivative(self.outputValues)[n] * dNext\\n self.deltas[n] += deltas_i[n]\\n\\n # print \\\"shape of delta is \\\" + str(self.deltas.shape)\\n\\n if self.spaceConv is True:\\n self.deltas = np.transpose(self.deltas, (3, 1, 2, 0))\\n else:\\n pass\\n\\n # Compute delta Biases\\n deltaBiases = (np.sum(self.deltas, axis=(0, 2, 3)))\\n assert deltaBiases.shape == self.bias.shape\\n\\n # Compute delta Kernels\\n\\n deltaKernel = np.zeros(self.weights.shape)\\n\\n for ninp in range(self.inputShape[0]):\\n for nf in range(self.numberOfFilters):\\n flippedDelta = self.flipArray(self.deltas[ninp, nf, :, :]) # Flips Kernel for the convolution\\n for cin in range(self.inputShape[1]):\\n nh = 0\\n for h in np.arange(0, self.inputs.shape[2] - flippedDelta.shape[0] + 1, self.stride[0]):\\n nw = 0\\n for w in np.arange(0, self.inputs.shape[3] - flippedDelta.shape[1] + 1, self.stride[1]):\\n activationMap = self.inputs[ninp, cin,\\n h:h + flippedDelta.shape[0],\\n w:w + flippedDelta.shape[1]] # Input Map used for the convolution\\n deltaKernel[nf, nh, nw] = np.sum(activationMap * flippedDelta) # Convolution\\n nw += 1\\n nh += 1\\n\\n if self.spaceConv is True:\\n self.deltas = np.transpose(self.deltas, (3, 1, 2, 0))\\n else:\\n pass\\n\\n self.deltaWeights = deltaKernel\\n self.deltaBiases = deltaBiases\\n\\n if self.__previousLayer is None:\\n return self.deltas, self.deltaWeights, self.deltaBiases\\n else:\\n return self.__previousLayer.backpropagation()\",\n \"def train(X, Y=[], hidden_layer_sizes=[], error_deriv=\\\"default\\\", n_outputs=\\\"default\\\", n_loops=100,\\n eta=.1, output_transformation=\\\"default\\\", error_function=\\\"default\\\"):\\n \\n # the default error function will be the squared error function, whose derivative is just\\n # the output minus the target values\\n def square_error_deriv(output, x, y):\\n return output - y\\n if error_deriv == \\\"default\\\":\\n error_deriv = square_error_deriv\\n \\n # the default error function is the squared error \\n def square_error(Y, Y_hat):\\n return np.linalg.norm(Y_hat - Y, ord='fro') / (Y.shape[0]*Y.shape[1])\\n if error_function == \\\"default\\\":\\n error_function = square_error\\n\\n # the default output transformatoin is none\\n def none_transformation(output):\\n return output\\n if output_transformation == \\\"default\\\":\\n output_transformation = none_transformation\\n\\n if len(Y) > 0:\\n if n_outputs == \\\"default\\\":\\n n_outputs = Y.shape[0]\\n else:\\n # setting one y value for the rest of the training\\n y = \\\"None\\\"\\n layer_sizes = [X.shape[0]] + hidden_layer_sizes + [n_outputs]\\n weights = construct_network(layer_sizes)\\n \\n errorvec = np.empty((n_loops))\\n for loop in np.arange(n_loops):\\n delta_W = []\\n # initiazlizing delta Ws\\n for weight_mat_idx in range(len(weights)):\\n delta_W.append(np.zeros((weights[weight_mat_idx].shape)))\\n \\n for data_idx in np.arange(n_data):\\n x = X[:, data_idx]\\n y = Y[:, data_idx]\\n layer_activations, output = forward_propagate(x, weights)\\n \\n errors = [error_deriv(output, x, y)]\\n # go from the output layer towards the input layer and calculate error values\\n for idx in np.arange(1, len(weights)):\\n # prepend the newest error layer to the errors list:\\n errors = [-np.multiply(deriv_sigmoid(layer_activations[-idx-1]), \\\\\\n weights[-idx].T @ errors[-idx])] \\\\\\n + errors\\n errors[-idx-1] = errors[-idx-1][:-1,0] # removing bias\\n # go from input layer towards output layer and calculate weight updates\\n for idx in range(len(weights)):\\n delta_W[idx] -= errors[idx] @ layer_activations[idx].T\\n delta_W[idx][:,:-1] = np.mean(layer_activations[idx])\\n \\n # update all weight matrices\\n for idx in range(len(weights)): \\n weights[idx] += eta/n_data * delta_W[idx]\\n \\n Y_hat = classify(X, weights, output_transformation)\\n errorvec[loop] = error_function(Y, Y_hat)\\n return weights, errorvec\",\n \"def compute(self, step: int) -> None:\\n if self.episode >= self._wp.training_delay:\\n # Transfer network parameters if episode 0 or 100 * n.\\n if self.episode % 100 == 0:\\n self._policy.transfer_parameters()\\n\\n self.get_logger().info('Computing gradients...')\\n if self.atype in ['REINFORCE', 'A2C']:\\n batch = self._db.sample_batch(step, 'all')\\n self._policy.train(batch, step)\\n\\n else:\\n batch = self._db.sample_batch(self._wp.batch_size)\\n self._policy.train(batch, self._wp.batch_size)\\n\\n else:\\n self.get_logger().warn(\\n 'Skipping computing gradients till episode ' +\\n f'{self._wp.training_delay}!'\\n )\\n\\n # Move to `push` section\\n self.flag.shift_to_push_cycle()\",\n \"def step(self, closure=None):\\n loss = None\\n if closure is not None:\\n with torch.enable_grad():\\n loss = closure()\\n\\n for group in self.param_groups:\\n beta1, beta2 = group['betas']\\n base_lr = group['lr']\\n max_norm = group['max_norm']\\n fixed_norm = group['fixed_norm']\\n zero_mean = group['zero_mean']\\n normalizing_grad_by_norm = group['normalizing_grad_by_norm']\\n eps = group['eps']\\n weight_decay = group['weight_decay']\\n l2_regularization = group['l2_regularization']\\n bias_correction1 = 1\\n for p in group['params']:\\n if p.grad is None:\\n continue\\n pmax_norm, pfixed_norm, pzero_mean = _get_opt_args(\\n p, max_norm, fixed_norm, zero_mean)\\n lr = get_opt_arg(p, 'lr', base_lr)\\n lr_scale = get_opt_arg(p, 'lr_scale', 1)\\n state = self.state[p]\\n state['step'] += 1\\n bias_correction2 = 1 - beta2**state['step']\\n grad = p.grad\\n pweight_decay = get_opt_arg(p, 'weight_decay', weight_decay)\\n pl2_regularization = get_opt_arg(p, 'l2_regularization',\\n l2_regularization)\\n if pl2_regularization != 0:\\n grad = grad.add(p, alpha=pl2_regularization)\\n if beta1 > 0:\\n bias_correction1 = 1 - beta1**state['step']\\n exp_avg = state['exp_avg']\\n exp_avg.lerp_(grad, 1 - beta1)\\n else:\\n exp_avg = grad\\n if normalizing_grad_by_norm:\\n sq = _norm(grad)**2\\n else:\\n sq = grad**2\\n state['exp_avg_sq'].lerp_(sq, 1 - beta2)\\n denom = state['exp_avg_sq'].sqrt().add_(eps)\\n if pweight_decay > 0:\\n p.mul_(1 - lr_scale * lr * pweight_decay)\\n # the exponential moving average of exp_avg and exp_avg_sq are not\\n # unbiased estimate of the mean. Correct them using bas_correction1\\n # and bias_correct2 as suggest by the original Adam paper.\\n step_size = lr_scale * lr * math.sqrt(\\n bias_correction2) / bias_correction1\\n # p <- p - step_size * exp_avg / denom\\n p.addcdiv_(exp_avg, denom, value=-step_size)\\n _normalize(p, pmax_norm, pfixed_norm, pzero_mean)\\n\\n return loss\",\n \"def step(self, closure=None):\\n loss = None\\n if closure is not None:\\n loss = closure()\\n\\n for group in self.param_groups:\\n lr = group[\\\"lr\\\"]\\n weight_decay = group[\\\"weight_decay\\\"]\\n momentum = group['momentum']\\n dampening = group[\\\"dampening\\\"]\\n nesterov = group[\\\"nesterov\\\"]\\n maximize = group[\\\"maximize\\\"]\\n\\n for p in group[\\\"params\\\"]:\\n if p.grad is None:\\n continue\\n\\n grad = p.grad\\n\\n if grad.is_sparse:\\n raise RuntimeError(\\\"SGD does not support sparse gradients.\\\")\\n\\n grad = grad if not maximize else -grad\\n\\n if weight_decay != 0:\\n grad = grad.add(p, alpha=weight_decay)\\n\\n if momentum != 0:\\n buf = self.state[p][\\\"momentum_buffer\\\"]\\n\\n buf.mul_(momentum).add_(grad, alpha=1.0 - dampening)\\n\\n if nesterov:\\n grad.add_(buf, alpha=momentum)\\n else:\\n grad = buf\\n\\n p.add_(-lr * grad)\\n\\n return loss\",\n \"def step(self, closure: Optional[Callable[[], float]] = None) -> Optional[float]:\\n loss = None\\n if closure is not None:\\n with torch.enable_grad():\\n loss = closure()\\n\\n for group in self.param_groups:\\n for p in group[\\\"params\\\"]:\\n if p.grad is None:\\n continue\\n grad = p.grad\\n if grad.is_sparse:\\n raise RuntimeError(\\\"RMSpropTF does not support sparse gradients\\\")\\n state = self.state[p]\\n\\n # State initialization\\n if len(state) == 0:\\n state[\\\"step\\\"] = 0\\n # PyTorch initialized to zeros here\\n state[\\\"square_avg\\\"] = torch.ones_like(p, memory_format=torch.preserve_format)\\n if group[\\\"momentum\\\"] > 0:\\n state[\\\"momentum_buffer\\\"] = torch.zeros_like(p, memory_format=torch.preserve_format)\\n if group[\\\"centered\\\"]:\\n state[\\\"grad_avg\\\"] = torch.zeros_like(p, memory_format=torch.preserve_format)\\n\\n square_avg = state[\\\"square_avg\\\"]\\n alpha = group[\\\"alpha\\\"]\\n\\n state[\\\"step\\\"] += 1\\n\\n if group[\\\"weight_decay\\\"] != 0:\\n grad = grad.add(p, alpha=group[\\\"weight_decay\\\"])\\n\\n square_avg.mul_(alpha).addcmul_(grad, grad, value=1 - alpha)\\n\\n if group[\\\"centered\\\"]:\\n grad_avg = state[\\\"grad_avg\\\"]\\n grad_avg.mul_(alpha).add_(grad, alpha=1 - alpha)\\n # PyTorch added epsilon after square root\\n # avg = square_avg.addcmul(grad_avg, grad_avg, value=-1).sqrt_().add_(group['eps'])\\n avg = square_avg.addcmul(grad_avg, grad_avg, value=-1).add_(group[\\\"eps\\\"]).sqrt_()\\n else:\\n # PyTorch added epsilon after square root\\n # avg = square_avg.sqrt().add_(group['eps'])\\n avg = square_avg.add(group[\\\"eps\\\"]).sqrt_()\\n\\n if group[\\\"momentum\\\"] > 0:\\n buf = state[\\\"momentum_buffer\\\"]\\n buf.mul_(group[\\\"momentum\\\"]).addcdiv_(grad, avg)\\n p.add_(buf, alpha=-group[\\\"lr\\\"])\\n else:\\n p.addcdiv_(grad, avg, value=-group[\\\"lr\\\"])\\n\\n return loss\",\n \"def step(self, closure=None):\\n loss = None\\n if closure is not None:\\n with torch.enable_grad():\\n loss = closure()\\n\\n for group in self.param_groups:\\n momentum = group['momentum']\\n beta = group['beta']\\n eps = group['eps']\\n clip_threshold = group['clip_threshold']\\n for p in group['params']:\\n if p is None:\\n continue\\n grad = p.grad\\n\\n state = self.state[p]\\n shape = grad.shape\\n rank = len(shape)\\n\\n # State initialization\\n if len(state) == 0:\\n state['step'] = 0\\n state['momentum_buffer'] = 0.\\n _add_initial_accumulators(state, grad)\\n\\n if grad.is_sparse:\\n # the update is non-linear so indices must be unique\\n grad.coalesce()\\n grad_indices = grad._indices()\\n grad_values = grad._values()\\n\\n # Transform update_values into sparse tensor\\n def make_sparse(values):\\n constructor = grad.new\\n if grad_indices.dim() == 0 or values.dim() == 0:\\n return constructor().resize_as_(grad)\\n return constructor(grad_indices, values, grad.size())\\n\\n acc = state[_key(0)]\\n update_values = _compute_sparse_update(beta, acc, grad_values, grad_indices)\\n self._update_sparse_accumulator(beta, acc, make_sparse(update_values))\\n\\n # Add small amount for numerical stability\\n update_values.add_(eps).rsqrt_().mul_(grad_values)\\n\\n update = make_sparse(update_values)\\n else:\\n # Get previous accumulators mu_{t-1}\\n if rank > 1:\\n acc_list = [state[_key(i)] for i in range(rank)]\\n else:\\n acc_list = [state[_key(0)]]\\n\\n # Get update from accumulators and gradients\\n update = _compute_update(beta, acc_list, grad, clip_threshold)\\n\\n # Update accumulators.\\n self._update_accumulator(beta, acc_list, update)\\n\\n # Add small amount for numerical stability\\n update.add_(eps).rsqrt_().mul_(grad)\\n\\n if momentum > 0.:\\n m = state['momentum_buffer']\\n update.mul_(1. - momentum).add_(m, alpha=momentum)\\n state['momentum_buffer'] = update.detach()\\n\\n p.sub_(update, alpha=group['lr'])\\n state['step'] += 1\\n return loss\",\n \"def add_grad_updates(self):\\n \\n gradients = T.grad(self.cost, self.theta)\\n \\n for target_param, grad in zip(self.theta, gradients):\\n \\n if target_param.name ==\\\"W\\\" and self.num_hidden ==0\\\\\\n and self.zero_diag:\\n \\n grad = grad - T.diag(T.diag(grad)) # no x i - xi connections\\n # for all i = 1, ..., D\\n ##############################################################\\n if target_param.name ==\\\"b\\\" and self.learn_biases == False:\\n print(\\\"Will not learn bias terms\\\")\\n pass\\n \\n elif target_param.name ==\\\"bhid\\\" and self.learn_biases == False:\\n print(\\\"Will not learn bias terms\\\")\\n pass\\n \\n else:\\n \\n if self.use_momentum:\\n \\n # alternative definition (mostly seen):\\n #g_tilda = self.momentum*self.grad_vec[target_param.name] - \\\\\\n #T.cast(self.learning_rate, dtype = theano.config.floatX)*grad\\n #self.updates[target_param] = target_param + g_tilda\\n \\n g_tilda = self.momentum*self.grad_vec[target_param.name] - \\\\\\n (1-self.momentum)*grad\\n \\n self.updates[target_param] = target_param +\\\\\\n T.cast(self.learning_rate, dtype = theano.config.floatX)*g_tilda\\n \\n # store g_tilda for next iteration:\\n self.updates[self.grad_vec[target_param.name]] = g_tilda\\n \\n else:\\n \\n self.updates[target_param] = target_param -\\\\\\n T.cast(self.learning_rate, dtype = theano.config.floatX)*grad\\n \\n if (\\\"PCD\\\" in self.algorithm) and self.num_hidden > 0:\\n \\n self.updates[self.persistent_gibbs] = self.hid_samples\",\n \"def calc_gradient(self):\\n \\n self.setup()\\n\\n # Create our 2D dictionary the first time we execute.\\n if not self.gradient:\\n for name in self.param_names:\\n self.gradient[name] = {}\\n \\n # Pull initial state and stepsizes from driver's parameters\\n base_param = OrderedDict()\\n stepsize = {}\\n for key, item in self._parent.get_parameters().iteritems():\\n base_param[key] = item.evaluate()\\n \\n if item.fd_step:\\n stepsize[key] = item.fd_step\\n else:\\n stepsize[key] = self.default_stepsize\\n\\n # For Forward or Backward diff, we want to save the baseline\\n # objective and constraints. These are also needed for the\\n # on-diagonal Hessian terms, so we will save them in the class\\n # later.\\n base_data = self._run_point(base_param)\\n \\n # Set up problem based on Finite Difference type\\n if self.form == 'central':\\n deltas = [1, -1]\\n func = diff_1st_central\\n elif self.form == 'forward':\\n deltas = [1, 0]\\n func = diff_1st_fwrdbwrd\\n else:\\n deltas = [0, -1]\\n func = diff_1st_fwrdbwrd\\n\\n self.gradient_case = OrderedDict()\\n\\n # Assemble input data\\n for param in self.param_names:\\n \\n pcase = []\\n for j_step, delta in enumerate(deltas):\\n \\n case = base_param.copy()\\n case[param] += delta*stepsize[param]\\n pcase.append({ 'param': case })\\n \\n self.gradient_case[param] = pcase\\n \\n # Run all \\\"cases\\\".\\n # TODO - Integrate OpenMDAO's concurrent processing capability once it\\n # is formalized. This operation is inherently paralellizable.\\n for key, case in self.gradient_case.iteritems():\\n for ipcase, pcase in enumerate(case):\\n if deltas[ipcase]:\\n pcase['data'] = self._run_point(pcase['param'])\\n else:\\n pcase['data'] = base_data\\n \\n \\n # Calculate gradients\\n for key, case in self.gradient_case.iteritems():\\n \\n eps = stepsize[key]\\n \\n for name in list(self.objective_names + \\\\\\n self.eqconst_names + \\\\\\n self.ineqconst_names):\\n self.gradient[key][name] = \\\\\\n func(case[0]['data'][name],\\n case[1]['data'][name], eps)\\n\\n # Save these for Hessian calculation\\n self.base_param = base_param\\n self.base_data = base_data\",\n \"def _compute(self, global_step, params, batch_loss):\\n individual_losses = get_individual_losses(global_step)\\n individual_gradients = autograd_individual_gradients(individual_losses, params)\\n layerwise = [\\n self._compute_histogram(p, igrad)\\n for p, igrad in zip(params, individual_gradients)\\n ]\\n\\n hist = sum(out[0] for out in layerwise)\\n edges = layerwise[0][1]\\n\\n result = {\\\"hist\\\": hist, \\\"edges\\\": edges}\\n\\n if self._keep_individual:\\n result[\\\"param_groups\\\"] = len(params)\\n\\n for idx, (hist, edges) in enumerate(layerwise):\\n result[f\\\"param_{idx}\\\"] = {\\\"hist\\\": hist, \\\"edges\\\": edges}\\n\\n return result\",\n \"def train_LR(self, X, y, eta=1e-3, batch_size=1, num_iters=1000) :\\n loss_history = []\\n N,d = X.shape\\n for t in np.arange(num_iters):\\n X_batch = None\\n y_batch = None\\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Sample batch_size elements from the training data for use in gradient descent. \\n # After sampling, X_batch should have shape: (batch_size,1), y_batch should have shape: (batch_size,)\\n # The indices should be randomly generated to reduce correlations in the dataset. \\n # Use np.random.choice. It is better to user WITHOUT replacement.\\n # ================================================================ #\\n \\n # sample indices without replacement\\n batch_idx = np.random.choice(N, batch_size, replace = False)\\n X_batch = X[batch_idx]\\n y_batch = y[batch_idx]\\n \\n \\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n loss = 0.0\\n grad = np.zeros_like(self.w)\\n # ================================================================ #\\n # YOUR CODE HERE: \\n # evaluate loss and gradient for batch data\\n # save loss as loss and gradient as grad\\n # update the weights self.w\\n # ================================================================ #\\n \\n # compute the loss and gradient\\n # loss_and_grad will take responsible for these\\n \\n loss, grad = self.loss_and_grad(X_batch, y_batch)\\n \\n self.w = self.w - eta * grad\\n \\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n loss_history.append(loss)\\n return loss_history, self.w\",\n \"def _evaluate_gradient(self, **variables):\\n pass\",\n \"def _train_step(self, params, sim_data):\\n \\n # Compute loss and store gradients\\n with tf.GradientTape() as tape:\\n loss = self.loss(self.network, params, sim_data)\\n \\n # One step backprop\\n gradients = tape.gradient(loss, self.network.trainable_variables)\\n self._apply_gradients(gradients, self.network.trainable_variables) \\n \\n return loss.numpy()\",\n \"def step(self, closure=None):\\n loss = None\\n if closure is not None:\\n loss = closure()\\n\\n for group in self.param_groups:\\n lr = group[\\\"lr\\\"]\\n weight_decay = group[\\\"weight_decay\\\"]\\n lr_decay = group[\\\"lr_decay\\\"]\\n eps = group[\\\"eps\\\"]\\n maximize = group[\\\"maximize\\\"]\\n\\n for p in group[\\\"params\\\"]:\\n if p.grad is None:\\n continue\\n\\n grad = p.grad\\n\\n if grad.is_sparse:\\n raise RuntimeError(\\n \\\"Adagrad does not support sparse gradients.\\\"\\n )\\n\\n state = self.state[p]\\n state_sum = state[\\\"sum\\\"]\\n\\n global_step = self._get_global_step(p)\\n\\n grad = grad if not maximize else -grad\\n\\n if group[\\\"weight_decay\\\"] > 0:\\n grad = grad.add(p, alpha=weight_decay)\\n\\n state_sum.addcmul_(grad, grad, value=1.0)\\n std = state_sum.sqrt().add_(eps)\\n\\n grad.div_(1.0 + (global_step - 1.0) * lr_decay)\\n p.addcdiv_(-lr * grad, std)\\n\\n return loss\",\n \"def _apply_gradient_descent(self, gradients):\\n updated_sd = {}\\n global_model = self._get_global_model()\\n \\n for name, param, grad in zip(global_model.keys(), global_model.values(), gradients):\\n updated_sd[name] = param - self.global_lr * grad\\n \\n self._load_global_model(updated_sd)\",\n \"def step(self, closure=None):\\n loss = None\\n if closure is not None:\\n loss = closure()\\n\\n for group in self.param_groups:\\n for p in group['params']:\\n if p.grad is None:\\n continue\\n grad = p.grad.data\\n if grad.is_sparse:\\n raise RuntimeError('Lamb does not support sparse gradients, consider SparseAdam instad.')\\n\\n state = self.state[p]\\n\\n # State initialization\\n if len(state) == 0:\\n state['step'] = 0\\n # Exponential moving average of gradient values\\n state['exp_avg'] = torch.zeros_like(p.data)\\n # Exponential moving average of squared gradient values\\n state['exp_avg_sq'] = torch.zeros_like(p.data)\\n\\n exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']\\n beta1, beta2 = group['betas']\\n\\n state['step'] += 1\\n\\n # Decay the first and second moment running average coefficient\\n # m_t\\n exp_avg.mul_(beta1).add_(1 - beta1, grad)\\n # v_t\\n exp_avg_sq.mul_(beta2).addcmul_(1 - beta2, grad, grad)\\n\\n # Paper v3 does not use debiasing.\\n # bias_correction1 = 1 - beta1 ** state['step']\\n # bias_correction2 = 1 - beta2 ** state['step']\\n # Apply bias to lr to avoid broadcast.\\n step_size = group['lr'] # * math.sqrt(bias_correction2) / bias_correction1\\n\\n weight_norm = p.data.pow(2).sum().sqrt().clamp(0, 10)\\n\\n adam_step = exp_avg / exp_avg_sq.sqrt().add(group['eps'])\\n if group['weight_decay'] != 0:\\n adam_step.add_(group['weight_decay'], p.data)\\n\\n adam_norm = adam_step.pow(2).sum().sqrt()\\n if weight_norm == 0 or adam_norm == 0:\\n trust_ratio = 1\\n else:\\n trust_ratio = weight_norm / adam_norm\\n state['weight_norm'] = weight_norm\\n state['adam_norm'] = adam_norm\\n state['trust_ratio'] = trust_ratio\\n if self.adam:\\n trust_ratio = 1\\n\\n p.data.add_(-step_size * trust_ratio, adam_step)\\n\\n return loss\",\n \"def train(self, X, y, X_val, y_val,\\n alpha=1e-3, alpha_decay=0.95,\\n reg=1e-5, num_iters=100,\\n batch_size=100):\\n num_train = X.shape[0]\\n iteration = max(num_train / batch_size, 1)\\n\\n loss_train = []\\n train_acc = []\\n val_acc = []\\n\\n for it in range(num_iters):\\n print('iteration '+str(it))\\n data_batch = None\\n label_batch = None\\n \\n #########################################################################\\n # create a random batch of data and labels for\\n indx = np.random.permutation(len(X))\\n data, labels = X[indx], y[indx]\\n data_batch = data[0:batch_size]\\n label_batch = labels[0:batch_size]\\n #########################################################################\\n pass\\n #########################################################################\\n # END OF YOUR CODE #\\n #########################################################################\\n # calculate loss and gradients\\n loss, gradient = self.loss(data_batch, y=label_batch, reg=reg)\\n loss_train.append(loss)\\n #########################################################################\\n # update weights and biases which stored in the slef.p_net regarding \\n # to gradient dictionary.\\n self.p_net['W1'] -= alpha * gradient['W1']\\n self.p_net['b1'] -= alpha * gradient['b1']\\n self.p_net['W2'] -= alpha * gradient['W2']\\n self.p_net['b2'] -= alpha * gradient['b2']\\n #########################################################################\\n pass\\n #########################################################################\\n # END OF YOUR CODE #\\n #########################################################################\\n if it % 100 == 0:\\n print ('iteration %d / %d: loss %f' % (it, num_iters, loss))\\n \\n if it % iteration == 0:\\n # Check accuracy\\n train_acc_ = (self.predict(data_batch) == label_batch).mean()\\n val_acc_ = (self.predict(X_val) == y_val).mean()\\n train_acc.append(train_acc_)\\n val_acc.append(val_acc_)\\n\\n alpha *= alpha_decay\\n\\n return {\\n 'loss_train': loss_train,\\n 'train_acc': train_acc,\\n 'val_acc': val_acc,\\n }\",\n \"def backward_pass(architecture,gradient_layerwise,grad_weights,grad_bias):\\n \\n for layer in range(len(architecture)-1,-1,-1):\\n X_input,X_output,weightsi,biasi,X_input_im2col,imi,output_shapei,kernel_shapei,stridei,operationi,imxi = architecture['layer{}'.format(layer+1)]\\n# print(\\\"Operation is:{} and Layer is: {}\\\".format(operationi,layer+1))\\n if operationi == 'softmax': # Last layer -> Dont apply softmax in any layer other than the last layer!\\n # not taking gradients here because we need dz_dX(secondlastlayer) which is y_pred - y\\n continue\\n \\n if operationi == 'conv_bn_relu' or operationi == 'conv_relu' or operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n if operationi__1 == 'softmax':\\n y_pred = architecture['layer{}'.format(layer+2)][1]\\n y_pred = torch.reshape(y_pred,y.shape)\\n dz_dXi = y_pred - y\\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi:\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n \\n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # .\\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # .\\n try:\\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input_im2col)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\\n except:\\n dz_dweightsi = (dz_dXi).mm(X_input_im2col)\\n \\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0\\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi #\\n elif operationi__1 == 'maxpool': # need to do something here to fix the problem\\n None\\n\\n elif 'flatten' in operationi__1:\\n # we currently have dz_doutput of flatten -> we want dz_doutput of the conv_bn_relu before flatten\\n \\n weightsi__1 = architecture['layer{}'.format(layer+2)][2] # weights2\\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput of flatten\\n if len(dz_dXi__1.shape) == 3:\\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\\n imi__1 = architecture['layer{}'.format(layer+2)][5] # i\\n try:\\n dz_dXi = torch.t(weightsi__1).mm(dz_dXi__1)\\n except:\\n dz_dXi = weightsi__1.mm(dz_dXi__1)\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi:\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n\\n dz_dXi = torch.reshape(dz_dXi,(output_shapei[1]*output_shapei[2],-1))\\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\\n dz_dweightsi = X_input_im2col.mm(dz_dXi)\\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\\n dz_dbi = dz_dXi\\n \\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)# Can also set this to layer like in line ~800\\n \\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi) # Can also set this to layer like in line ~800\\n \\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi) # Can also set this to layer like in line ~800\\n \\n else:\\n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dX2 -> backpropagated from maxpool\\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\\n if len(dz_dXi__1.shape) == 3:\\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\\n imi__1 = architecture['layer{}'.format(layer+2)][5]\\n try:\\n Y = weightsi__1.mm(dz_dXi__1)\\n except:\\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\\n dz_dXi = torch.zeros(X_output.shape)\\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\\n for i in range(np.shape(X_output)[0]):\\n for j in range(np.shape(X_output)[1]):\\n for k in range(np.shape(X_output)[2]):\\n idxs = getIndexes(imi__1,(i,j,k))\\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\\n \\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n if 'sigmoid' in operationi__1: # ...\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi__1: # ...\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n \\n dz_dXi = torch.reshape(dz_dXi,(output_shape_current_layer[1]*output_shape_current_layer[2],-1))\\n dz_dbi = torch.reshape(dz_dXi,bias_current_layer.shape)\\n dz_dweightsi = X_im2col_current_layer.mm(dz_dXi)\\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\\n \\n if operationi == 'maxpool':\\n \\n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput -> backpropagated from maxpool\\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\\n \\n if len(dz_dXi__1.shape) == 3:\\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\\n imi__1 = architecture['layer{}'.format(layer+2)][5]\\n try:\\n Y = weightsi__1.mm(dz_dXi__1)\\n except:\\n try:\\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\\n except:\\n Y = torch.t(weightsi__1).mm(dz_dXi__1) # Ensuring valid matrix multiplication here\\n \\n dz_dXi = torch.zeros(X_output.shape)\\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\\n for i in range(np.shape(X_output)[0]):\\n for j in range(np.shape(X_output)[1]):\\n for k in range(np.shape(X_output)[2]):\\n idxs = getIndexes(imi__1,(i,j,k))\\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\\n\\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n \\n if operationi__1 == 'conv_sigmoid' or operationi__1 == 'conv_bn_sigmoid': # ...\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n else:\\n dz_dXi[X_output <= 0] = 0\\n\\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\\n \\n dz_dXinput = torch.zeros((X_input.shape))\\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+1)][0] # output = output of maxpool\\n\\n dz_dXoutput = torch.reshape(dz_dXoutput,(output_shapei[0],X_input_im2col.shape[2]))\\n \\n for i in range(output_shapei[0]):\\n for j in range(X_input_im2col.shape[2]):\\n Xi2ci = X_im2col_current_layer[i,:,:]\\n idx = torch.argmax(Xi2ci[:,j]).item()\\n value = imxi[i][(idx,j)]\\n dz_dXinput[value[0],value[1],value[2]] += float(dz_dXoutput[i,j])\\n\\n# dz_dXinput = torch.reshape(dz_dXinput,output_shapei)\\n \\n X_prev_im2col = architecture['layer{}'.format(layer)][4]\\n X_output_prev = architecture['layer{}'.format(layer)][1]\\n X_output_prev = torch.reshape(X_output_prev,dz_dXinput.shape)\\n X_input_prev = architecture['layer{}'.format(layer)][0]\\n prev_bias = architecture['layer{}'.format(layer)][3]\\n output_shape_prev = architecture['layer{}'.format(layer)][6]\\n prev_operation = architecture['layer{}'.format(layer)][9]\\n \\n if prev_operation == 'conv_sigmoid' or prev_operation == 'conv_bn_sigmoid':\\n dz_dXinput *= sigmoid(X_output_prev)*(1-sigmoid(X_output_prev)) # Taking the derivative of the sigmoid function\\n else:\\n dz_dXinput[X_output_prev <= 0] = 0\\n \\n if len(dz_dXinput.shape) == 3:\\n dz_dXinput = torch.reshape(dz_dXinput,(-1,output_shape_prev[0]))\\n \\n dz_dbi = torch.reshape(dz_dXinput,prev_bias.shape)\\n dz_dweightsi = X_prev_im2col.mm(dz_dXinput)\\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0\\n \\n gradient_layerwise['layer{}'.format(layer)][2] = torch.Tensor(dz_dbi)\\n gradient_layerwise['layer{}'.format(layer)][1] = torch.Tensor(dz_dweightsi)\\n gradient_layerwise['layer{}'.format(layer)][0] = torch.Tensor(dz_dXinput) # ...\\n \\n if 'flatten_dense' in operationi:\\n \\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n \\n if operationi__1 == 'softmax':\\n \\n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\\n X_output = torch.reshape(X_output,(-1,1))\\n y_pred = architecture['layer{}'.format(layer+2)][1]\\n y_pred = torch.reshape(y_pred,y.shape)\\n dz_dXi = y_pred - y\\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n if 'sigmoid' in operationi:\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi:\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n \\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\\n try:\\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\\n except:\\n dz_dweightsi = (dz_dXi).mm(X_input)\\n \\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0\\n \\n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # Can also set this to layer like in line ~800\\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi # Can also set this to layer like in line ~800\\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # Can also set this to layer like in line ~800\\n \\n else:\\n # Have to modify and test this before implementation -> Specifically\\n # the backprop implementation is not consistent with the ones above\\n #\\n X_output = torch.reshape(X_output,(-1,1))\\n weights__i = architecture['layer{}'.format(layer+2)][2]\\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+2)][0]\\n dz_dXoutput = torch.reshape(torch.Tensor(dz_dXoutput),X_output.shape)\\n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\\n\\n if 'relu' in operationi:\\n dz_dXoutput[X_output<0] = 0\\n try:\\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\\n except:\\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\\n try:\\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\\n except:\\n dz_dweightsi = dz_dXoutput.mm(X_input)\\n dz_dbi = dz_dXoutput\\n if 'sigmoid' in operationi:\\n dz_dXoutput*= sigmoid(X_output)*(1-sigmoid(X_output))\\n try:\\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\\n except:\\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\\n try:\\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\\n except:\\n dz_dweightsi = dz_dXoutput.mm(X_input)\\n dz_dbi = dz_dXoutput\\n else:\\n try:\\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\\n except:\\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\\n try:\\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\\n except:\\n dz_dweightsi = dz_dXoutput.mm(X_input)\\n dz_dbi = dz_dXoutput\\n \\n unflattened_Xinput = architecture['layer{}'.format(layer+1)][0]\\n dz_dXinput = torch.reshape(dz_dXinput,unflattened_Xinput.shape)\\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXinput)\\n \\n if gradient_layerwise['layer{}'.format(layer+1)][1] is not None:\\n try:\\n grad_weights['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][1]\\n except:\\n grad_weights['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][1])\\n if gradient_layerwise['layer{}'.format(layer+1)][2] is not None:\\n try:\\n grad_bias['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][2]\\n except:\\n grad_bias['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][2])\\n \\n gc.collect()\\n return\",\n \"def compute_gradients(self,\\n loss,\\n var_list=None,\\n gate_gradients=optimizer.Optimizer.GATE_OP,\\n aggregation_method=None,\\n colocate_gradients_with_ops=False,\\n grad_loss=None):\\n if not var_list:\\n var_list = variables.trainable_variables()\\n\\n elastic_difference = [\\n math_ops.subtract(v, lv)\\n for v, lv in zip(variables.trainable_variables(),\\n [self._local_map[var] for var in var_list])\\n ]\\n\\n distance_loss = self._rho * math_ops.add_n(\\n [gen_nn_ops.l2_loss(ed) for ed in elastic_difference])\\n\\n total_loss = loss + distance_loss\\n return self._opt.compute_gradients(total_loss, var_list, gate_gradients,\\n aggregation_method,\\n colocate_gradients_with_ops, grad_loss)\",\n \"def optimize(w, b, X, Y, num_iterations,learning_rate,print_cost = False):\\n costs = []\\n for i in range(num_iterations):\\n\\n # Cost and gradient calculation (≈ 1-4 lines of code)\\n ### START CODE HERE ###\\n grads,cost = propagate(w,b,X,Y)\\n ### END CODE HERE ###\\n\\n # Retrieve derivatives from grads\\n dw = grads[\\\"dw\\\"]\\n db = grads[\\\"db\\\"]\\n\\n # update rule (≈ 2 lines of code)\\n ### START CODE HERE ###\\n w = w - learning_rate*dw\\n b = b - learning_rate*db\\n ### END CODE HERE ###\\n\\n # Record the costs\\n if i % 100 == 0:\\n costs.append(cost)\\n\\n # Print the cost every 100 training examples\\n if print_cost and i%100==0:\\n print(\\\"Cost after iteration %i: %f\\\"%(i,cost))\\n\\n params = {\\n \\\"w\\\":w,\\n \\\"b\\\":b\\n }\\n grads = {\\n \\\"dw\\\":dw,\\n \\\"db\\\":db\\n }\\n return params,grads,costs\",\n \"def solve(self):\\n max_iter = 1000\\n iter_count = 0\\n yhat = self.predict()\\n loss = self.cross_entropy(yhat)\\n gradloss = self.cross_entropy_gradient(yhat)\\n while la.norm(gradloss) > 1e-6 and iter_count < max_iter:\\n alpha = 1.0\\n slope = la.norm(gradloss)**2\\n beta_new = self.beta + alpha * gradloss\\n yhat = self.predict(beta=beta_new)\\n loss_new = self.cross_entropy(yhat)\\n while loss_new < loss + 1e-4 * alpha * slope:\\n alpha = alpha / 2\\n beta_new = self.beta + alpha * gradloss\\n yhat = self.predict(beta=beta_new)\\n loss_new = self.cross_entropy(yhat)\\n self.beta = beta_new\\n loss = loss_new\\n gradloss = self.cross_entropy_gradient(yhat)\\n iter_count += 1\",\n \"def run(self):\\n if self.graph is None:\\n raise ValueError(\\\"Create TensorFlow graph before running a session.\\\")\\n with tf.Session(graph=self.graph) as session:\\n tf.global_variables_initializer().run()\\n\\n # Stochastic gradient descent: train the data with a mini-batch each iteration\\n batch_size = self.options['batch_size']\\n for epoch_idx in range(self.options['num_epoch']):\\n training_epoch = self.training_data[epoch_idx]\\n label_epoch = self.training_label[epoch_idx]\\n batch_count = training_epoch.shape[0] // batch_size\\n\\n learning_rate = self.options['learning_rate']\\n if self.options['learning_rate_decay_coeff'] > 0.:\\n learning_rate *= self.options['learning_rate_decay_coeff'] ** \\\\\\n max(float(epoch_idx + 1 - self.options['init_epoch']), 0.0)\\n for batch in range(batch_count):\\n try:\\n batch_data = training_epoch[batch*batch_size:(batch+1)*batch_size, :, :]\\n batch_labels = label_epoch[batch*batch_size:(batch+1)*batch_size, :]\\n except KeyError:\\n batch_data = training_epoch[batch*batch_size:, :, :]\\n batch_labels = label_epoch[batch*batch_size:, :]\\n feed_dict = {\\n self.tf_dataset: batch_data,\\n self.tf_labels: batch_labels,\\n self.learning_rate: learning_rate}\\n\\n p, l, _, = session.run([self.predict, self.loss, self.minimise], feed_dict=feed_dict)\\n self.train_losses.append(l)\\n self.train_accuracies.append(self.get_accuracy(batch_labels, p))\\n\\n # Finally run the data on test data\\n final_feed_dict = {\\n self.tf_dataset: self.test_data,\\n self.tf_labels: self.test_label,\\n self.learning_rate: 0.,\\n }\\n self.predict, final_loss = session.run([self.predict, self.minimise], feed_dict=final_feed_dict)\\n return self.predict\",\n \"def verify_gradients(self):\\n\\n print 'WARNING: calling verify_gradients reinitializes the learner'\\n\\n rng = np.random.mtrand.RandomState(1234)\\n\\n self.seed = 1234\\n self.sizes = [4, 5]\\n self.initialize(20, 3)\\n example = (rng.rand(20) < 0.5, 2)\\n input, target = example\\n epsilon = 1e-6\\n self.lr = 0.1\\n self.decrease_constant = 0\\n\\n self.fprop(input, target)\\n self.bprop(input, target) # compute gradients\\n\\n import copy\\n emp_grad_weights = copy.deepcopy(self.weights)\\n\\n for h in range(len(self.weights)):\\n for i in range(self.weights[h].shape[0]):\\n for j in range(self.weights[h].shape[1]):\\n self.weights[h][i, j] += epsilon\\n a = self.fprop(input, target)\\n self.weights[h][i, j] -= epsilon\\n\\n self.weights[h][i, j] -= epsilon\\n b = self.fprop(input, target)\\n self.weights[h][i, j] += epsilon\\n\\n emp_grad_weights[h][i, j] = (a - b) / (2. * epsilon)\\n\\n print 'grad_weights[0] diff.:', np.sum(np.abs(self.grad_weights[0].ravel() - emp_grad_weights[0].ravel())) / \\\\\\n self.weights[0].ravel().shape[0]\\n print 'grad_weights[1] diff.:', np.sum(np.abs(self.grad_weights[1].ravel() - emp_grad_weights[1].ravel())) / \\\\\\n self.weights[1].ravel().shape[0]\\n print 'grad_weights[2] diff.:', np.sum(np.abs(self.grad_weights[2].ravel() - emp_grad_weights[2].ravel())) / \\\\\\n self.weights[2].ravel().shape[0]\\n\\n emp_grad_biases = copy.deepcopy(self.biases)\\n for h in range(len(self.biases)):\\n for i in range(self.biases[h].shape[0]):\\n self.biases[h][i] += epsilon\\n a = self.fprop(input, target)\\n self.biases[h][i] -= epsilon\\n\\n self.biases[h][i] -= epsilon\\n b = self.fprop(input, target)\\n self.biases[h][i] += epsilon\\n\\n emp_grad_biases[h][i] = (a - b) / (2. * epsilon)\\n\\n print 'grad_biases[0] diff.:', np.sum(np.abs(self.grad_biases[0].ravel() - emp_grad_biases[0].ravel())) / \\\\\\n self.biases[0].ravel().shape[0]\\n print 'grad_biases[1] diff.:', np.sum(np.abs(self.grad_biases[1].ravel() - emp_grad_biases[1].ravel())) / \\\\\\n self.biases[1].ravel().shape[0]\\n print 'grad_biases[2] diff.:', np.sum(np.abs(self.grad_biases[2].ravel() - emp_grad_biases[2].ravel())) / \\\\\\n self.biases[2].ravel().shape[0]\",\n \"def step_mine(self, iter=1):\\n for i in range(iter):\\n self.XY_optimizer_mine.zero_grad()\\n batch_XY = _resample(self.XY, batch_size=self.batch_size)\\n batch_X, batch_Y = self.split(batch_XY)\\n # batch_X = _resample(self.X, batch_size=self.batch_size)\\n # batch_Y = _resample(self.Y, batch_size=self.batch_size)\\n batch_X_ref_mine = _resample(self.X, batch_size=self.batch_size)\\n batch_Y_ref_mine = _resample(self.Y, batch_size=self.batch_size)\\n batch_XY_ref_mine = self.cat(batch_X_ref_mine, batch_Y_ref_mine)\\n # batch_XY_ref_mine = torch.cat(\\n # (batch_X_ref_mine, batch_Y_ref_mine), dim=1)\\n # define the loss function with moving average in the gradient estimate\\n mean_fXY = self.XY_net(batch_XY).mean(\\n ) - self.X_net(batch_X).mean() - self.Y_net(batch_Y).mean()\\n # mean_efXY_ref_mine = torch.logsumexp(self.XY_net(batch_XY_ref_mine) - self.X_net(batch_X_ref_mine) - self.Y_net(batch_Y_ref_mine), 0) - np.log(batch_XY_ref_mine.shape[0])\\n mean_efXY_ref_mine = torch.exp(\\n self.XY_net(batch_XY_ref_mine) - self.X_net(batch_X_ref_mine) - self.Y_net(batch_Y_ref_mine)).mean()\\n self.ma_ef = (1-self.ma_rate)*self.ma_ef + \\\\\\n self.ma_rate*mean_efXY_ref_mine\\n batch_loss_XY = - mean_fXY + \\\\\\n (1 / self.ma_ef.mean()).detach() * mean_efXY_ref_mine\\n batch_loss_XY.backward()\\n self.XY_optimizer_mine.step()\",\n \"def step(self, closure=None):\\n orig_loss,err,pred = closure()\\n loss = orig_loss\\n\\n group = self.param_groups[0]\\n lr = group['lr']\\n decay_lr = group['decay_lr']\\n max_iter = group['max_iter']\\n reg = group['reg']\\n backtrack = group['backtrack']\\n bt_alpha = group['bt_alpha']\\n bt_beta = group['bt_beta']\\n sketch_size = group['sketch_size']\\n tolerance = group['tolerance']\\n\\n #import pdb; pdb.set_trace()\\n n = err.shape[0] #batch size\\n #If sketching the jacobian, randomly select [sketch_size] samples\\n \\n if sketch_size is not None:\\n idx = torch.randperm(n)[:sketch_size]\\n else:\\n idx = torch.arange(n) #Don't sketch, use all samples\\n \\n w0 = nn.utils.parameters_to_vector(self._params) #weight parameters in vector form\\n \\n #Compute Gauss-Newton vector product \\n grad, ggnvp = _make_ggnvp(err,self._params,w0,n,reg,idx) #return gradient in vector form + ggnvp function\\n #Solve for the Conjugate Gradient Direction\\n dw, cost_log = _conjugate_gradient(ggnvp, grad, max_iter, tolerance)\\n\\n #Perform backtracking line search\\n val = loss + 0.5 * reg * torch.norm(w0)**2\\n fprime = -1*dw @ grad\\n \\n self.grad_update += 1\\n if backtrack > 0:\\n t = lr\\n\\n #TODO: If using backtracking, get new loss with (w0 - t*dw) as network parameters\\n bts = 0\\n alpha = bt_alpha\\n beta = bt_beta \\n while (loss + 0.5 * reg * torch.norm(w0 - t*dw)**2 > val + alpha * t * fprime):\\n t = beta * t\\n bts += 1\\n if bts > backtrack:\\n print('Maximum backtracking reached, accuracy not guaranteed')\\n break\\n elif decay_lr: #decay lr\\n t = lr/np.maximum(1, self.grad_update-10)\\n else: #use lr step-size\\n t = lr\\n\\n print('step size: {}'.format(t))\\n\\n #Update the model parameters\\n self._add_grad(-t, dw)\\n \\n return val, pred\",\n \"def __SGD(self, X_train, Y_train):\\n \\n display_step = 100\\n iters = len(X_train) // batch_size\\n all_loss = []\\n\\n for e in range(epochs):\\n indices = np.random.permutation(len(X_train))\\n X_train, Y_train = X_train[indices], Y_train[indices]\\n loss = 0\\n for i in range(iters):\\n batch_x = X_train[i * self.batch_size : min((i + 1) * self.batch_size, len(X_train))]\\n batch_y = Y_train[i * self.batch_size : min((i + 1) * self.batch_size, len(Y_train))]\\n outputs = self.__forward_propagate(batch_x)\\n loss += self.compute_loss(batch_y, all_X[-1])\\n grad_list = self.__backward_propagate(batch_y, outputs)\\n self.update_weight(grad_list)\\n\\n if (e + 1) % display_step == 0:\\n print(\\\"Epoch: {}, Loss: {}\\\".format(e + 1, loss))\",\n \"def update(network: nn.Module, data: DataLoader, loss: nn.Module, \\n opt: optim.Optimizer) -> list:\\n error_list = []\\n counter = 0\\n for x, y in data:\\n \\n print(x.float()[0])\\n pred = network(x.float())\\n print(pred, y.float())\\n\\n le = loss(pred, y.float())\\n error_list.append(le)\\n opt.zero_grad()\\n le.backward()\\n opt.step()\\n counter += 1\\n \\n print(\\\"Loss: \\\", torch.mean(torch.tensor(error_list)) )\\n \\n return torch.tensor(error_list)\",\n \"def step(self, closure=None):\\n loss = None\\n if closure is not None:\\n loss = closure()\\n for group in self.param_groups:\\n weight_decay = group['weight_decay']\\n for p in group['params']:\\n if p.grad is None:\\n continue\\n d_p = p.grad.data\\n if weight_decay != 0:\\n d_p.add_(weight_decay, p.data)\\n p.data.add_(-group['lr'], d_p)\\n return loss\",\n \"def update_network(self, loss_dict):\\r\\n loss = sum(loss_dict.values())\\r\\n self.optimizer.zero_grad()\\r\\n loss.backward()\\r\\n self.optimizer.step()\",\n \"def gradient_descend(self, X, y, state_generators, operator_programs=None,\\r\\n qvm=None):\\r\\n history_theta, history_loss, history_grad = [], [], []\\r\\n coeff, theta = 1.0, self.initial_theta\\r\\n \\r\\n prog_input_gen = state_generators['input']\\r\\n prog_output_gen = state_generators['output']\\r\\n prog_output_grad = state_generators['grad']\\r\\n \\r\\n n_samples = len(X)\\r\\n n_theta = len(theta)\\r\\n \\r\\n if qvm is None:\\r\\n self.qvm = api.QVMConnection()\\r\\n else:\\r\\n self.qvm = qvm\\r\\n \\r\\n # Check operators\\r\\n if not isinstance(operator_programs, list):\\r\\n operator_programs = [operator_programs]\\r\\n n_operators = len(operator_programs)\\r\\n \\r\\n # Check batch size\\r\\n if self.batch_size is None:\\r\\n self.batch_size = n_samples\\r\\n self.batch_size = min(self.batch_size, n_samples)\\r\\n \\r\\n # Loop over epochs\\r\\n for e in range(self.epochs): \\r\\n \\r\\n # Loop over batches\\r\\n batches = self.generate_batches(X, y, self.batch_size)\\r\\n n_batches = len(batches)\\r\\n for i, batch in enumerate(batches):\\r\\n \\r\\n batch_X, batch_y = batch\\r\\n n_samples_in_batch = len(batch_X)\\r\\n \\r\\n # Predictions\\r\\n batch_y_pred = np.zeros((n_samples_in_batch, n_operators))\\r\\n for k in range(n_samples_in_batch):\\r\\n prog = prog_input_gen(batch_X[k,:])\\r\\n prog += prog_output_gen(theta)\\r\\n batch_y_pred[k,:] = coeff * np.array(qvm.expectation(prog, operator_programs))\\r\\n if self.loss == self.loss_entropy:\\r\\n batch_y_pred[k,:] = np.exp(batch_y_pred[k,:]) / np.sum(np.exp(batch_y_pred[k,:]))\\r\\n \\r\\n # Comput loss\\r\\n loss_value = self._compute_loss(batch_y, batch_y_pred)\\r\\n \\r\\n # Display status\\r\\n if self.verbose:\\r\\n print('Epoch: {}/{} ::: Batch: {}/{} ::: Loss: {:.5f}'.format(e+1, self.epochs, i+1, n_batches, loss_value)) \\r\\n \\r\\n # Gradient\\r\\n if not (e == self.epochs - 1 and i == n_batches - 1):\\r\\n grad = np.zeros((n_samples_in_batch, n_operators, n_theta))\\r\\n for k in range(n_samples_in_batch):\\r\\n \\r\\n # Define input state \\r\\n prog_input = prog_input_gen(batch_X[k,:])\\r\\n \\r\\n # Caclulate gradient for each theta_j\\r\\n for j in range(n_theta):\\r\\n \\r\\n # Gradient +/- \\r\\n for sign in [1,-1]:\\r\\n grad_sign = np.zeros(n_operators)\\r\\n grad_progs = prog_output_grad(theta, j, sign)\\r\\n # Generally, the gradient programs could return\\r\\n # a program or list of programs (in case the \\r\\n # gradient +/- is the sum of expectations)\\r\\n if not isinstance(grad_progs, list):\\r\\n grad_progs = [grad_progs]\\r\\n for grad_prog in grad_progs:\\r\\n prog = prog_input\\r\\n prog += grad_prog\\r\\n # B_j +/- expectation\\r\\n grad_sign += np.array(qvm.expectation(prog, operator_programs))\\r\\n # Gradient = (B_j+ - B_j-) / 2\\r\\n grad[k, :, j] += sign / 2.0 * grad_sign\\r\\n \\r\\n # Gradient update\\r\\n grad_full = self._compute_grad_full(batch_y, batch_y_pred, grad)\\r\\n if self.loss == self.loss_mse:\\r\\n grad_full_coeff = -2.0 * np.mean((batch_y - batch_y_pred) * batch_y_pred)\\r\\n \\r\\n # Update theta\\r\\n theta -= self.learning_rate * grad_full\\r\\n if self.loss == self.loss_mse:\\r\\n coeff -= self.learning_rate * grad_full_coeff\\r\\n \\r\\n # Append to history\\r\\n history_loss.append(loss_value)\\r\\n history_theta.append(theta)\\r\\n history_grad.append(grad)\\r\\n \\r\\n # Prepare results\\r\\n results = OptResults()\\r\\n results.theta, results.coeff = theta, coeff\\r\\n results.loss = loss_value\\r\\n results.history_loss = history_loss\\r\\n results.history_theta = history_theta\\r\\n results.history_grad = history_grad\\r\\n \\r\\n return results\",\n \"def get_gradients(self, images, labels):\\n # Push to gpu\\n images = Variable(images, requires_grad = True) if self.gpu == False else Variable(images.cuda(), requires_grad = True)\\n labels = labels if self.gpu == False else labels.cuda()\\n\\n # Make images require gradients\\n images.requires_grad_(True)\\n\\n # Clear Gradients\\n self.net.zero_grad()\\n images.grad = None\\n\\n #Forward pass\\n outputs = self.net(images)\\n soft_max_output = self.soft_max(outputs)\\n loss = self.criterion(outputs, labels)\\n losses = self.indv_criterion(outputs, labels)\\n _, predicted = torch.max(outputs.data, 1)\\n \\n # Find size parameters\\n batch_size = outputs.size(0)\\n num_classes = outputs.size(1)\\n\\n # Find gradients\\n loss.cpu().backward(retain_graph = True)\\n gradients = images.grad.data.view(batch_size, 28*28, 1) \\n \\n return gradients, batch_size, num_classes, losses, predicted\",\n \"def evaluate_loss(net, data_iter, loss):\\n metric = Accumulator(2) # Sum of losses, no. of examples\\n for X, y in data_iter:\\n out = net(X)\\n y = torch.reshape(y, out.shape)\\n l = loss(out, y)\\n metric.add(torch.sum(l), l.numel())\\n return metric[0] / metric[1]\",\n \"def evaluate_loss(net, data_iter, loss):\\n metric = Accumulator(2) # Sum of losses, no. of examples\\n for X, y in data_iter:\\n out = net(X)\\n y = torch.reshape(y, out.shape)\\n l = loss(out, y)\\n metric.add(torch.sum(l), l.numel())\\n return metric[0] / metric[1]\",\n \"def step(self, closure):\\r\\n self.state['step'] += 1\\r\\n for y_ind in range(self.dim_out):\\r\\n err = closure(y_ind)\\r\\n for group_ind in range(len(self.param_groups)):\\r\\n group = self.param_groups[group_ind]\\r\\n iekf_mat = self.state['iekf_groups'][group_ind]\\r\\n for ii, w in enumerate(group['params']):\\r\\n if w.grad is None:\\r\\n continue\\r\\n H_n = iekf_mat[ii]['H']\\r\\n grad = w.grad.data.detach()\\r\\n if len(w.size()) > 1:\\r\\n grad = grad.transpose(1, 0)\\r\\n grad = grad.contiguous().view((1, -1))\\r\\n if y_ind == 0:\\r\\n H_n = grad\\r\\n else:\\r\\n H_n = torch.cat([H_n, grad], dim=0)\\r\\n self.state['iekf_groups'][group_ind][ii]['H'] = H_n\\r\\n\\r\\n err_T = err.transpose(0, 1)\\r\\n\\r\\n for group_ind in range(len(self.param_groups)):\\r\\n group = self.param_groups[group_ind]\\r\\n iekf_mat = self.state['iekf_groups'][group_ind]\\r\\n for ii, w in enumerate(group['params']):\\r\\n if w.grad is None:\\r\\n continue\\r\\n\\r\\n lbd_n = iekf_mat[ii]['lbd']\\r\\n P_n = iekf_mat[ii]['P']\\r\\n EPS = iekf_mat[ii]['EPS']\\r\\n H_n = iekf_mat[ii]['H']\\r\\n H_n_T = H_n.transpose(0, 1)\\r\\n if group['lbd_decay']:\\r\\n miu = 1.0 / min(self.state['step'], group['lbd_max_step'])\\r\\n lbd_n = lbd_n + miu * (err_T.mm(err).flatten()[0] / self.dim_out - lbd_n)\\r\\n self.state['iekf_groups'][group_ind][ii]['lbd'] = lbd_n\\r\\n R_n = lbd_n * torch.eye(self.dim_out, dtype=torch.float, device=iekf_mat[ii]['device'],\\r\\n requires_grad=False)\\r\\n\\r\\n g_n = R_n + H_n.mm(P_n).mm(H_n_T)\\r\\n g_n = g_n.inverse()\\r\\n\\r\\n K_n = P_n.mm(H_n_T).mm(g_n)\\r\\n delta_w = K_n.mm(err)\\r\\n if len(w.size()) > 1:\\r\\n delta_w = delta_w.view((w.size(1), w.size(0))).transpose(1, 0)\\r\\n else:\\r\\n delta_w = delta_w.view(w.size())\\r\\n\\r\\n new_P = (group['alpha'] + 1) * (P_n - K_n.mm(H_n).mm(P_n) + EPS)\\r\\n self.state['iekf_groups'][group_ind][ii]['P'] = new_P\\r\\n\\r\\n w.data.add_(delta_w)\\r\\n\\r\\n return err\",\n \"def gradient_descent(features, values, theta, alpha, num_iterations):\\r\\n \\r\\n m = len(values)\\r\\n cost_history = []\\r\\n\\r\\n for i in range(num_iterations):\\r\\n # your code here\\r\\n cost = compute_cost(features, values, theta)/(2.0*m)\\r\\n cost_history.append([cost])\\r\\n \\r\\n error = features.dot(theta) - values\\r\\n error = np.reshape(error,(error.shape[0], 1))\\r\\n errorWeighted = features*error\\r\\n errorSum = (np.sum(errorWeighted,0))/(m*1.0)\\r\\n theta = theta - alpha*errorSum \\r\\n \\r\\n return theta, pandas.Series(cost_history)\",\n \"def __call__(self):\\n #Losses and optimizers\\n for epoch in range(self.nb_epochs): # loop over the dataset multiple times\\n self.train_loss = 0.0\\n self.gan_loss = 0.0\\n self.loss_discrim = 0.0\\n val_loss = 0.0\\n nb_data = 0.\\n nb_data_val = 0.\\n for i, data in enumerate(self.trainloader, 0):\\n # get the batch; data is a list of [inputs, labels]\\n inputs, real = data\\n inputs, real = inputs.to(device), real.to(device)\\n if i%self.discrimTrainPeriod==0:\\n self.trainDiscrim(inputs, real)\\n else:\\n self.trainGen(inputs, real)\\n nb_data += 1.\\n #occasionnally save an example target/generated\\n if i%self.displayPeriod==0:\\n self.gen.eval()\\n real = self.unNormalize(real[0,:,:,:].detach().cpu())\\n self.transformToImage(real).save(self.targetFile)\\n fake = self.gen(inputs)\\n fake = self.unNormalize(fake[0,:,:,:].detach().cpu())\\n self.transformToImage(fake).save(self.generatedFile)\\n\\n self.gen.eval()\\n for i, data in enumerate(self.valloader, 0):\\n with torch.no_grad():\\n # get the inputs; data is a list of [inputs, labels]\\n inputs, real = data\\n inputs, real = inputs.to(device), real.to(device)\\n #compute L1 loss\\n fake = self.gen(inputs)\\n lossGenL1 = self.criterionL1(fake, real)\\n #statistics\\n val_loss += lossGenL1.item()\\n nb_data_val += 1.\\n self.gan_loss = self.gan_loss / nb_data\\n self.train_loss = self.train_loss / nb_data\\n self.loss_discrim = self.loss_discrim / nb_data\\n val_loss = val_loss / nb_data_val\\n self.gan_loss_list.append(self.gan_loss)\\n self.train_loss_list.append(self.train_loss)\\n self.val_loss_list.append(val_loss)\\n print(\\\"Epoch \\\", epoch, \\\"; train loss = \\\", self.train_loss,\\n \\\"; val loss = \\\", val_loss, \\\"; gan loss = \\\", self.gan_loss,\\n \\\"; loss discrim = \\\", self.loss_discrim)\\n\\n plt.plot(range(len(self.train_loss_list)), self.train_loss_list,\\n self.val_loss_list, self.gan_loss_list)\\n plt.xlabel(\\\"Epochs\\\")\\n plt.ylabel(\\\"Generator Loss\\\")\\n plt.savefig(self.graphFile)\\n #save the weights\\n torch.save(self.gen.state_dict(), self.savefileGen)\\n torch.save(self.discrim.state_dict(), self.savefileDiscrim)\",\n \"def _validation_loss(self) -> Tuple[float, int]:\\n logger.info(\\\"Validating\\\")\\n\\n self.model.eval()\\n\\n # Replace parameter values with the shadow values from the moving averages.\\n if self._moving_average is not None:\\n self._moving_average.assign_average_value()\\n\\n if self._validation_iterator is not None:\\n val_iterator = self._validation_iterator\\n else:\\n val_iterator = self.iterator\\n\\n num_gpus = len(self._cuda_devices)\\n\\n raw_val_generator = val_iterator(self._validation_data,\\n num_epochs=1,\\n shuffle=False)\\n val_generator = lazy_groups_of(raw_val_generator, num_gpus)\\n num_validation_batches = math.ceil(val_iterator.get_num_batches(self._validation_data)/num_gpus)\\n val_generator_tqdm = Tqdm.tqdm(val_generator,\\n total=num_validation_batches)\\n batches_this_epoch = 0\\n val_loss = 0\\n for batch_group in val_generator_tqdm:\\n\\n output_dict = self.get_output_dict(batch_group, for_training=False)\\n loss = self.get_batch_loss(output_dict, for_training=False)\\n\\n if loss is not None:\\n # You shouldn't necessarily have to compute a loss for validation, so we allow for\\n # `loss` to be None. We need to be careful, though - `batches_this_epoch` is\\n # currently only used as the divisor for the loss function, so we can safely only\\n # count those batches for which we actually have a loss. If this variable ever\\n # gets used for something else, we might need to change things around a bit.\\n batches_this_epoch += 1\\n val_loss += loss.detach().cpu().numpy()\\n\\n # Update the description with the latest metrics\\n val_metrics = training_util.get_metrics(self.model, val_loss, batches_this_epoch)\\n description = training_util.description_from_metrics(val_metrics)\\n val_generator_tqdm.set_description(description, refresh=False)\\n\\n # Now restore the original parameter values.\\n if self._moving_average is not None:\\n self._moving_average.restore()\\n\\n return val_loss, batches_this_epoch\",\n \"def train(epoch, model, loss_fn, optimizer, dataloder,pair_generation_tnf):\\n model.train()\\n train_loss =0\\n for batch_idx, batch in enumerate(tqdm(dataloder, desc='Epoch {}'.format(epoch))):\\n optimizer.zero_grad()\\n #batch = pair_generation_tnf(batch)\\n \\n theta = model(batch)\\n print()\\n loss= loss_fn(theta, batch['theta'])\\n \\n \\n \\n loss.backward()\\n optimizer.step()\\n train_loss += loss.data.cpu().numpy().item()\\n train_loss /= len(dataloader)\\n print('Train set: Average loss: {:.4f}'.format(train_loss))\\n return train_loss\",\n \"def svm_loss_forloop(W, X, y, reg, delta=1):\\n\\n ################################################################################\\n # You implementation #\\n # Use the ahove svm_loss_bias_forloop implementation as reference #\\n ################################################################################\\n\\n # initialize the returned results\\n loss = 0.0\\n d_W = np.zeros(W.shape)\\n\\n # compute the loss and the gradient\\n num_classes = W.shape[1]\\n num_train = X.shape[0]\\n\\n for i in xrange(num_train):\\n # compute the classification scores for a single image\\n scores = X[i].dot(W)\\n correct_class_score = scores[y[i]]\\n for j in xrange(num_classes):\\n # compute the loss for this image\\n if j == y[i]:\\n continue\\n margin = scores[j] - correct_class_score + delta\\n if margin > 0:\\n loss += margin\\n # compute the gradient for this image\\n d_W[:, j] += X[i, :].T\\n d_W[:, y[i]] -= X[i, :].T\\n\\n # Right now the loss is a sum over all training examples\\n # We need it to be an average instead so we divide by num_train.\\n loss /= num_train\\n # Add regularization to the loss.\\n #no reg on bias\\n loss += 0.5 * reg * np.sum(W[:-1,:] * W[:-1,:])\\n\\n # Do the same for d_W and d_b\\n d_W /= num_train\\n d_W[:-1,:] += reg * W[:-1,:]\\n\\n\\n return loss, d_W\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7177683","0.70011306","0.69751114","0.68704146","0.6854747","0.6794312","0.67768157","0.67635286","0.6713901","0.6713034","0.66898924","0.66752005","0.665963","0.6622884","0.6610839","0.66093385","0.66018146","0.65964544","0.6590787","0.6583664","0.6579465","0.65566885","0.654532","0.6535439","0.65264","0.65066075","0.65018195","0.64977205","0.64880705","0.64838105","0.6482338","0.6471282","0.6456324","0.64429426","0.6437969","0.6434186","0.6430671","0.64248866","0.6422061","0.64187217","0.6415501","0.64057857","0.6405625","0.6383021","0.6382507","0.6379643","0.6379008","0.6374592","0.63709134","0.63492906","0.6343919","0.6338709","0.6336033","0.63325256","0.6303641","0.63006127","0.62986124","0.6293778","0.6288526","0.62768","0.62713164","0.6269332","0.6267966","0.6265939","0.62652904","0.6264365","0.62593037","0.6247394","0.6243793","0.6243547","0.6234834","0.62270856","0.6220194","0.6220116","0.6217007","0.6207468","0.6204805","0.6203193","0.6200474","0.6193283","0.6191528","0.6189096","0.6186807","0.61808753","0.61780614","0.6174258","0.61650264","0.61644506","0.61598307","0.6157991","0.6157356","0.61559004","0.6154523","0.61542577","0.61542577","0.6145324","0.6145211","0.61427426","0.614047","0.6135176","0.61316365"],"string":"[\n \"0.7177683\",\n \"0.70011306\",\n \"0.69751114\",\n \"0.68704146\",\n \"0.6854747\",\n \"0.6794312\",\n \"0.67768157\",\n \"0.67635286\",\n \"0.6713901\",\n \"0.6713034\",\n \"0.66898924\",\n \"0.66752005\",\n \"0.665963\",\n \"0.6622884\",\n \"0.6610839\",\n \"0.66093385\",\n \"0.66018146\",\n \"0.65964544\",\n \"0.6590787\",\n \"0.6583664\",\n \"0.6579465\",\n \"0.65566885\",\n \"0.654532\",\n \"0.6535439\",\n \"0.65264\",\n \"0.65066075\",\n \"0.65018195\",\n \"0.64977205\",\n \"0.64880705\",\n \"0.64838105\",\n \"0.6482338\",\n \"0.6471282\",\n \"0.6456324\",\n \"0.64429426\",\n \"0.6437969\",\n \"0.6434186\",\n \"0.6430671\",\n \"0.64248866\",\n \"0.6422061\",\n \"0.64187217\",\n \"0.6415501\",\n \"0.64057857\",\n \"0.6405625\",\n \"0.6383021\",\n \"0.6382507\",\n \"0.6379643\",\n \"0.6379008\",\n \"0.6374592\",\n \"0.63709134\",\n \"0.63492906\",\n \"0.6343919\",\n \"0.6338709\",\n \"0.6336033\",\n \"0.63325256\",\n \"0.6303641\",\n \"0.63006127\",\n \"0.62986124\",\n \"0.6293778\",\n \"0.6288526\",\n \"0.62768\",\n \"0.62713164\",\n \"0.6269332\",\n \"0.6267966\",\n \"0.6265939\",\n \"0.62652904\",\n \"0.6264365\",\n \"0.62593037\",\n \"0.6247394\",\n \"0.6243793\",\n \"0.6243547\",\n \"0.6234834\",\n \"0.62270856\",\n \"0.6220194\",\n \"0.6220116\",\n \"0.6217007\",\n \"0.6207468\",\n \"0.6204805\",\n \"0.6203193\",\n \"0.6200474\",\n \"0.6193283\",\n \"0.6191528\",\n \"0.6189096\",\n \"0.6186807\",\n \"0.61808753\",\n \"0.61780614\",\n \"0.6174258\",\n \"0.61650264\",\n \"0.61644506\",\n \"0.61598307\",\n \"0.6157991\",\n \"0.6157356\",\n \"0.61559004\",\n \"0.6154523\",\n \"0.61542577\",\n \"0.61542577\",\n \"0.6145324\",\n \"0.6145211\",\n \"0.61427426\",\n \"0.614047\",\n \"0.6135176\",\n \"0.61316365\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":12192,"cells":{"query":{"kind":"string","value":"Computes the forward pass for the tanh activation function."},"document":{"kind":"string","value":"def tanh_forward(self, x):\n \n #############################################################################\n # TODO: Implement the tanh forward pass. #\n #############################################################################\n out = np.tanh(x)\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n cache = out\n return out, cache"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def forward_hidden_activation(self, X):\n return np.tanh(X)","def test_tanh_activation(self):\n self.assertEqual([0.099668, 0.099668], list(\n af.TanH().output(np.array([0.1, 0.1]))))\n self.assertEqual([0.990066, 0.990066], list(\n af.TanH().derivative(np.array([0.1, 0.1]))))","def tanh_grad(self, X):\n return 1-self.tanh(X)**2","def tanh(input, inplace=False):\n return FunctionLib.apply(\n 'Tanh', input.device, [input],\n outputs=[input if inplace else None])","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n return F.tanh(self.fc3(x))","def forward(self, x):\n # Pass the input through all the layers apllying ReLU activation, but the last\n for layer in self.fc_layers[:-1]:\n x = F.relu(layer(x))\n # Pass the result through the output layer apllying hyperbolic tangent function\n x = torch.tanh(self.fc_layers[-1](x))\n # Return the better action for the input state\n return x","def forward(self, state):#forward pass\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n return torch.tanh(self.fc3(x))","def tanh(data):\n return _make.tanh(data)","def tanh(x):\r\n # see decorator for function body\r","def forward(self, state):\n x = f.relu(self.fc1(state))\n x = f.relu(self.fc2(x))\n return torch.tanh(self.fc3(x))","def derived_tanh(x):\n return 1 - tanh(x)","def derived_tanh(x):\n return 1 - tanh(x)","def tanh(X):\n\tif isinstance(X,np.ndarray):\n\t\treturn (2.0/(1.0+np.exp(-(2*X))))-1\n\telse:\n\t\tX=np.array(X)\n\t\treturn tanh(X)","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n x = F.relu(self.fc3(x))\n x = F.relu(self.fc4(x))\n\n return F.tanh(self.fc5(x))","def tanh(x):\n raise NotImplementedError","def grad_tanh(self):\n grad = 1 - self.tanh(self.x) ** 2\n return grad","def tanh(self, x):\n self.x = x\n output = np.tanh(x)\n return output","def forward(self, state):\n \n x = F.relu(self.fc1(state)) \n x = F.relu(self.fc2(x)) \n x = F.tanh(self.fc3(x)) \n \n \n ####x = F.relu(self.bn1(self.fc1(state)))\n ####x = F.relu(self.bn2(self.fc2(x)))\n ####x = torch.tanh(self.bn3(self.fc3(x)))\n ##x = torch.tanh(self.fc3(x))\n\n return x","def forward(self, x):\n self.y = x.tanh()\n return self.y","def tanh(x):\n return 0.0","def tanh(self, X):\n return (np.exp(X)-np.exp(-X))/(np.exp(X)+np.exp(-X))","def tanh(self, x):\r\n self.x = x\r\n return np.tanh(x)","def grad_tanh(self):\r\n return 1 - np.square(self.tanh(self.x))","def tanh(self):\n return type(self)(self.parent(),\n self._simplify(self._express.tanh()))","def grad_tanh(self):\n return (1-np.tanh(self.x)*np.tanh(self.x))\n raise NotImplementedError(\"tanh gradient not implemented\")","def tanh(x):\r\n ex = np.exp(x)\r\n emx = np.exp(-x)\r\n return (ex - emx) / (ex + emx)","def tanh(x):\n return (1 - e ** (-2*x))/ (1 + e ** (-2*x))","def tanh(self):\t\t\t\t\n\t\tval = np.tanh(self.val)\n\t\tif len(self.der.shape):\n\t\t\tto_multiply = 1 / np.power(np.cosh(self.val), 2)\n\t\t\tto_multiply = np.expand_dims(to_multiply, 1) if len(self.der.shape) > len(to_multiply.shape) else to_multiply\n\t\t\tder = to_multiply * self.der\n\t\telse:\n\t\t\tder = None\n\t\treturn Var(val, der)","def tanh(obj):\n\tif isinstance(obj, Variable):\n\t\tval = np.tanh(obj.val)\n\t\tder = 1-np.tanh(obj.val)**2\n\t\tif len(obj.der.shape)>len(der.shape):\n\t\t\tder = np.expand_dims(der,1)\n\t\tder = np.multiply(der, obj.der)\n\t\treturn Variable(val, der)\n\telse:\n\t\treturn np.tanh(obj)","def tanh_grad(z):\n return 1.7159 * 2 / 3.0 * (1 - (np.tanh(2 / 3.0 * z)) ** 2)","def forward(self, state):\n\t\tx = F.relu(self.fc1(state))\n\t\tx = F.relu(self.fc2(x))\n\t\tx = F.tanh(self.fc3(x)) # outputs are in the range [-1, 1]\n\n\t\treturn x","def forward(self, state):\n x = self.fc1(state)\n action = self.tanh(x)\n\n action = action.cpu().data.numpy() * self.action_lim\n action = torch.FloatTensor(action)\n\n return action","def tanh(d: D) -> NumDict:\n\n return (2 * sigmoid(d)) - 1","def tanh(x):\n return (1- power(e,(-2*x))) / (1 + power(e,(-2*x)))","def d_tanh(x):\n return 1. - np.power(np.tanh(x), 2)","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = self.fc2(x)\n action = self.tanh(x)\n\n action = action.cpu().data.numpy() * self.action_lim\n action = torch.FloatTensor(action)\n\n return action","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n x = self.fc3(x)\n action = self.tanh(x)\n\n action = action.cpu().data.numpy() * self.action_lim\n action = torch.FloatTensor(action)\n\n return action","def create_tanh(x, bias):\n\n return tf.nn.tanh(tf.nn.bias_add(x, bias))","def makeFastFeedForwardFunction(self):\n\n\t\toutWeightMatrix = []\n\t\tfor unit in self.outputLayer:\n\n\t\t\trow = []\n\t\t\tfor b in unit.branchesIn:\n\t\t\t\tprint b.weight\n\t\t\t\trow.append(b.weight)\n\t\t\t\n\t\t\toutWeightMatrix.append(row)\n\t\toutWeightMatrix = np.array(outWeightMatrix).squeeze()\n\n\t\thiddenMatrices = []\n\t\tfor layer in self.hiddenLayers:\n\t\t\tmatrix = []\n\t\t\t#ignore the bias unit, since it has no branches in\n\t\t\tfor unit in layer[1:]:\n\t\t\t\trow = []\n\t\t\t\tfor b in unit.branchesIn:\n\t\t\t\t\trow.append(b.weight)\n\n\t\t\t\tmatrix.append(row)\n\t\t\tmatrix = np.array(matrix)\n\n\t\t\thiddenMatrices.append(matrix)\n\n\t\thidActFunc = (self.hiddenLayers[0])[1].activationFunction\n\t\toutActFunc = self.outputLayer[0].activationFunction\n\n\t\tdef ffFunc(inp):\n\t\n\t\t\tforward = np.insert(inp.T,0,1.0,axis=0)\n\t\t\tfor matrix in hiddenMatrices:\n\t\t\t\tnext = np.dot(matrix,forward)\n\t\t\t\tnext = hidActFunc(next)\n\t\t\t\tforward = np.insert(next,0,1.0,axis=0)\n\n\t\t\tout = np.dot(outWeightMatrix,forward)\n\n\t\t\treturn outActFunc(out)\n\n\t\treturn ffFunc","def forward(self, y, h):\n y = y.transpose(1, 0)\n\n t = self.linear_in(h)\n target = self.linear_in(h).unsqueeze(2) # batch x dim x 1\n\n # Get attention\n attn = torch.bmm(y, target).squeeze(2) # batch x T\n attn = F.softmax(attn, dim=1)\n attn3 = attn.view(attn.size(0), 1, attn.size(1)) # batch x 1 x T\n\n weighted_y = torch.bmm(attn3, y).squeeze(1) # batch x dim\n h_tilde = torch.cat((weighted_y, h), 1)\n\n h_tilde = torch.tanh(self.linear_out(h_tilde))\n\n return h_tilde, attn","def tanh(a):","def d_tanh(x):\n\n return 1 - x.tanh().pow(2)","def forward(self, state):\n x = F.relu(self.linear1(state))\n x = F.relu(self.linear2(x))\n x = torch.tanh(self.linear3(x))\n\n return x","def forward(self, t, h):\n if self.i == 0:\n self.A = self.beta * (self.B - self.B.transpose(1, 0)) + (\n 1 - self.beta) * (self.B +\n self.B.transpose(1, 0)) - self.gamma * self.I\n self.W = self.beta * (self.C - self.C.transpose(1, 0)) + (\n 1 - self.beta) * (self.C +\n self.C.transpose(1, 0)) - self.gamma * self.I\n\n return torch.matmul(\n h, self.A) + self.tanh(torch.matmul(h, self.W) + self.z)","def tanh_backward(dA, internal_params):\n Z = internal_params\n Zt=tanh(Z)\n dzp=np.power(Zt,2)\n print(dzp.shape)\n dZ=np.multiply(dzp,dA)\n return dZ\n # raise NotImplementedError","def forward(self, t, x):\n\n out = F.relu(self.l1(t, x))\n out = F.sigmoid(self.l2(t, out))\n\n return out","def compute_hidden(self, a_h):\n if self.relu:\n return a_h*(a_h > 0)\n else:\n return np.tanh(a_h)","def convert_tanh(node, **kwargs):\n return create_basic_op_node('Tanh', node, kwargs)","def forward(self, a):\n if self.activation_type == \"sigmoid\":\n return self.sigmoid(a)\n\n elif self.activation_type == \"tanh\":\n return self.tanh(a)\n\n elif self.activation_type == \"ReLU\":\n return self.ReLU(a)","def forward(W,X):\n return activation_func(np.dot(add_bias(X),W))","def _rnn_tanh_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):\n if b_ih is None:\n igates = P.MatMul(False, True)(inputs, w_ih)\n hgates = P.MatMul(False, True)(hidden, w_hh)\n else:\n igates = P.MatMul(False, True)(inputs, w_ih) + b_ih\n hgates = P.MatMul(False, True)(hidden, w_hh) + b_hh\n return P.Tanh()(igates + hgates)","def forward_step_layer(t1, t2, activation_f=torchfun.relu):\n return batch_norm_tensor(activation_f(t1.bmm(t2)))","def tanh(x:float)->float:\n if not isinstance(x, numbers.Real):\n raise TypeError(\"Input value of invalid type\")\n\n return(math.tanh(x))","def forward(self, x):\n x = self.first_deconv(x)\n x = self.first_batch_norm(x)\n x = F.leaky_relu(x)\n\n x = self.second_deconv(x)\n x = self.second_batch_norm(x)\n x = F.leaky_relu(x)\n\n x = self.third_deconv(x)\n x = self.third_batch_norm(x)\n x = F.leaky_relu(x)\n\n x = self.fourth_deconv(x)\n x = self.fourth_batch_norm(x)\n\n x = self.fifth_deconv(x)\n x = self.fifth_batch_norm(x)\n\n x = self.sixth_deconv(x)\n x = self.sixth_batch_norm(x)\n\n x = self.seventh_deconv(x)\n\n # sigmoid_out = nn.functional.sigmoid(x)\n tanh_out = nn.functional.tanh(x)\n\n out = (tanh_out + 1) * 255 / 2\n\n # print 'out.shape =', out.shape\n\n return out","def forward(self, input):\n input, _ = input\n bs = input.shape[0]\n d1 = self.relu1(self.fc1(input))\n d2 = self.relu2(self.fc2(d1))\n d3 = self.fc3(d2)\n out = self.sigmoid(d3)\n\n out = out.view(bs, 17, 3)\n return out","def one_step(self, x, h):\n concatHX = torch.cat((x, h), 1)\n ft = self.sigmoid(self.linearF(concatHX))\n it = self.sigmoid(self.linearI(concatHX))\n newCt = ft*self.ct.clone() + it*self.tanh(self.linearC(concatHX))\n #self.ct = ft*self.ct.clone() + it*self.tanh(self.linearC(concatHX))\n ot = self.sigmoid(self.linearO(concatHX))\n ht = ot*self.tanh(newCt)\n self.ct = newCt\n \n return ht","def tanh(self, z, deriv=False):\n return np.tanh(z) if not deriv else 1 - np.square(np.tanh(z))","def tanh(self):\r\n getcontext().prec += 2\r\n re2 = 2 * self._real\r\n im2 = 2 * self._imag\r\n den = cosh(re2) + cos(im2)\r\n ans = self.__class__(sinh(re2) / den, sin(im2) / den)\r\n getcontext().prec -= 2\r\n return +ans","def _forward(z: np.array, W: np.array, b: np.array,\n activation: str) -> np.array:\n a = np.dot(z, W) + b\n if activation == 'sigmoid':\n return sigmoid(a)\n elif activation == 'identity':\n return identity(a)","def forward(inputs,weights,function=sigmoid,step=-1):\n if step == 0:\n return inputs\n elif step == -1:\n step = len(weights) #go to output layer \n output = np.append(1, inputs)\n for i in range(step):\n output = np.append(1, function(np.dot(weights[i], output))) #calculating activation\n return output[1:]","def __tanh_old(self, x):\n return np.tanh(x)","def tanh(tensor, method=\"sigmoid\"):\n if method == \"sigmoid\":\n return _tanh_sigmoid(tensor)\n else:\n raise ValueError(f\"Invalid method {method} given for tanh function\")","def forward(self, inputs, state):\n h, = state\n outputs = []\n for x in inputs:\n h = nd.tanh(nd.dot(x, self.w_xh) + nd.dot(h, self.w_hh) + self.b_h)\n y = nd.dot(h, self.w_hq) + self.b_q\n outputs.append(y)\n y_hat = nd.concat(*outputs, dim=0)\n return y_hat, (h,)","def tanh_backward(dA, Z):\n\n s = 1 - tanh(Z)**2\n dZ = dA * s\n\n assert (dZ.shape == Z.shape)\n\n return dZ","def forward(self, state):\n\n x = state # Careful: deepcopy bug?\n # Intermediate Layers\n for layer in self.layers[:-1]:\n\n x = nn.ReLU()(layer(x))\n\n x = nn.Tanh()(self.layers[-1](x))\n return x","def tanh_inplace(a):","def forward(self, x):\n\n\t\t## Conv layers\n\t\tx = self.avgpool(F.tanh(self.conv1(x)))\n\t\tx = self.avgpool(F.tanh(self.conv2(x)))\n\t\tx = F.tanh(self.conv3(x))\n\n\t\t## Flatten\n\t\tx = x.view(x.size(0), -1)\n\n\t\t## Fully connected layers\n\t\tx = F.tanh(self.fc1(x))\n\t\tx = self.fc2(x)\n\n\t\tx = F.softmax(x, dim=1)\n\n\t\treturn x","def d_tanh(x:float)->float:\n if not isinstance(x, numbers.Real):\n raise TypeError(\"Input value of invalid type\")\n\n return(1 - math.pow(math.tanh(x), 2))","def _sigmoid_to_tanh(x):\n return (x - 0.5) * 2.","def forward(self, inputs):\n x = F.relu(self.bn_1(self.conv_1(inputs)))\n\n # If it is the last layer, use sigmoid activation instead of hyperbolic tangent\n if self.last:\n x = F.tanh(self.bn_2(self.conv_2(x)))\n else:\n x = F.relu(self.bn_2(self.conv_2(x)))\n\n # Performing max pooling if needed\n if self.pool:\n x, indices = self.max_pool(x)\n\n return x","def _tanh_sigmoid(tensor):\n return 2 * sigmoid(2 * tensor) - 1","def activation(x):\n # return np.tanh(x)\n return np.maximum(0,x)","def train_layer(self, h, t):\n\n mr1h = torch.matmul(h, self.mr1.weight) # h => [m, self.ent_hidden_size], self.mr1 => [self.ent_hidden_size, self.rel_hidden_size]\n mr2t = torch.matmul(t, self.mr2.weight) # t => [m, self.ent_hidden_size], self.mr2 => [self.ent_hidden_size, self.rel_hidden_size]\n\n expanded_h = h.unsqueeze(dim=0).repeat(self.rel_hidden_size, 1, 1) # [self.rel_hidden_size, m, self.ent_hidden_size]\n expanded_t = t.unsqueeze(dim=-1) # [m, self.ent_hidden_size, 1]\n\n temp = (torch.matmul(expanded_h, self.mr.weight.view(self.rel_hidden_size, self.ent_hidden_size, self.ent_hidden_size))).permute(1, 0, 2) # [m, self.rel_hidden_size, self.ent_hidden_size]\n htmrt = torch.squeeze(torch.matmul(temp, expanded_t), dim=-1) # [m, self.rel_hidden_size]\n\n return F.tanh(htmrt + mr1h + mr2t + self.br.weight)","def forward(self, x):\n h = self.l1(x)\n h = h.view(x.shape[0], -1, self.bottom_width, self.bottom_width)\n h = self.block2(h)\n h = self.block3(h)\n h = self.block4(h)\n h = self.block5(h)\n h = self.b6(h)\n h = self.activation(h)\n h = torch.tanh(self.c6(h))\n\n return h","def tanh(Z):\n\n e_2_z = np.exp(2*Z)\n\n A = (e_2_z - 1) / (e_2_z + 1)\n\n internal_params = Z\n return A, internal_params","def forward_pass(self, h_tm1, x_t): # Function though to be used by tf.scan\n\n # Convert vector-tensor form into matrix-tensor form\n x_t = tf.reshape(x_t, shape=[1, -1])\n h_tm1 = tf.reshape(h_tm1, shape=[1, -1])\n\n # Definitions of z_t and r_t\n z_t = tf.sigmoid(tf.matmul(x_t, self.Wz) + tf.matmul(h_tm1, self.Uz) + self.bz)\n r_t = tf.sigmoid(tf.matmul(x_t, self.Wr) + tf.matmul(h_tm1, self.Ur) + self.br)\n\n # Definition of h~_t\n h_proposal = tf.tanh(tf.matmul(x_t, self.Wh) + tf.matmul(tf.multiply(r_t, h_tm1), self.Uh) + self.bh)\n\n # Compute the next hidden state\n h_t = tf.multiply(1 - z_t, h_tm1) + tf.multiply(z_t, h_proposal)\n\n return tf.squeeze(h_t)","def f1(phi, phi_o, d):\n return 1 - sigmoid_decay(phi, phi_o, d)","def one_step(i_t, h_tm1):\n h_t = self.activation(T.dot(i_t, self.W) + T.dot(h_tm1, self.W_rec) + self.b)\n return h_t","def forward(self, state: list) -> list:\n x = F.relu(self.fc1_layer(state))\n x = F.relu(self.fc2_layer(x))\n x = F.tanh(self.fc3_layer(x))\n\n return x","def forward_activationfunction(self, x):\n if self.forward_activation == 'tanh':\n return torch.tanh(x)\n elif self.forward_activation == 'relu':\n return F.relu(x)\n elif self.forward_activation == 'linear':\n return x\n elif self.forward_activation == 'leakyrelu':\n return F.leaky_relu(x, 0.2)\n elif self.forward_activation == 'sigmoid':\n return torch.sigmoid(x)\n else:\n raise ValueError('The provided forward activation {} is not '\n 'supported'.format(self.forward_activation))","def feed_forward(self):\n self.hidden_activation = self._sigmoid(np.dot(self.input_activation, self.w1))\n self.output_activation = self._sigmoid(np.dot(self.hidden_activation, self.w2))","def activation(h):\n\n if(h > 0):\n return 1\n\n else:\n return 0","def forward(self, h_prev, x_t):\n hidden_con = np.concatenate((h_prev.T, x_t.T), axis=0)\n h_next = np.tanh((np.matmul(hidden_con.T, self.Wh)) + self.bh)\n y = self.softmax((np.matmul(h_next, self.Wy)) + self.by)\n return h_next, y","def scaled_tanh(self, x):\r\n return tf.keras.backend.tanh(x) * 3","def one_step(self, x, h):\n concatHX = torch.cat((x, h), 1)\n zt = self.sigmoid(self.linearZ(concatHX))\n rt = self.sigmoid(self.linearR(concatHX))\n ht = (1-zt)*h + zt* self.tanh(self.linearH(rt*concatHX))\n return ht","def one_step(self, x, h):\n concatHX = torch.cat((x, h), 1)\n ft = self.sigmoid(self.linearF(concatHX))\n it = self.sigmoid(self.linearI(concatHX))\n ct = ft*self.cts[-1] + it*self.tanh(self.linearC(concatHX))\n #self.ct = ft*self.ct.clone() + it*self.tanh(self.linearC(concatHX))\n ot = self.sigmoid(self.linearO(concatHX))\n ht = ot*self.tanh(ct)\n \n self.cts.append(ct)\n \n return ht","def forward(self, h_prev, x_t):\n h_concat_x = np.concatenate((h_prev.T, x_t.T), axis=0)\n h_next = np.tanh((np.matmul(h_concat_x.T, self.Wh)) + self.bh)\n y = self.softmax((np.matmul(h_next, self.Wy)) + self.by)\n\n return h_next, y","def forward(self, x):\n h = self.l1(x)\n h = h.view(x.shape[0], -1, self.bottom_width, self.bottom_width)\n h = self.block2(h)\n h = self.block3(h)\n h = self.block4(h)\n h = self.b5(h)\n h = self.activation(h)\n h = torch.tanh(self.c5(h))\n\n return h","def layer(self, h, t):\n mr1h = torch.matmul(h, self.mr1.weight) # h => [m, d], self.mr1 => [d, k]\n mr2t = torch.matmul(t, self.mr2.weight) # t => [m, d], self.mr2 => [d, k]\n return torch.tanh(mr1h + mr2t)","def forward(self, x):\n\n x = self.first_conv_layer(x)\n x = self.second_conv_layer(x)\n x = self.third_conv_layer(x)\n x = self.fourth_conv_layer(x)\n x = self.fifth_conv_layer(x)\n\n '''\n x = x.view(-1, 4 * 4 * 512)\n x = F.relu(self.fc1(x))\n x = F.relu(self.fc2(x))\n '''\n\n sigmoid_out = nn.functional.sigmoid(x)\n\n return sigmoid_out","def forward(self, x):\n # get hidden layer input\n if self.layer == 1:\n out = torch.tanh(self.fc1(x))\n y_pred = self.fc_end(out)\n return y_pred\n elif self.layer == 2:\n out1 = torch.tanh(self.fc1(x))\n x = torch.tanh(self.fc2_1(x))\n out2 = torch.tanh(self.fc2_2(x))\n out = (out1+out2)/2\n y_pred = self.fc_end(out)\n return y_pred\n else:\n out1 = torch.tanh(self.fc1(x))\n x = torch.tanh(self.fc2_1(x))\n out3 = torch.tanh(self.fc3_1(x))\n out3 = torch.tanh(self.fc3_2(out3))\n out3 = (out3 + x)/2\n out2 = torch.tanh(self.fc2_2(out3))\n out = (out1 + out2)/2\n y_pred = self.fc_end(out)\n return y_pred","def forward(self, x):\n\n x = self.first_conv_layer(x)\n x = self.second_conv_layer(x)\n x = self.third_conv_layer(x)\n x = self.fourth_conv_layer(x)\n\n #print 'x.shape=', x.shape\n x = x.view(-1, 5 * 5 * 64)\n x = F.relu(self.fc1(x))\n\n sigmoid_out = nn.functional.sigmoid(x)\n\n return sigmoid_out","def activationFunction(self, z):\n if self.__activation == 'sig':\n activation = 1 / (1 + np.exp(-z))\n else:\n tanhnum = np.exp(z) - np.exp(-z)\n tanhden = np.exp(z) + np.exp(-z)\n activation = tanhnum / tanhden\n return activation","def forwardpass_train(self, X):\n # hidden_1\n h1_input = np.dot(X, self.W1) + self.b1\n h1_output = functions.relu(h1_input)\n # hidden_2\n h2_input = np.dot(h1_output, self.W2) + self.b2\n h2_output = functions.relu(h2_input)\n # output\n o_input = np.dot(h2_output, self.W3) + self.b3\n final_output = functions.softmax(o_input)\n return h1_input, h1_output, h2_input, h2_output, final_output","def d_act_f(self, p):\n if self.activation is None:\n return p\n if self.activation == \"tanh\":\n return 1 - np.tanh(p)**2\n if self.activation == \"sigmoid\":\n return (1 / (1 + np.exp(-p))) * (1 - (1 / (1 + np.exp(-p))))\n if self.activation == \"relu\":\n p[np.where(p < 0)] = 0\n return p\n\n return p","def forward(self, x):\r\n y = self.en_fc1(x)\r\n y = F.relu(y)\r\n y = self.en_fc2(y)\r\n y = F.relu(y)\r\n y = self.en_fc3(y)\r\n y = F.relu(y)\r\n\r\n mean = self.en_mu(y)\r\n stddev_p = self.en_log(y)\r\n \r\n n = x.shape[0]\r\n z = torch.randn(n,self.latent_dim)\r\n std = torch.exp(stddev_p/2.0)\r\n z = z.mul(std) + mean\r\n \r\n xhat = self.de_fc1(z)\r\n xhat = F.relu(xhat)\r\n xhat = self.de_fc2(xhat)\r\n xhat = F.relu(xhat)\r\n xhat = self.de_fc3(xhat)\r\n xhat = F.sigmoid(xhat)\r\n \r\n return y,mean,stddev_p,z,xhat","def gradient_hidden(self, h):\n if self.relu:\n return 1.0*(h > 0)\n else:\n return 1 - h * h","def forward(self, state):\n #pass\n #forward through each layer in \"hidden layer\", with ReLU activation unit between them\n for linear in self.hidden_layers:\n state = F.relu(linear(state))\n \n state = self.output(state)\n return state#F.log_softmax(state, dim=1)","def convert_tanhshrink(g, op, block):\n\n x = g.get_node(op.input(\"X\")[0])\n out = x - _op.tanh(x)\n g.add_node(op.output(\"Out\")[0], out)","def tan(x):\r\n # see decorator for function body\r"],"string":"[\n \"def forward_hidden_activation(self, X):\\n return np.tanh(X)\",\n \"def test_tanh_activation(self):\\n self.assertEqual([0.099668, 0.099668], list(\\n af.TanH().output(np.array([0.1, 0.1]))))\\n self.assertEqual([0.990066, 0.990066], list(\\n af.TanH().derivative(np.array([0.1, 0.1]))))\",\n \"def tanh_grad(self, X):\\n return 1-self.tanh(X)**2\",\n \"def tanh(input, inplace=False):\\n return FunctionLib.apply(\\n 'Tanh', input.device, [input],\\n outputs=[input if inplace else None])\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n return F.tanh(self.fc3(x))\",\n \"def forward(self, x):\\n # Pass the input through all the layers apllying ReLU activation, but the last\\n for layer in self.fc_layers[:-1]:\\n x = F.relu(layer(x))\\n # Pass the result through the output layer apllying hyperbolic tangent function\\n x = torch.tanh(self.fc_layers[-1](x))\\n # Return the better action for the input state\\n return x\",\n \"def forward(self, state):#forward pass\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n return torch.tanh(self.fc3(x))\",\n \"def tanh(data):\\n return _make.tanh(data)\",\n \"def tanh(x):\\r\\n # see decorator for function body\\r\",\n \"def forward(self, state):\\n x = f.relu(self.fc1(state))\\n x = f.relu(self.fc2(x))\\n return torch.tanh(self.fc3(x))\",\n \"def derived_tanh(x):\\n return 1 - tanh(x)\",\n \"def derived_tanh(x):\\n return 1 - tanh(x)\",\n \"def tanh(X):\\n\\tif isinstance(X,np.ndarray):\\n\\t\\treturn (2.0/(1.0+np.exp(-(2*X))))-1\\n\\telse:\\n\\t\\tX=np.array(X)\\n\\t\\treturn tanh(X)\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n x = F.relu(self.fc3(x))\\n x = F.relu(self.fc4(x))\\n\\n return F.tanh(self.fc5(x))\",\n \"def tanh(x):\\n raise NotImplementedError\",\n \"def grad_tanh(self):\\n grad = 1 - self.tanh(self.x) ** 2\\n return grad\",\n \"def tanh(self, x):\\n self.x = x\\n output = np.tanh(x)\\n return output\",\n \"def forward(self, state):\\n \\n x = F.relu(self.fc1(state)) \\n x = F.relu(self.fc2(x)) \\n x = F.tanh(self.fc3(x)) \\n \\n \\n ####x = F.relu(self.bn1(self.fc1(state)))\\n ####x = F.relu(self.bn2(self.fc2(x)))\\n ####x = torch.tanh(self.bn3(self.fc3(x)))\\n ##x = torch.tanh(self.fc3(x))\\n\\n return x\",\n \"def forward(self, x):\\n self.y = x.tanh()\\n return self.y\",\n \"def tanh(x):\\n return 0.0\",\n \"def tanh(self, X):\\n return (np.exp(X)-np.exp(-X))/(np.exp(X)+np.exp(-X))\",\n \"def tanh(self, x):\\r\\n self.x = x\\r\\n return np.tanh(x)\",\n \"def grad_tanh(self):\\r\\n return 1 - np.square(self.tanh(self.x))\",\n \"def tanh(self):\\n return type(self)(self.parent(),\\n self._simplify(self._express.tanh()))\",\n \"def grad_tanh(self):\\n return (1-np.tanh(self.x)*np.tanh(self.x))\\n raise NotImplementedError(\\\"tanh gradient not implemented\\\")\",\n \"def tanh(x):\\r\\n ex = np.exp(x)\\r\\n emx = np.exp(-x)\\r\\n return (ex - emx) / (ex + emx)\",\n \"def tanh(x):\\n return (1 - e ** (-2*x))/ (1 + e ** (-2*x))\",\n \"def tanh(self):\\t\\t\\t\\t\\n\\t\\tval = np.tanh(self.val)\\n\\t\\tif len(self.der.shape):\\n\\t\\t\\tto_multiply = 1 / np.power(np.cosh(self.val), 2)\\n\\t\\t\\tto_multiply = np.expand_dims(to_multiply, 1) if len(self.der.shape) > len(to_multiply.shape) else to_multiply\\n\\t\\t\\tder = to_multiply * self.der\\n\\t\\telse:\\n\\t\\t\\tder = None\\n\\t\\treturn Var(val, der)\",\n \"def tanh(obj):\\n\\tif isinstance(obj, Variable):\\n\\t\\tval = np.tanh(obj.val)\\n\\t\\tder = 1-np.tanh(obj.val)**2\\n\\t\\tif len(obj.der.shape)>len(der.shape):\\n\\t\\t\\tder = np.expand_dims(der,1)\\n\\t\\tder = np.multiply(der, obj.der)\\n\\t\\treturn Variable(val, der)\\n\\telse:\\n\\t\\treturn np.tanh(obj)\",\n \"def tanh_grad(z):\\n return 1.7159 * 2 / 3.0 * (1 - (np.tanh(2 / 3.0 * z)) ** 2)\",\n \"def forward(self, state):\\n\\t\\tx = F.relu(self.fc1(state))\\n\\t\\tx = F.relu(self.fc2(x))\\n\\t\\tx = F.tanh(self.fc3(x)) # outputs are in the range [-1, 1]\\n\\n\\t\\treturn x\",\n \"def forward(self, state):\\n x = self.fc1(state)\\n action = self.tanh(x)\\n\\n action = action.cpu().data.numpy() * self.action_lim\\n action = torch.FloatTensor(action)\\n\\n return action\",\n \"def tanh(d: D) -> NumDict:\\n\\n return (2 * sigmoid(d)) - 1\",\n \"def tanh(x):\\n return (1- power(e,(-2*x))) / (1 + power(e,(-2*x)))\",\n \"def d_tanh(x):\\n return 1. - np.power(np.tanh(x), 2)\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = self.fc2(x)\\n action = self.tanh(x)\\n\\n action = action.cpu().data.numpy() * self.action_lim\\n action = torch.FloatTensor(action)\\n\\n return action\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n x = self.fc3(x)\\n action = self.tanh(x)\\n\\n action = action.cpu().data.numpy() * self.action_lim\\n action = torch.FloatTensor(action)\\n\\n return action\",\n \"def create_tanh(x, bias):\\n\\n return tf.nn.tanh(tf.nn.bias_add(x, bias))\",\n \"def makeFastFeedForwardFunction(self):\\n\\n\\t\\toutWeightMatrix = []\\n\\t\\tfor unit in self.outputLayer:\\n\\n\\t\\t\\trow = []\\n\\t\\t\\tfor b in unit.branchesIn:\\n\\t\\t\\t\\tprint b.weight\\n\\t\\t\\t\\trow.append(b.weight)\\n\\t\\t\\t\\n\\t\\t\\toutWeightMatrix.append(row)\\n\\t\\toutWeightMatrix = np.array(outWeightMatrix).squeeze()\\n\\n\\t\\thiddenMatrices = []\\n\\t\\tfor layer in self.hiddenLayers:\\n\\t\\t\\tmatrix = []\\n\\t\\t\\t#ignore the bias unit, since it has no branches in\\n\\t\\t\\tfor unit in layer[1:]:\\n\\t\\t\\t\\trow = []\\n\\t\\t\\t\\tfor b in unit.branchesIn:\\n\\t\\t\\t\\t\\trow.append(b.weight)\\n\\n\\t\\t\\t\\tmatrix.append(row)\\n\\t\\t\\tmatrix = np.array(matrix)\\n\\n\\t\\t\\thiddenMatrices.append(matrix)\\n\\n\\t\\thidActFunc = (self.hiddenLayers[0])[1].activationFunction\\n\\t\\toutActFunc = self.outputLayer[0].activationFunction\\n\\n\\t\\tdef ffFunc(inp):\\n\\t\\n\\t\\t\\tforward = np.insert(inp.T,0,1.0,axis=0)\\n\\t\\t\\tfor matrix in hiddenMatrices:\\n\\t\\t\\t\\tnext = np.dot(matrix,forward)\\n\\t\\t\\t\\tnext = hidActFunc(next)\\n\\t\\t\\t\\tforward = np.insert(next,0,1.0,axis=0)\\n\\n\\t\\t\\tout = np.dot(outWeightMatrix,forward)\\n\\n\\t\\t\\treturn outActFunc(out)\\n\\n\\t\\treturn ffFunc\",\n \"def forward(self, y, h):\\n y = y.transpose(1, 0)\\n\\n t = self.linear_in(h)\\n target = self.linear_in(h).unsqueeze(2) # batch x dim x 1\\n\\n # Get attention\\n attn = torch.bmm(y, target).squeeze(2) # batch x T\\n attn = F.softmax(attn, dim=1)\\n attn3 = attn.view(attn.size(0), 1, attn.size(1)) # batch x 1 x T\\n\\n weighted_y = torch.bmm(attn3, y).squeeze(1) # batch x dim\\n h_tilde = torch.cat((weighted_y, h), 1)\\n\\n h_tilde = torch.tanh(self.linear_out(h_tilde))\\n\\n return h_tilde, attn\",\n \"def tanh(a):\",\n \"def d_tanh(x):\\n\\n return 1 - x.tanh().pow(2)\",\n \"def forward(self, state):\\n x = F.relu(self.linear1(state))\\n x = F.relu(self.linear2(x))\\n x = torch.tanh(self.linear3(x))\\n\\n return x\",\n \"def forward(self, t, h):\\n if self.i == 0:\\n self.A = self.beta * (self.B - self.B.transpose(1, 0)) + (\\n 1 - self.beta) * (self.B +\\n self.B.transpose(1, 0)) - self.gamma * self.I\\n self.W = self.beta * (self.C - self.C.transpose(1, 0)) + (\\n 1 - self.beta) * (self.C +\\n self.C.transpose(1, 0)) - self.gamma * self.I\\n\\n return torch.matmul(\\n h, self.A) + self.tanh(torch.matmul(h, self.W) + self.z)\",\n \"def tanh_backward(dA, internal_params):\\n Z = internal_params\\n Zt=tanh(Z)\\n dzp=np.power(Zt,2)\\n print(dzp.shape)\\n dZ=np.multiply(dzp,dA)\\n return dZ\\n # raise NotImplementedError\",\n \"def forward(self, t, x):\\n\\n out = F.relu(self.l1(t, x))\\n out = F.sigmoid(self.l2(t, out))\\n\\n return out\",\n \"def compute_hidden(self, a_h):\\n if self.relu:\\n return a_h*(a_h > 0)\\n else:\\n return np.tanh(a_h)\",\n \"def convert_tanh(node, **kwargs):\\n return create_basic_op_node('Tanh', node, kwargs)\",\n \"def forward(self, a):\\n if self.activation_type == \\\"sigmoid\\\":\\n return self.sigmoid(a)\\n\\n elif self.activation_type == \\\"tanh\\\":\\n return self.tanh(a)\\n\\n elif self.activation_type == \\\"ReLU\\\":\\n return self.ReLU(a)\",\n \"def forward(W,X):\\n return activation_func(np.dot(add_bias(X),W))\",\n \"def _rnn_tanh_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):\\n if b_ih is None:\\n igates = P.MatMul(False, True)(inputs, w_ih)\\n hgates = P.MatMul(False, True)(hidden, w_hh)\\n else:\\n igates = P.MatMul(False, True)(inputs, w_ih) + b_ih\\n hgates = P.MatMul(False, True)(hidden, w_hh) + b_hh\\n return P.Tanh()(igates + hgates)\",\n \"def forward_step_layer(t1, t2, activation_f=torchfun.relu):\\n return batch_norm_tensor(activation_f(t1.bmm(t2)))\",\n \"def tanh(x:float)->float:\\n if not isinstance(x, numbers.Real):\\n raise TypeError(\\\"Input value of invalid type\\\")\\n\\n return(math.tanh(x))\",\n \"def forward(self, x):\\n x = self.first_deconv(x)\\n x = self.first_batch_norm(x)\\n x = F.leaky_relu(x)\\n\\n x = self.second_deconv(x)\\n x = self.second_batch_norm(x)\\n x = F.leaky_relu(x)\\n\\n x = self.third_deconv(x)\\n x = self.third_batch_norm(x)\\n x = F.leaky_relu(x)\\n\\n x = self.fourth_deconv(x)\\n x = self.fourth_batch_norm(x)\\n\\n x = self.fifth_deconv(x)\\n x = self.fifth_batch_norm(x)\\n\\n x = self.sixth_deconv(x)\\n x = self.sixth_batch_norm(x)\\n\\n x = self.seventh_deconv(x)\\n\\n # sigmoid_out = nn.functional.sigmoid(x)\\n tanh_out = nn.functional.tanh(x)\\n\\n out = (tanh_out + 1) * 255 / 2\\n\\n # print 'out.shape =', out.shape\\n\\n return out\",\n \"def forward(self, input):\\n input, _ = input\\n bs = input.shape[0]\\n d1 = self.relu1(self.fc1(input))\\n d2 = self.relu2(self.fc2(d1))\\n d3 = self.fc3(d2)\\n out = self.sigmoid(d3)\\n\\n out = out.view(bs, 17, 3)\\n return out\",\n \"def one_step(self, x, h):\\n concatHX = torch.cat((x, h), 1)\\n ft = self.sigmoid(self.linearF(concatHX))\\n it = self.sigmoid(self.linearI(concatHX))\\n newCt = ft*self.ct.clone() + it*self.tanh(self.linearC(concatHX))\\n #self.ct = ft*self.ct.clone() + it*self.tanh(self.linearC(concatHX))\\n ot = self.sigmoid(self.linearO(concatHX))\\n ht = ot*self.tanh(newCt)\\n self.ct = newCt\\n \\n return ht\",\n \"def tanh(self, z, deriv=False):\\n return np.tanh(z) if not deriv else 1 - np.square(np.tanh(z))\",\n \"def tanh(self):\\r\\n getcontext().prec += 2\\r\\n re2 = 2 * self._real\\r\\n im2 = 2 * self._imag\\r\\n den = cosh(re2) + cos(im2)\\r\\n ans = self.__class__(sinh(re2) / den, sin(im2) / den)\\r\\n getcontext().prec -= 2\\r\\n return +ans\",\n \"def _forward(z: np.array, W: np.array, b: np.array,\\n activation: str) -> np.array:\\n a = np.dot(z, W) + b\\n if activation == 'sigmoid':\\n return sigmoid(a)\\n elif activation == 'identity':\\n return identity(a)\",\n \"def forward(inputs,weights,function=sigmoid,step=-1):\\n if step == 0:\\n return inputs\\n elif step == -1:\\n step = len(weights) #go to output layer \\n output = np.append(1, inputs)\\n for i in range(step):\\n output = np.append(1, function(np.dot(weights[i], output))) #calculating activation\\n return output[1:]\",\n \"def __tanh_old(self, x):\\n return np.tanh(x)\",\n \"def tanh(tensor, method=\\\"sigmoid\\\"):\\n if method == \\\"sigmoid\\\":\\n return _tanh_sigmoid(tensor)\\n else:\\n raise ValueError(f\\\"Invalid method {method} given for tanh function\\\")\",\n \"def forward(self, inputs, state):\\n h, = state\\n outputs = []\\n for x in inputs:\\n h = nd.tanh(nd.dot(x, self.w_xh) + nd.dot(h, self.w_hh) + self.b_h)\\n y = nd.dot(h, self.w_hq) + self.b_q\\n outputs.append(y)\\n y_hat = nd.concat(*outputs, dim=0)\\n return y_hat, (h,)\",\n \"def tanh_backward(dA, Z):\\n\\n s = 1 - tanh(Z)**2\\n dZ = dA * s\\n\\n assert (dZ.shape == Z.shape)\\n\\n return dZ\",\n \"def forward(self, state):\\n\\n x = state # Careful: deepcopy bug?\\n # Intermediate Layers\\n for layer in self.layers[:-1]:\\n\\n x = nn.ReLU()(layer(x))\\n\\n x = nn.Tanh()(self.layers[-1](x))\\n return x\",\n \"def tanh_inplace(a):\",\n \"def forward(self, x):\\n\\n\\t\\t## Conv layers\\n\\t\\tx = self.avgpool(F.tanh(self.conv1(x)))\\n\\t\\tx = self.avgpool(F.tanh(self.conv2(x)))\\n\\t\\tx = F.tanh(self.conv3(x))\\n\\n\\t\\t## Flatten\\n\\t\\tx = x.view(x.size(0), -1)\\n\\n\\t\\t## Fully connected layers\\n\\t\\tx = F.tanh(self.fc1(x))\\n\\t\\tx = self.fc2(x)\\n\\n\\t\\tx = F.softmax(x, dim=1)\\n\\n\\t\\treturn x\",\n \"def d_tanh(x:float)->float:\\n if not isinstance(x, numbers.Real):\\n raise TypeError(\\\"Input value of invalid type\\\")\\n\\n return(1 - math.pow(math.tanh(x), 2))\",\n \"def _sigmoid_to_tanh(x):\\n return (x - 0.5) * 2.\",\n \"def forward(self, inputs):\\n x = F.relu(self.bn_1(self.conv_1(inputs)))\\n\\n # If it is the last layer, use sigmoid activation instead of hyperbolic tangent\\n if self.last:\\n x = F.tanh(self.bn_2(self.conv_2(x)))\\n else:\\n x = F.relu(self.bn_2(self.conv_2(x)))\\n\\n # Performing max pooling if needed\\n if self.pool:\\n x, indices = self.max_pool(x)\\n\\n return x\",\n \"def _tanh_sigmoid(tensor):\\n return 2 * sigmoid(2 * tensor) - 1\",\n \"def activation(x):\\n # return np.tanh(x)\\n return np.maximum(0,x)\",\n \"def train_layer(self, h, t):\\n\\n mr1h = torch.matmul(h, self.mr1.weight) # h => [m, self.ent_hidden_size], self.mr1 => [self.ent_hidden_size, self.rel_hidden_size]\\n mr2t = torch.matmul(t, self.mr2.weight) # t => [m, self.ent_hidden_size], self.mr2 => [self.ent_hidden_size, self.rel_hidden_size]\\n\\n expanded_h = h.unsqueeze(dim=0).repeat(self.rel_hidden_size, 1, 1) # [self.rel_hidden_size, m, self.ent_hidden_size]\\n expanded_t = t.unsqueeze(dim=-1) # [m, self.ent_hidden_size, 1]\\n\\n temp = (torch.matmul(expanded_h, self.mr.weight.view(self.rel_hidden_size, self.ent_hidden_size, self.ent_hidden_size))).permute(1, 0, 2) # [m, self.rel_hidden_size, self.ent_hidden_size]\\n htmrt = torch.squeeze(torch.matmul(temp, expanded_t), dim=-1) # [m, self.rel_hidden_size]\\n\\n return F.tanh(htmrt + mr1h + mr2t + self.br.weight)\",\n \"def forward(self, x):\\n h = self.l1(x)\\n h = h.view(x.shape[0], -1, self.bottom_width, self.bottom_width)\\n h = self.block2(h)\\n h = self.block3(h)\\n h = self.block4(h)\\n h = self.block5(h)\\n h = self.b6(h)\\n h = self.activation(h)\\n h = torch.tanh(self.c6(h))\\n\\n return h\",\n \"def tanh(Z):\\n\\n e_2_z = np.exp(2*Z)\\n\\n A = (e_2_z - 1) / (e_2_z + 1)\\n\\n internal_params = Z\\n return A, internal_params\",\n \"def forward_pass(self, h_tm1, x_t): # Function though to be used by tf.scan\\n\\n # Convert vector-tensor form into matrix-tensor form\\n x_t = tf.reshape(x_t, shape=[1, -1])\\n h_tm1 = tf.reshape(h_tm1, shape=[1, -1])\\n\\n # Definitions of z_t and r_t\\n z_t = tf.sigmoid(tf.matmul(x_t, self.Wz) + tf.matmul(h_tm1, self.Uz) + self.bz)\\n r_t = tf.sigmoid(tf.matmul(x_t, self.Wr) + tf.matmul(h_tm1, self.Ur) + self.br)\\n\\n # Definition of h~_t\\n h_proposal = tf.tanh(tf.matmul(x_t, self.Wh) + tf.matmul(tf.multiply(r_t, h_tm1), self.Uh) + self.bh)\\n\\n # Compute the next hidden state\\n h_t = tf.multiply(1 - z_t, h_tm1) + tf.multiply(z_t, h_proposal)\\n\\n return tf.squeeze(h_t)\",\n \"def f1(phi, phi_o, d):\\n return 1 - sigmoid_decay(phi, phi_o, d)\",\n \"def one_step(i_t, h_tm1):\\n h_t = self.activation(T.dot(i_t, self.W) + T.dot(h_tm1, self.W_rec) + self.b)\\n return h_t\",\n \"def forward(self, state: list) -> list:\\n x = F.relu(self.fc1_layer(state))\\n x = F.relu(self.fc2_layer(x))\\n x = F.tanh(self.fc3_layer(x))\\n\\n return x\",\n \"def forward_activationfunction(self, x):\\n if self.forward_activation == 'tanh':\\n return torch.tanh(x)\\n elif self.forward_activation == 'relu':\\n return F.relu(x)\\n elif self.forward_activation == 'linear':\\n return x\\n elif self.forward_activation == 'leakyrelu':\\n return F.leaky_relu(x, 0.2)\\n elif self.forward_activation == 'sigmoid':\\n return torch.sigmoid(x)\\n else:\\n raise ValueError('The provided forward activation {} is not '\\n 'supported'.format(self.forward_activation))\",\n \"def feed_forward(self):\\n self.hidden_activation = self._sigmoid(np.dot(self.input_activation, self.w1))\\n self.output_activation = self._sigmoid(np.dot(self.hidden_activation, self.w2))\",\n \"def activation(h):\\n\\n if(h > 0):\\n return 1\\n\\n else:\\n return 0\",\n \"def forward(self, h_prev, x_t):\\n hidden_con = np.concatenate((h_prev.T, x_t.T), axis=0)\\n h_next = np.tanh((np.matmul(hidden_con.T, self.Wh)) + self.bh)\\n y = self.softmax((np.matmul(h_next, self.Wy)) + self.by)\\n return h_next, y\",\n \"def scaled_tanh(self, x):\\r\\n return tf.keras.backend.tanh(x) * 3\",\n \"def one_step(self, x, h):\\n concatHX = torch.cat((x, h), 1)\\n zt = self.sigmoid(self.linearZ(concatHX))\\n rt = self.sigmoid(self.linearR(concatHX))\\n ht = (1-zt)*h + zt* self.tanh(self.linearH(rt*concatHX))\\n return ht\",\n \"def one_step(self, x, h):\\n concatHX = torch.cat((x, h), 1)\\n ft = self.sigmoid(self.linearF(concatHX))\\n it = self.sigmoid(self.linearI(concatHX))\\n ct = ft*self.cts[-1] + it*self.tanh(self.linearC(concatHX))\\n #self.ct = ft*self.ct.clone() + it*self.tanh(self.linearC(concatHX))\\n ot = self.sigmoid(self.linearO(concatHX))\\n ht = ot*self.tanh(ct)\\n \\n self.cts.append(ct)\\n \\n return ht\",\n \"def forward(self, h_prev, x_t):\\n h_concat_x = np.concatenate((h_prev.T, x_t.T), axis=0)\\n h_next = np.tanh((np.matmul(h_concat_x.T, self.Wh)) + self.bh)\\n y = self.softmax((np.matmul(h_next, self.Wy)) + self.by)\\n\\n return h_next, y\",\n \"def forward(self, x):\\n h = self.l1(x)\\n h = h.view(x.shape[0], -1, self.bottom_width, self.bottom_width)\\n h = self.block2(h)\\n h = self.block3(h)\\n h = self.block4(h)\\n h = self.b5(h)\\n h = self.activation(h)\\n h = torch.tanh(self.c5(h))\\n\\n return h\",\n \"def layer(self, h, t):\\n mr1h = torch.matmul(h, self.mr1.weight) # h => [m, d], self.mr1 => [d, k]\\n mr2t = torch.matmul(t, self.mr2.weight) # t => [m, d], self.mr2 => [d, k]\\n return torch.tanh(mr1h + mr2t)\",\n \"def forward(self, x):\\n\\n x = self.first_conv_layer(x)\\n x = self.second_conv_layer(x)\\n x = self.third_conv_layer(x)\\n x = self.fourth_conv_layer(x)\\n x = self.fifth_conv_layer(x)\\n\\n '''\\n x = x.view(-1, 4 * 4 * 512)\\n x = F.relu(self.fc1(x))\\n x = F.relu(self.fc2(x))\\n '''\\n\\n sigmoid_out = nn.functional.sigmoid(x)\\n\\n return sigmoid_out\",\n \"def forward(self, x):\\n # get hidden layer input\\n if self.layer == 1:\\n out = torch.tanh(self.fc1(x))\\n y_pred = self.fc_end(out)\\n return y_pred\\n elif self.layer == 2:\\n out1 = torch.tanh(self.fc1(x))\\n x = torch.tanh(self.fc2_1(x))\\n out2 = torch.tanh(self.fc2_2(x))\\n out = (out1+out2)/2\\n y_pred = self.fc_end(out)\\n return y_pred\\n else:\\n out1 = torch.tanh(self.fc1(x))\\n x = torch.tanh(self.fc2_1(x))\\n out3 = torch.tanh(self.fc3_1(x))\\n out3 = torch.tanh(self.fc3_2(out3))\\n out3 = (out3 + x)/2\\n out2 = torch.tanh(self.fc2_2(out3))\\n out = (out1 + out2)/2\\n y_pred = self.fc_end(out)\\n return y_pred\",\n \"def forward(self, x):\\n\\n x = self.first_conv_layer(x)\\n x = self.second_conv_layer(x)\\n x = self.third_conv_layer(x)\\n x = self.fourth_conv_layer(x)\\n\\n #print 'x.shape=', x.shape\\n x = x.view(-1, 5 * 5 * 64)\\n x = F.relu(self.fc1(x))\\n\\n sigmoid_out = nn.functional.sigmoid(x)\\n\\n return sigmoid_out\",\n \"def activationFunction(self, z):\\n if self.__activation == 'sig':\\n activation = 1 / (1 + np.exp(-z))\\n else:\\n tanhnum = np.exp(z) - np.exp(-z)\\n tanhden = np.exp(z) + np.exp(-z)\\n activation = tanhnum / tanhden\\n return activation\",\n \"def forwardpass_train(self, X):\\n # hidden_1\\n h1_input = np.dot(X, self.W1) + self.b1\\n h1_output = functions.relu(h1_input)\\n # hidden_2\\n h2_input = np.dot(h1_output, self.W2) + self.b2\\n h2_output = functions.relu(h2_input)\\n # output\\n o_input = np.dot(h2_output, self.W3) + self.b3\\n final_output = functions.softmax(o_input)\\n return h1_input, h1_output, h2_input, h2_output, final_output\",\n \"def d_act_f(self, p):\\n if self.activation is None:\\n return p\\n if self.activation == \\\"tanh\\\":\\n return 1 - np.tanh(p)**2\\n if self.activation == \\\"sigmoid\\\":\\n return (1 / (1 + np.exp(-p))) * (1 - (1 / (1 + np.exp(-p))))\\n if self.activation == \\\"relu\\\":\\n p[np.where(p < 0)] = 0\\n return p\\n\\n return p\",\n \"def forward(self, x):\\r\\n y = self.en_fc1(x)\\r\\n y = F.relu(y)\\r\\n y = self.en_fc2(y)\\r\\n y = F.relu(y)\\r\\n y = self.en_fc3(y)\\r\\n y = F.relu(y)\\r\\n\\r\\n mean = self.en_mu(y)\\r\\n stddev_p = self.en_log(y)\\r\\n \\r\\n n = x.shape[0]\\r\\n z = torch.randn(n,self.latent_dim)\\r\\n std = torch.exp(stddev_p/2.0)\\r\\n z = z.mul(std) + mean\\r\\n \\r\\n xhat = self.de_fc1(z)\\r\\n xhat = F.relu(xhat)\\r\\n xhat = self.de_fc2(xhat)\\r\\n xhat = F.relu(xhat)\\r\\n xhat = self.de_fc3(xhat)\\r\\n xhat = F.sigmoid(xhat)\\r\\n \\r\\n return y,mean,stddev_p,z,xhat\",\n \"def gradient_hidden(self, h):\\n if self.relu:\\n return 1.0*(h > 0)\\n else:\\n return 1 - h * h\",\n \"def forward(self, state):\\n #pass\\n #forward through each layer in \\\"hidden layer\\\", with ReLU activation unit between them\\n for linear in self.hidden_layers:\\n state = F.relu(linear(state))\\n \\n state = self.output(state)\\n return state#F.log_softmax(state, dim=1)\",\n \"def convert_tanhshrink(g, op, block):\\n\\n x = g.get_node(op.input(\\\"X\\\")[0])\\n out = x - _op.tanh(x)\\n g.add_node(op.output(\\\"Out\\\")[0], out)\",\n \"def tan(x):\\r\\n # see decorator for function body\\r\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7288412","0.7224226","0.71908355","0.7186722","0.7179838","0.71629184","0.71265453","0.7122386","0.7074787","0.7027048","0.69930476","0.69930476","0.6986668","0.6968281","0.6967701","0.6929699","0.6904969","0.68929416","0.68862855","0.6878756","0.687386","0.6852396","0.6844744","0.682989","0.68291503","0.68053424","0.67556316","0.67083144","0.667216","0.66372603","0.6624867","0.6621873","0.658709","0.6581357","0.65800744","0.6548777","0.6548672","0.65423113","0.6534695","0.65310675","0.6522397","0.6501222","0.64985293","0.6484597","0.6483523","0.6441027","0.6432713","0.64286923","0.6420448","0.6408975","0.6401251","0.63948494","0.6392259","0.63900447","0.6379333","0.63579154","0.63507336","0.634576","0.6322513","0.63055426","0.63050866","0.63035446","0.62990427","0.6296382","0.62960994","0.6289098","0.62846565","0.6261701","0.625511","0.6244457","0.6231547","0.6228348","0.62097156","0.61780775","0.6174464","0.6154296","0.6152194","0.6148374","0.61360437","0.6134101","0.6116773","0.61065596","0.60942525","0.60910624","0.60886717","0.60662144","0.60530907","0.6048347","0.6047718","0.60464627","0.6045426","0.60291064","0.60195565","0.60168666","0.60106295","0.59941983","0.59890187","0.59864897","0.59841084","0.59742814"],"string":"[\n \"0.7288412\",\n \"0.7224226\",\n \"0.71908355\",\n \"0.7186722\",\n \"0.7179838\",\n \"0.71629184\",\n \"0.71265453\",\n \"0.7122386\",\n \"0.7074787\",\n \"0.7027048\",\n \"0.69930476\",\n \"0.69930476\",\n \"0.6986668\",\n \"0.6968281\",\n \"0.6967701\",\n \"0.6929699\",\n \"0.6904969\",\n \"0.68929416\",\n \"0.68862855\",\n \"0.6878756\",\n \"0.687386\",\n \"0.6852396\",\n \"0.6844744\",\n \"0.682989\",\n \"0.68291503\",\n \"0.68053424\",\n \"0.67556316\",\n \"0.67083144\",\n \"0.667216\",\n \"0.66372603\",\n \"0.6624867\",\n \"0.6621873\",\n \"0.658709\",\n \"0.6581357\",\n \"0.65800744\",\n \"0.6548777\",\n \"0.6548672\",\n \"0.65423113\",\n \"0.6534695\",\n \"0.65310675\",\n \"0.6522397\",\n \"0.6501222\",\n \"0.64985293\",\n \"0.6484597\",\n \"0.6483523\",\n \"0.6441027\",\n \"0.6432713\",\n \"0.64286923\",\n \"0.6420448\",\n \"0.6408975\",\n \"0.6401251\",\n \"0.63948494\",\n \"0.6392259\",\n \"0.63900447\",\n \"0.6379333\",\n \"0.63579154\",\n \"0.63507336\",\n \"0.634576\",\n \"0.6322513\",\n \"0.63055426\",\n \"0.63050866\",\n \"0.63035446\",\n \"0.62990427\",\n \"0.6296382\",\n \"0.62960994\",\n \"0.6289098\",\n \"0.62846565\",\n \"0.6261701\",\n \"0.625511\",\n \"0.6244457\",\n \"0.6231547\",\n \"0.6228348\",\n \"0.62097156\",\n \"0.61780775\",\n \"0.6174464\",\n \"0.6154296\",\n \"0.6152194\",\n \"0.6148374\",\n \"0.61360437\",\n \"0.6134101\",\n \"0.6116773\",\n \"0.61065596\",\n \"0.60942525\",\n \"0.60910624\",\n \"0.60886717\",\n \"0.60662144\",\n \"0.60530907\",\n \"0.6048347\",\n \"0.6047718\",\n \"0.60464627\",\n \"0.6045426\",\n \"0.60291064\",\n \"0.60195565\",\n \"0.60168666\",\n \"0.60106295\",\n \"0.59941983\",\n \"0.59890187\",\n \"0.59864897\",\n \"0.59841084\",\n \"0.59742814\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8011069"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":12193,"cells":{"query":{"kind":"string","value":"Computes the backward pass for tanh activation function."},"document":{"kind":"string","value":"def tanh_backward(self, dUpper, cache):\n out = cache\n #############################################################################\n # TODO: Implement the tanh backward pass. #\n #############################################################################\n sech2 = 1 - out * out\n dtanh = dUpper * sech2\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n return dtanh"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def tanh_backward(dA, internal_params):\n Z = internal_params\n Zt=tanh(Z)\n dzp=np.power(Zt,2)\n print(dzp.shape)\n dZ=np.multiply(dzp,dA)\n return dZ\n # raise NotImplementedError","def tanh_backward(dA, Z):\n\n s = 1 - tanh(Z)**2\n dZ = dA * s\n\n assert (dZ.shape == Z.shape)\n\n return dZ","def propagate_backward(self, h):\n h = h.mm(self.feedbackweights.t())\n if self.feedbackbias is not None:\n h += self.feedbackbias.unsqueeze(0).expand_as(h)\n return self.feedback_activationfunction(h)","def tanh_grad(self, X):\n return 1-self.tanh(X)**2","def grad_tanh(self):\n grad = 1 - self.tanh(self.x) ** 2\n return grad","def backward_hidden_activation(self, Y, d):\n # y = tanh(x) ==> dy/dx = (1 - tanh(x)^2) = (1 - y^2)\n return d * (1 - Y ** 2)","def tanh_forward(self, x):\n \n #############################################################################\n # TODO: Implement the tanh forward pass. #\n #############################################################################\n out = np.tanh(x)\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n cache = out\n return out, cache","def backward(self, delta):\n if self.activation_type == \"sigmoid\":\n grad = self.grad_sigmoid()\n\n elif self.activation_type == \"tanh\":\n grad = self.grad_tanh()\n\n elif self.activation_type == \"ReLU\":\n grad = self.grad_ReLU()\n\n return grad * delta","def linear_activation_backward(dA, cache, activation):\n pass","def backward(ctx, grad_output):\n input, = ctx.saved_tensors\n\n sp = F.softplus(input)\n grad_sp = -torch.expm1(sp)\n\n tsp = F.tanh(sp)\n grad_tsp = (1 - tsp * tsp) * grad_sp\n grad = input * grad_tsp + tsp\n return grad","def tanh_grad(z):\n return 1.7159 * 2 / 3.0 * (1 - (np.tanh(2 / 3.0 * z)) ** 2)","def test_tanh_activation(self):\n self.assertEqual([0.099668, 0.099668], list(\n af.TanH().output(np.array([0.1, 0.1]))))\n self.assertEqual([0.990066, 0.990066], list(\n af.TanH().derivative(np.array([0.1, 0.1]))))","def grad_tanh(self):\r\n return 1 - np.square(self.tanh(self.x))","def backward_deconvnet_relu(x):\n def grad(dy):\n return tf.nn.relu(dy)\n return tf.nn.relu(x), grad","def sigmoid_backward(dout, cache):\n dx, x = None, cache\n\n f = lambda x: 1/(1 + np.exp(-x)) # activation function (sigmoid)\n\n fun = f(x)\n\n dx = np.multiply(fun, (1-fun))\n dx = np.multiply(dx,dout)\n\n return dx","def forward_hidden_activation(self, X):\n return np.tanh(X)","def rnn_step_backward(dnext_h, cache):\n dx, dprev_h, dWx, dWh, db = None, None, None, None, None\n ##############################################################################\n # TODO: Implement the backward pass for a single step of a vanilla RNN. #\n # #\n # HINT: For the tanh function, you can compute the local derivative in terms #\n # of the output value from tanh. #\n ##############################################################################\n\n x, next_h, prev_h, Wx, Wh, b = cache\n # this is because in vanilla RNN h = tanh(z) and derivative of next_h = tanh(z) = 1-z*z;\n dz = (1-next_h*next_h)*dnext_h\n # THIS ERROR IS SPREAD AMONG THE\n # np.dot(x, Wx) + np.dot(prev_h, Wh) + b)\n dx = np.dot(dz,Wx.T)\n dprev_h = np.dot(dz,Wh.T)\n db = np.sum(dz,axis=0)\n dWx = np.dot(x.T,dz)\n dWh = np.dot(prev_h.T,dz)\n #d(tanh) = 1- tanh*tanh\n\n\n ##############################################################################\n # END OF YOUR CODE #\n ##############################################################################\n return dx, dprev_h, dWx, dWh, db","def backward_pass(self):\r\n # the gradient of cross-entropy on top of softmax is (t-y)\r\n back_output = (self.targets - self.y) / self.y.shape[0]\r\n\r\n for layer in reversed(self.layers):\r\n back_output = layer.backward_pass(back_output)","def forward(self, x):\n # Pass the input through all the layers apllying ReLU activation, but the last\n for layer in self.fc_layers[:-1]:\n x = F.relu(layer(x))\n # Pass the result through the output layer apllying hyperbolic tangent function\n x = torch.tanh(self.fc_layers[-1](x))\n # Return the better action for the input state\n return x","def grad_tanh(self):\n return (1-np.tanh(self.x)*np.tanh(self.x))\n raise NotImplementedError(\"tanh gradient not implemented\")","def linear_activation_backward(dA, cache, lambd, activation):\n\n\tlinear_cache, activation_cache = cache\n\n\tif activation == \"relu\":\n\n\t\tZ = activation_cache\n\t\tdZ = np.array(dA, copy=True)\n\t\tdZ[Z <= 0] = 0\n\n\t\tassert (dZ.shape == Z.shape)\n\n\t\t# dZ = relu_backward(dA, activation_cache)\n\n\t\tdA_prev, dW, db = linear_backward(dZ, linear_cache, lambd)\n\n\telif activation == \"sigmoid\":\n\n\t\ts = 1 / (1 + np.exp(-activation_cache))\n\t\tdZ = dA * s * (1 - s)\n\t\tdA_prev, dW, db = linear_backward(dZ, linear_cache, lambd)\n\n\treturn dA_prev, dW, db","def linear_activation_backward(dA, cache, activation):\n linear_cache, activation_cache = cache\n\n if activation == \"relu\":\n dZ = relu_backward(dA, activation_cache)\n dA_prev, dW, db = linear_backward(dZ, linear_cache)\n\n elif activation == \"sigmoid\":\n dZ = sigmoid_backward(dA, activation_cache)\n dA_prev, dW, db = linear_backward(dZ, linear_cache)\n\n return dA_prev, dW, db","def linear_activation_backward(dA, cache, activation):\n linear_cache, activation_cache = cache\n\n if activation == \"relu\":\n dZ = relu_backward(dA,activation_cache)\n elif activation == \"sigmoid\":\n dZ = sigmoid_backward(dA,activation_cache)\n\n dA_prev,dW,db = linear_backward(dZ,linear_cache)\n\n return dA_prev,dW,db","def backward(self, inputs, gradients, **kwargs):\n grad_relu = inputs > 0\n return gradients * grad_relu","def derived_tanh(x):\n return 1 - tanh(x)","def derived_tanh(x):\n return 1 - tanh(x)","def backwardpass(self, grad):\n return (self.x>0) * grad","def linear_activation_backward(dA, AL, cache, activation):\n linear_cache, activation_cache = cache\n \n if activation == \"relu\":\n dZ = relu_backward(dA, activation_cache)\n dA_prev, dW, db = linear_backward(dZ, linear_cache)\n \n elif activation == \"softmax\":\n dZ = softmax_backward(dA, AL, activation_cache)\n dA_prev, dW, db = linear_backward(dZ, linear_cache)\n \n return dA_prev, dW, db","def sigmoid_backward(dA, Z):\r\n dsig = sigmoid(Z) * (1 - sigmoid(Z))\r\n return dA * dsig","def sigmoid_backward(a, z, g_z):\r\n exp_a = np.multiply(z, 1 - z)\r\n g_a = g_z * exp_a\r\n return g_a","def linear_activation_backward_calculation(dA, internal_params, activation_function):\n if activation_function == \"relu\":\n dZ = relu_backward(dA, internal_params)\n elif activation_function == \"sigmoid\":\n dZ = sigmoid_backward(dA, internal_params)\n else:\n dZ=tanh_backward(dA,internal_params)\n dA_prev, dW, db = linear_backward_calculation(dZ, internal_params)\n return dA_prev, dW, db\n\n # raise NotImplementedError","def linear_activation_backward(dA, cache, activation):\n if activation == 'sigmoid':\n fun = sigmoid_backward\n else:\n fun = relu_backward\n Z = cache[1]\n dZ = fun(dA, Z)\n W = cache[0][1]\n m = Z.shape[1]\n dA_prev = np.dot(W.transpose(), dZ)\n dW = np.dot(dZ, cache[0][0].transpose())/m\n db = np.sum(dZ, axis=1)/m\n return dA_prev, dW, db","def gradient_hidden(self, h):\n if self.relu:\n return 1.0*(h > 0)\n else:\n return 1 - h * h","def backward_pass(architecture,gradient_layerwise,grad_weights,grad_bias):\n \n for layer in range(len(architecture)-1,-1,-1):\n X_input,X_output,weightsi,biasi,X_input_im2col,imi,output_shapei,kernel_shapei,stridei,operationi,imxi = architecture['layer{}'.format(layer+1)]\n# print(\"Operation is:{} and Layer is: {}\".format(operationi,layer+1))\n if operationi == 'softmax': # Last layer -> Dont apply softmax in any layer other than the last layer!\n # not taking gradients here because we need dz_dX(secondlastlayer) which is y_pred - y\n continue\n \n if operationi == 'conv_bn_relu' or operationi == 'conv_relu' or operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\n if operationi__1 == 'softmax':\n y_pred = architecture['layer{}'.format(layer+2)][1]\n y_pred = torch.reshape(y_pred,y.shape)\n dz_dXi = y_pred - y\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\n X_output = torch.reshape(X_output,dz_dXi.shape)\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n elif 'relu' in operationi:\n dz_dXi[X_output <= 0] = 0\n else:\n None\n \n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # .\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # .\n try:\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input_im2col)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\n except:\n dz_dweightsi = (dz_dXi).mm(X_input_im2col)\n \n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi #\n elif operationi__1 == 'maxpool': # need to do something here to fix the problem\n None\n\n elif 'flatten' in operationi__1:\n # we currently have dz_doutput of flatten -> we want dz_doutput of the conv_bn_relu before flatten\n \n weightsi__1 = architecture['layer{}'.format(layer+2)][2] # weights2\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput of flatten\n if len(dz_dXi__1.shape) == 3:\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\n imi__1 = architecture['layer{}'.format(layer+2)][5] # i\n try:\n dz_dXi = torch.t(weightsi__1).mm(dz_dXi__1)\n except:\n dz_dXi = weightsi__1.mm(dz_dXi__1)\n X_output = torch.reshape(X_output,dz_dXi.shape)\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n elif 'relu' in operationi:\n dz_dXi[X_output <= 0] = 0\n else:\n None\n\n dz_dXi = torch.reshape(dz_dXi,(output_shapei[1]*output_shapei[2],-1))\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\n dz_dweightsi = X_input_im2col.mm(dz_dXi)\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\n dz_dbi = dz_dXi\n \n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)# Can also set this to layer like in line ~800\n \n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi) # Can also set this to layer like in line ~800\n \n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi) # Can also set this to layer like in line ~800\n \n else:\n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dX2 -> backpropagated from maxpool\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\n if len(dz_dXi__1.shape) == 3:\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\n imi__1 = architecture['layer{}'.format(layer+2)][5]\n try:\n Y = weightsi__1.mm(dz_dXi__1)\n except:\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\n dz_dXi = torch.zeros(X_output.shape)\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\n for i in range(np.shape(X_output)[0]):\n for j in range(np.shape(X_output)[1]):\n for k in range(np.shape(X_output)[2]):\n idxs = getIndexes(imi__1,(i,j,k))\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\n \n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\n if 'sigmoid' in operationi__1: # ...\n X_output = torch.reshape(X_output,dz_dXi.shape)\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n elif 'relu' in operationi__1: # ...\n dz_dXi[X_output <= 0] = 0\n else:\n None\n \n dz_dXi = torch.reshape(dz_dXi,(output_shape_current_layer[1]*output_shape_current_layer[2],-1))\n dz_dbi = torch.reshape(dz_dXi,bias_current_layer.shape)\n dz_dweightsi = X_im2col_current_layer.mm(dz_dXi)\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\n \n if operationi == 'maxpool':\n \n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput -> backpropagated from maxpool\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\n \n if len(dz_dXi__1.shape) == 3:\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\n imi__1 = architecture['layer{}'.format(layer+2)][5]\n try:\n Y = weightsi__1.mm(dz_dXi__1)\n except:\n try:\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\n except:\n Y = torch.t(weightsi__1).mm(dz_dXi__1) # Ensuring valid matrix multiplication here\n \n dz_dXi = torch.zeros(X_output.shape)\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\n for i in range(np.shape(X_output)[0]):\n for j in range(np.shape(X_output)[1]):\n for k in range(np.shape(X_output)[2]):\n idxs = getIndexes(imi__1,(i,j,k))\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\n\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\n \n if operationi__1 == 'conv_sigmoid' or operationi__1 == 'conv_bn_sigmoid': # ...\n X_output = torch.reshape(X_output,dz_dXi.shape)\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n else:\n dz_dXi[X_output <= 0] = 0\n\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\n \n dz_dXinput = torch.zeros((X_input.shape))\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+1)][0] # output = output of maxpool\n\n dz_dXoutput = torch.reshape(dz_dXoutput,(output_shapei[0],X_input_im2col.shape[2]))\n \n for i in range(output_shapei[0]):\n for j in range(X_input_im2col.shape[2]):\n Xi2ci = X_im2col_current_layer[i,:,:]\n idx = torch.argmax(Xi2ci[:,j]).item()\n value = imxi[i][(idx,j)]\n dz_dXinput[value[0],value[1],value[2]] += float(dz_dXoutput[i,j])\n\n# dz_dXinput = torch.reshape(dz_dXinput,output_shapei)\n \n X_prev_im2col = architecture['layer{}'.format(layer)][4]\n X_output_prev = architecture['layer{}'.format(layer)][1]\n X_output_prev = torch.reshape(X_output_prev,dz_dXinput.shape)\n X_input_prev = architecture['layer{}'.format(layer)][0]\n prev_bias = architecture['layer{}'.format(layer)][3]\n output_shape_prev = architecture['layer{}'.format(layer)][6]\n prev_operation = architecture['layer{}'.format(layer)][9]\n \n if prev_operation == 'conv_sigmoid' or prev_operation == 'conv_bn_sigmoid':\n dz_dXinput *= sigmoid(X_output_prev)*(1-sigmoid(X_output_prev)) # Taking the derivative of the sigmoid function\n else:\n dz_dXinput[X_output_prev <= 0] = 0\n \n if len(dz_dXinput.shape) == 3:\n dz_dXinput = torch.reshape(dz_dXinput,(-1,output_shape_prev[0]))\n \n dz_dbi = torch.reshape(dz_dXinput,prev_bias.shape)\n dz_dweightsi = X_prev_im2col.mm(dz_dXinput)\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0\n \n gradient_layerwise['layer{}'.format(layer)][2] = torch.Tensor(dz_dbi)\n gradient_layerwise['layer{}'.format(layer)][1] = torch.Tensor(dz_dweightsi)\n gradient_layerwise['layer{}'.format(layer)][0] = torch.Tensor(dz_dXinput) # ...\n \n if 'flatten_dense' in operationi:\n \n operationi__1 = architecture['layer{}'.format(layer+2)][9]\n \n if operationi__1 == 'softmax':\n \n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\n X_output = torch.reshape(X_output,(-1,1))\n y_pred = architecture['layer{}'.format(layer+2)][1]\n y_pred = torch.reshape(y_pred,y.shape)\n dz_dXi = y_pred - y\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\n X_output = torch.reshape(X_output,dz_dXi.shape)\n if 'sigmoid' in operationi:\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n elif 'relu' in operationi:\n dz_dXi[X_output <= 0] = 0\n else:\n None\n \n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\n try:\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\n except:\n dz_dweightsi = (dz_dXi).mm(X_input)\n \n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0\n \n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # Can also set this to layer like in line ~800\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi # Can also set this to layer like in line ~800\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # Can also set this to layer like in line ~800\n \n else:\n # Have to modify and test this before implementation -> Specifically\n # the backprop implementation is not consistent with the ones above\n #\n X_output = torch.reshape(X_output,(-1,1))\n weights__i = architecture['layer{}'.format(layer+2)][2]\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+2)][0]\n dz_dXoutput = torch.reshape(torch.Tensor(dz_dXoutput),X_output.shape)\n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\n\n if 'relu' in operationi:\n dz_dXoutput[X_output<0] = 0\n try:\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\n except:\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\n try:\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\n except:\n dz_dweightsi = dz_dXoutput.mm(X_input)\n dz_dbi = dz_dXoutput\n if 'sigmoid' in operationi:\n dz_dXoutput*= sigmoid(X_output)*(1-sigmoid(X_output))\n try:\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\n except:\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\n try:\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\n except:\n dz_dweightsi = dz_dXoutput.mm(X_input)\n dz_dbi = dz_dXoutput\n else:\n try:\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\n except:\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\n try:\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\n except:\n dz_dweightsi = dz_dXoutput.mm(X_input)\n dz_dbi = dz_dXoutput\n \n unflattened_Xinput = architecture['layer{}'.format(layer+1)][0]\n dz_dXinput = torch.reshape(dz_dXinput,unflattened_Xinput.shape)\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXinput)\n \n if gradient_layerwise['layer{}'.format(layer+1)][1] is not None:\n try:\n grad_weights['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][1]\n except:\n grad_weights['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][1])\n if gradient_layerwise['layer{}'.format(layer+1)][2] is not None:\n try:\n grad_bias['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][2]\n except:\n grad_bias['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][2])\n \n gc.collect()\n return","def backward(cls, grad_out, activated_out):\n raise Exception(\"Unimplemented\")","def backward(cls, grad_out, activated_out):\n raise Exception(\"Unimplemented\")","def tanh(input, inplace=False):\n return FunctionLib.apply(\n 'Tanh', input.device, [input],\n outputs=[input if inplace else None])","def activation(x):\n # return np.tanh(x)\n return np.maximum(0,x)","def backward(cls, grad_out, activated_out):\n new_grad = grad_out.copy()\n new_grad[activated_out == 0] = 0\n return new_grad","def sigmoid_backward(dA, internal_params):\n Z= internal_params\n dZ=np.multiply(sigmoid(Z)*(1-sigmoid(Z)),dA)\n # raise NotImplementedError\n return dZ","def backward(self, gradient):\n raise NotImplementedError()","def _forward(z: np.array, W: np.array, b: np.array,\n activation: str) -> np.array:\n a = np.dot(z, W) + b\n if activation == 'sigmoid':\n return sigmoid(a)\n elif activation == 'identity':\n return identity(a)","def forward(self, state):\n\n x = state # Careful: deepcopy bug?\n # Intermediate Layers\n for layer in self.layers[:-1]:\n\n x = nn.ReLU()(layer(x))\n\n x = nn.Tanh()(self.layers[-1](x))\n return x","def tanh(data):\n return _make.tanh(data)","def backward(self, gradient):\n #TODO\n pass","def backward(self, gradient):\n #TODO\n pass","def backward(self, gradient: Tensor) -> Tensor:\n self.b_grad = np.sum(gradient, axis=0)\n self.w_grad = self.inputs.T @ gradient\n return gradient @ self.w.T","def backward(\n self, X: np.ndarray, y: np.ndarray, lr: float, reg: float = 0.0\n ) -> float:\n y_hat = self.forward(X)\n\n y_one_hot = self.one_hot_encode(y)\n loss = CrossEntropy.forward(y_one_hot, y_hat)\n\n d_layer = CrossEntropy.backward(y, y_hat)\n\n w_grads = []\n b_grads = []\n\n for idx, layer in reversed(list(enumerate(self.layers))):\n # Not output layer\n if (idx + 1) < len(self.layers):\n next_layer = self.layers[idx + 1]\n\n d_layer = d_layer.dot(next_layer.w.T)\n d_layer = layer.activation_func.backward(d_layer, layer.activated_out)\n\n d_w = layer.linear_in.T.dot(d_layer) + 2 * reg * layer.w\n d_b = np.sum(d_layer, axis=0)\n\n w_grads.insert(0, d_w)\n b_grads.insert(0, d_b)\n\n self.optimizer.step(self.layers, w_grads, b_grads, lr)\n\n if self.norm_weights:\n w_norm = max(np.linalg.norm(l.w) for l in self.layers) / len(self.layers)\n b_norm = max(np.linalg.norm(l.w) for l in self.layers) / len(self.layers)\n for layer in self.layers:\n layer.w /= w_norm\n layer.b /= b_norm\n\n return loss","def linear_activation_forward(A_prev, W, b, activation):\n pass","def backward_pass(self, delta, zs, activations, nabla_b, nabla_w):\n for l in range(2, self.num_layers):\n delta = np.dot(self.weights[-l + 1].transpose(), delta) * sigmoid_prime(zs[-l])\n nabla_b[-l] = delta\n nabla_w[-l] = np.dot(delta, activations[-l - 1].transpose())\n return nabla_b, nabla_w","def backward_pass(self, grad):\n pass","def forward(self, y, h):\n y = y.transpose(1, 0)\n\n t = self.linear_in(h)\n target = self.linear_in(h).unsqueeze(2) # batch x dim x 1\n\n # Get attention\n attn = torch.bmm(y, target).squeeze(2) # batch x T\n attn = F.softmax(attn, dim=1)\n attn3 = attn.view(attn.size(0), 1, attn.size(1)) # batch x 1 x T\n\n weighted_y = torch.bmm(attn3, y).squeeze(1) # batch x dim\n h_tilde = torch.cat((weighted_y, h), 1)\n\n h_tilde = torch.tanh(self.linear_out(h_tilde))\n\n return h_tilde, attn","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n return F.tanh(self.fc3(x))","def sigmoid_grad(z):\n return Sigmoid(z) * (1 - Sigmoid(z))","def forward(self, state):#forward pass\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n return torch.tanh(self.fc3(x))","def backward(ctx, grad_A):\n Z, = ctx.saved_tensors\n\n grad_Z = None\n\n # We only need to compute gradients for tensors that are flagged to\n # require gradients!\n if ctx.needs_input_grad[0]:\n sigmoid = 1. / (1. + torch.exp(-Z))\n grad_Z = grad_A * sigmoid * (1. - sigmoid)\n\n return grad_Z","def backward(self, dout):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n for l in range(len(self.layers)-1,-1,-1):\n act_dout = self.activations[l].backward(dout)\n dout = self.layers[l].backward(act_dout)\n ########################\n # END OF YOUR CODE #\n #######################\n\n return","def backward(self, out_grad, input):\n raise NotImplementedError","def backward(self, next_layer_weights, next_layer_delta):\n delta = np.dot(next_layer_weights.T, next_layer_delta)\n delta = delta * self.mask * self.activation_derivative(self.z)\n self.delta = delta\n return delta","def linear_activation_backward(dA: np.array,\n cache: Tuple, activation: str) -> Tuple:\n linear_cache, activation_cache = cache\n dZ = np.array\n\n if activation == \"sigmoid\":\n dZ = sigmoid_backward(dA, activation_cache)\n elif activation == \"relu\":\n dZ = relu_backward(dA, activation_cache)\n\n return linear_backward(dZ, linear_cache)","def tanh(x):\r\n # see decorator for function body\r","def backward_and_step(self, loss):\n self.opt.zero_grad()\n loss.backward()\n self.opt.step()","def calculate_gradient(y, tx, w): \n return tx.T@(sigmoid(tx@w)-y)","def sigmoid_backward(dout, cache):\n dx = None\n y = cache\n ########################################################################\n # TODO: Implement the Sigmoid backward pass. #\n ########################################################################\n\n dx = dout * y * (1-y)\n\n ########################################################################\n # END OF YOUR CODE #\n ########################################################################\n return dx","def backwards(delta,params,name='',activation_deriv=sigmoid_deriv):\n # everything you may need for this layer\n W = params['W' + name]\n b = params['b' + name]\n X, pre_act, post_act = params['cache_' + name]\n # your code here\n # do the derivative through activation first\n # then compute the derivative W,b, and X\n \n delta_pre = activation_deriv(post_act) * delta\n # (in_dim, out_dim) = (in_dim, examples) @ (examples, out_dim)\n grad_W = X.transpose() @ delta_pre\n grad_b = np.sum(delta_pre, axis=0, keepdims=True) # (1, out_dim)\n # (examples, in_dim) = (examples, out_dim) @ (out_dim, in_dim)\n grad_X = delta_pre @ W.transpose()\n\n # store the gradients\n params['grad_W' + name] = grad_W\n params['grad_b' + name] = grad_b\n return grad_X","def backward(self, inputs): \n self.error = self.error * sigmoid(self.output, der=True) # because the activation function of last layer must be sigmoid\n delta3_weights = np.dot(self.z2.T, self.error)\n\n self.error = np.dot(self.error, self.output3_weights.T) * self.af(self.z2, der=True) \n delta2_weights = np.dot(self.z1.T, self.error)\n\n self.error = np.dot(self.error, self.hidden2_weights.T) * self.af(self.z1, der=True)\n delta1_weights = np.dot(inputs.T, self.error)\n\n self.hidden1_weights -= self.lr * delta1_weights\n self.hidden2_weights -= self.lr * delta2_weights\n self.output3_weights -= self.lr * delta3_weights","def sigmoid_backward(dA, Z):\n\n s = 1 / (1 + np.exp(-Z))\n dZ = dA * s * (1 - s)\n\n assert (dZ.shape == Z.shape)\n\n return dZ","def backward(self, grad):\n self.grads[\"w\"] = np.matmul(self.input_data.T, grad)\n self.grads[\"b\"] = np.sum(grad, axis=0)\n return np.matmul(self.input_data.T, grad)","def backward(self, gradwrtoutput):\n if Dropout.train_flag:\n gradin = torch.empty(self.data.shape).zero_()\n gradin[self.data > 0] = 1.0\n return gradin*gradwrtoutput\n return gradwrtoutput","def forward(self, state):\n x = f.relu(self.fc1(state))\n x = f.relu(self.fc2(x))\n return torch.tanh(self.fc3(x))","def derivative_activation(z):\n return activation(z) * (1 - activation(z))","def compute_hidden(self, a_h):\n if self.relu:\n return a_h*(a_h > 0)\n else:\n return np.tanh(a_h)","def sigmoid_backward(dA, cache):\n\n Z = cache\n s,_ = sigmoid(Z)\n dZ = dA * s * (1-s)\n return dZ","def backward(ctx, grad_output):\n loss, reg, u, lbda = ctx.saved_tensors\n\n device = u.device\n\n # do clever computations\n eps = 1e-10\n grad, = torch.autograd.grad(loss, u, only_inputs=True,\n retain_graph=True)\n x = (u - eps * grad).data\n lbda = lbda.data\n\n prox_x = check_tensor(\n np.array([prox_tv.tv1_1d(xx, eps * lbda) for xx in x]),\n device=device,\n )\n grad_u = (u - prox_x) / eps\n grad_lbda = reg.clone()\n return (torch.ones(0), grad_u, grad_lbda)","def backward(self):\n gradient = blah\n return gradient","def backward(self):\n gradient = blah\n return gradient","def backward(self, grad_output):\n raise NotImplementedError","def backward(last_layer: str) -> Callable:\n\n def closure() -> Tuple[Optional[torch.Tensor], torch.Tensor]:\n optimizer.zero_grad()\n output = model(data)\n if last_layer == \"output\":\n output.backward(torch.ones_like(target))\n return None, output\n elif last_layer == 'loss':\n loss = compute_loss(output - target)\n loss.backward()\n return loss, output\n else:\n assert False, 'last layer must be \"output\" or \"loss\"'\n\n return closure","def backward(last_layer: str) -> Callable:\n\n def closure() -> Tuple[Optional[torch.Tensor], torch.Tensor]:\n optimizer.zero_grad()\n output = model(data)\n if last_layer == \"output\":\n output.backward(torch.ones_like(target))\n return None, output\n elif last_layer == 'loss':\n loss = compute_loss(output - target)\n loss.backward()\n return loss, output\n else:\n assert False, 'last layer must be \"output\" or \"loss\"'\n\n return closure","def forward_backward_prop(data, labels, params, dimensions):\n\n ### Unpack network parameters (do not modify)\n ofs = 0\n Dx, H, Dy = (dimensions[0], dimensions[1], dimensions[2])\n\n activation = []\n\n W1 = np.reshape(params[ofs:ofs+ Dx * H], (Dx, H))\n ofs += Dx * H\n b1 = np.reshape(params[ofs:ofs + H], (1, H))\n ofs += H\n W2 = np.reshape(params[ofs:ofs + H * Dy], (H, Dy))\n ofs += H * Dy\n b2 = np.reshape(params[ofs:ofs + Dy], (1, Dy))\n\n ### Forward propagation\n activation.append(data)\n\n # Hidden layer inputs: (N, Dx) * (Dx, H) -> N x H\n z = np.dot(activation[-1], W1) + b1 \n # Activations, inputs to the final layer. \n activation.append(sigmoid(z)) # output of the hidden layer, activation\n # Final layer outputs: ( N x H ) * ( H, Dy) -> (N, Dy)\n z = np.dot(activation[-1], W2) + b2\n activation.append( softmax(z) )\n\n # Cross-entropy cost\n\n y_p = activation[-1]\n activation = activation[:-1] # remove activation data (output)\n\n cost = -np.sum(labels * np.log(y_p))\n \n error = []\n \n ### backward propagation\n sigma = (y_p - labels)\n error.append(sigma)\n\n gradb2 = np.sum(error[-1], axis=0)\n gradW2 = np.dot(activation[-1].T, error[-1])\n\n #\n sigma = np.dot(W2, error[-1].T)\n sigma = sigma.T * sigmoid_grad(activation[-1])\n activation = activation[:-1] # remove activation data ( hidden layer )\n\n error.append(sigma)\n\n gradb1 = np.sum(error[-1], axis=0)\n gradW1 = np.dot(activation[-1].T, error[-1])\n\n\n ### Stack gradients (do not modify)\n grad = np.concatenate((gradW1.flatten(), gradb1.flatten(), \n gradW2.flatten(), gradb2.flatten()))\n \n return cost, grad","def tanh(x):\n return 0.0","def forward(self, state):\n \n x = F.relu(self.fc1(state)) \n x = F.relu(self.fc2(x)) \n x = F.tanh(self.fc3(x)) \n \n \n ####x = F.relu(self.bn1(self.fc1(state)))\n ####x = F.relu(self.bn2(self.fc2(x)))\n ####x = torch.tanh(self.bn3(self.fc3(x)))\n ##x = torch.tanh(self.fc3(x))\n\n return x","def sigmoid_backward(dA, cache):\n Z = cache\n s = 1.0 / (1.0 + np.exp(-Z))\n dZ = dA * s * (1 - s)\n return dZ","def backward(ctx, grad_output):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n # Retrieve saved tensors and constants\n gamma, ivar, mean, input = ctx.saved_tensors\n eps = ctx.saved_tensors\n\n # Check which inputs need gradients\n input_needs_grad, gamma_needs_grad, beta_needs_grad = ctx.needs_input_grad\n\n # Get the batch size (=N)\n N, _ = grad_output.shape\n\n # reconstruct the input_norm\n input_norm = (input - mean) * ivar\n grand_input_norm = grad_output * gamma\n\n ##### Gradient wrt beta #####\n grad_beta = grad_output.sum(dim=0) if beta_needs_grad else None\n\n #### Gradient wrt gamma ####\n grad_gamma = (input_norm*grad_output).sum(dim=0) if gamma_needs_grad else None\n \n #### Gradient wrt input ####\n term1 = N*grand_input_norm \n term2 = torch.sum(grand_input_norm, dim=0)\n term3 = input_norm*torch.sum(grand_input_norm*input_norm, dim=0)\n grad_input = (1. / N) * ivar * (term1 - term2 - term3) if input_needs_grad else None\n\n ########################\n # END OF YOUR CODE #\n #######################\n\n # return gradients of the three tensor inputs and None for the constant eps\n return grad_input, grad_gamma, grad_beta, None","def lossFunc(inputs, targets, hprev):\n xs, hs, ys, ps = {}, {}, {}, {} # input, hidden, output, out_prob states for each time t\n hs[-1] = np.copy(hprev)\n loss = 0\n \n # forward pass\n for t in xrange(len(inputs)):\n xs[t] = np.zeros((vocab_size,1)) \n xs[t][inputs[t]] = 1. # convert input to one-hot\n hs[t] = np.tanh(np.dot(Wxh, xs[t]) + np.dot(Whh, hs[t-1]) + bh)\n ys[t] = np.dot(Why, hs[t]) + by\n ps[t] = np.exp(ys[t]) / np.sum(np.exp(ys[t]))\n loss += -np.log(ps[t][targets[t],0])\n \n # backward pass\n dWxh, dWhh, dWhy = np.zeros_like(Wxh), np.zeros_like(Whh), np.zeros_like(Why)\n dbh, dby = np.zeros_like(bh), np.zeros_like(by)\n dhnext = np.zeros_like(hs[0])\n for t in reversed(xrange(len(inputs))):\n # backprop into y\n dy = np.copy(ps[t])\n dy[targets[t]] -= 1\n # backprop into Why, hs, and by\n dWhy += np.dot(dy, hs[t].T)\n dby += dy\n dh = np.dot(Why.T, dy) + dhnext\n # backprop through tanh activition\n dhraw = (1 - hs[t] * hs[t]) * dh\n # backprop into Wxh, Whh, hs, and bh\n dbh += dhraw\n dWxh += np.dot(dhraw, xs[t].T)\n dWhh += np.dot(dhraw, hs[t-1].T)\n dhnext = np.dot(Whh.T, dhraw)\n # clip gradient preventing exploding\n for dparam in [dWxh, dWhh, dWhy, dbh, dby]:\n np.clip(dparam, -5, 5, out=dparam)\n\n return loss, dWxh, dWhh, dWhy, dbh, dby, hs[len(inputs)-1]","def tanh_inplace(a):","def forward(W,X):\n return activation_func(np.dot(add_bias(X),W))","def affine_sigmoid_backward(dout, cache):\n\n # fc_cache contains w (weights), x(input) , b(bias)\n # sigmoid cache contains the combination wx+b\n fc_cache, sigmoid_cache = cache\n da = sigmoid_backward(dout, sigmoid_cache)\n dx, dw, db = affine_backward(da, fc_cache)\n return dx, dw, db","def tanh(X):\n\tif isinstance(X,np.ndarray):\n\t\treturn (2.0/(1.0+np.exp(-(2*X))))-1\n\telse:\n\t\tX=np.array(X)\n\t\treturn tanh(X)","def create_tanh(x, bias):\n\n return tf.nn.tanh(tf.nn.bias_add(x, bias))","def tanh(self):\t\t\t\t\n\t\tval = np.tanh(self.val)\n\t\tif len(self.der.shape):\n\t\t\tto_multiply = 1 / np.power(np.cosh(self.val), 2)\n\t\t\tto_multiply = np.expand_dims(to_multiply, 1) if len(self.der.shape) > len(to_multiply.shape) else to_multiply\n\t\t\tder = to_multiply * self.der\n\t\telse:\n\t\t\tder = None\n\t\treturn Var(val, der)","def backward(self, inputs, grad_loss_input):\n raise NotImplementedError","def tanh(x):\n raise NotImplementedError","def _backward(loss):\n\n loss.backward()","def backward_pass(self, loss):\n\n self.optimizer.zero_grad()\n self.optimizer.backward(loss)\n self.optimizer.step()","def backward(self, inGradient, lr=0.001): # batchSize = 1\n wGradient = np.dot(inGradient.T, self.data)\n bGradient = np.sum(inGradient, axis=0)\n outGradient = np.dot(inGradient, self.weights)\n\n self.weights = self.weights - lr * wGradient\n self.bias = self.bias - lr * bGradient\n self.wGradient = wGradient\n self.bGradient = bGradient\n\n #print \"weight gradient \", wGradient\n #print \"bias gradient \", bGradient\n\n return outGradient","def backward_propagation(self, x, y):\n\t\tnabla_b = [np.zeros(b.shape) for b in self.biases]\n\t\tnabla_w = [np.zeros(w.shape) for w in self.weights]\n\n\t\t# forward pass from input layer to output layer\n\t\tactivations = [x]\n\t\tzs = []\n\t\tactivation = x\n\t\tfor b,w in zip(self.biases, self.weights):\n\t\t\tz = np.dot(w, activation) + b\n\t\t\tzs.append(z)\n\t\t\tactivation = self.afunc.f(z)\n\t\t\tactivations.append(activation)\n\n\t\t# backward pass from output layer to input layer\n\t\tdelta = (activations[-1] - y) * self.afunc.df(zs[-1])\n\t\tnabla_b[-1] = delta\n\t\tnabla_w[-1] = np.dot(delta, activations[-2].transpose())\n\t\t# other layers\n\t\tfor l in xrange(2, self.num_layers):\n\t\t\tz = zs[-l]\n\t\t\tdelta = np.dot(self.weights[-l+1].transpose(), delta) * self.afunc.df(z)\n\t\t\tnabla_b[-l] = delta\n\t\t\tnabla_w[-l] = np.dot(delta, activations[-l-1].transpose())\n\n\t\treturn (nabla_b, nabla_w)","def forward(self, x):\n self.y = x.tanh()\n return self.y","def _linear_activation_backward(self, dA, cache, activation_backward):\n linear_cache, activation_cache = cache\n dZ = activation_backward[1](dA, activation_cache)\n dA_prev, dW, db = self._linear_backward(dZ, linear_cache)\n\n return dA_prev, dW, db","def _backward(self, w=None):\n grad = self.w # Should be I * self.w . We keep a vector for simplicity\n\n # Left multiply input `w` with normalizer gradient\n return w * grad if w is not None else grad"],"string":"[\n \"def tanh_backward(dA, internal_params):\\n Z = internal_params\\n Zt=tanh(Z)\\n dzp=np.power(Zt,2)\\n print(dzp.shape)\\n dZ=np.multiply(dzp,dA)\\n return dZ\\n # raise NotImplementedError\",\n \"def tanh_backward(dA, Z):\\n\\n s = 1 - tanh(Z)**2\\n dZ = dA * s\\n\\n assert (dZ.shape == Z.shape)\\n\\n return dZ\",\n \"def propagate_backward(self, h):\\n h = h.mm(self.feedbackweights.t())\\n if self.feedbackbias is not None:\\n h += self.feedbackbias.unsqueeze(0).expand_as(h)\\n return self.feedback_activationfunction(h)\",\n \"def tanh_grad(self, X):\\n return 1-self.tanh(X)**2\",\n \"def grad_tanh(self):\\n grad = 1 - self.tanh(self.x) ** 2\\n return grad\",\n \"def backward_hidden_activation(self, Y, d):\\n # y = tanh(x) ==> dy/dx = (1 - tanh(x)^2) = (1 - y^2)\\n return d * (1 - Y ** 2)\",\n \"def tanh_forward(self, x):\\n \\n #############################################################################\\n # TODO: Implement the tanh forward pass. #\\n #############################################################################\\n out = np.tanh(x)\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n cache = out\\n return out, cache\",\n \"def backward(self, delta):\\n if self.activation_type == \\\"sigmoid\\\":\\n grad = self.grad_sigmoid()\\n\\n elif self.activation_type == \\\"tanh\\\":\\n grad = self.grad_tanh()\\n\\n elif self.activation_type == \\\"ReLU\\\":\\n grad = self.grad_ReLU()\\n\\n return grad * delta\",\n \"def linear_activation_backward(dA, cache, activation):\\n pass\",\n \"def backward(ctx, grad_output):\\n input, = ctx.saved_tensors\\n\\n sp = F.softplus(input)\\n grad_sp = -torch.expm1(sp)\\n\\n tsp = F.tanh(sp)\\n grad_tsp = (1 - tsp * tsp) * grad_sp\\n grad = input * grad_tsp + tsp\\n return grad\",\n \"def tanh_grad(z):\\n return 1.7159 * 2 / 3.0 * (1 - (np.tanh(2 / 3.0 * z)) ** 2)\",\n \"def test_tanh_activation(self):\\n self.assertEqual([0.099668, 0.099668], list(\\n af.TanH().output(np.array([0.1, 0.1]))))\\n self.assertEqual([0.990066, 0.990066], list(\\n af.TanH().derivative(np.array([0.1, 0.1]))))\",\n \"def grad_tanh(self):\\r\\n return 1 - np.square(self.tanh(self.x))\",\n \"def backward_deconvnet_relu(x):\\n def grad(dy):\\n return tf.nn.relu(dy)\\n return tf.nn.relu(x), grad\",\n \"def sigmoid_backward(dout, cache):\\n dx, x = None, cache\\n\\n f = lambda x: 1/(1 + np.exp(-x)) # activation function (sigmoid)\\n\\n fun = f(x)\\n\\n dx = np.multiply(fun, (1-fun))\\n dx = np.multiply(dx,dout)\\n\\n return dx\",\n \"def forward_hidden_activation(self, X):\\n return np.tanh(X)\",\n \"def rnn_step_backward(dnext_h, cache):\\n dx, dprev_h, dWx, dWh, db = None, None, None, None, None\\n ##############################################################################\\n # TODO: Implement the backward pass for a single step of a vanilla RNN. #\\n # #\\n # HINT: For the tanh function, you can compute the local derivative in terms #\\n # of the output value from tanh. #\\n ##############################################################################\\n\\n x, next_h, prev_h, Wx, Wh, b = cache\\n # this is because in vanilla RNN h = tanh(z) and derivative of next_h = tanh(z) = 1-z*z;\\n dz = (1-next_h*next_h)*dnext_h\\n # THIS ERROR IS SPREAD AMONG THE\\n # np.dot(x, Wx) + np.dot(prev_h, Wh) + b)\\n dx = np.dot(dz,Wx.T)\\n dprev_h = np.dot(dz,Wh.T)\\n db = np.sum(dz,axis=0)\\n dWx = np.dot(x.T,dz)\\n dWh = np.dot(prev_h.T,dz)\\n #d(tanh) = 1- tanh*tanh\\n\\n\\n ##############################################################################\\n # END OF YOUR CODE #\\n ##############################################################################\\n return dx, dprev_h, dWx, dWh, db\",\n \"def backward_pass(self):\\r\\n # the gradient of cross-entropy on top of softmax is (t-y)\\r\\n back_output = (self.targets - self.y) / self.y.shape[0]\\r\\n\\r\\n for layer in reversed(self.layers):\\r\\n back_output = layer.backward_pass(back_output)\",\n \"def forward(self, x):\\n # Pass the input through all the layers apllying ReLU activation, but the last\\n for layer in self.fc_layers[:-1]:\\n x = F.relu(layer(x))\\n # Pass the result through the output layer apllying hyperbolic tangent function\\n x = torch.tanh(self.fc_layers[-1](x))\\n # Return the better action for the input state\\n return x\",\n \"def grad_tanh(self):\\n return (1-np.tanh(self.x)*np.tanh(self.x))\\n raise NotImplementedError(\\\"tanh gradient not implemented\\\")\",\n \"def linear_activation_backward(dA, cache, lambd, activation):\\n\\n\\tlinear_cache, activation_cache = cache\\n\\n\\tif activation == \\\"relu\\\":\\n\\n\\t\\tZ = activation_cache\\n\\t\\tdZ = np.array(dA, copy=True)\\n\\t\\tdZ[Z <= 0] = 0\\n\\n\\t\\tassert (dZ.shape == Z.shape)\\n\\n\\t\\t# dZ = relu_backward(dA, activation_cache)\\n\\n\\t\\tdA_prev, dW, db = linear_backward(dZ, linear_cache, lambd)\\n\\n\\telif activation == \\\"sigmoid\\\":\\n\\n\\t\\ts = 1 / (1 + np.exp(-activation_cache))\\n\\t\\tdZ = dA * s * (1 - s)\\n\\t\\tdA_prev, dW, db = linear_backward(dZ, linear_cache, lambd)\\n\\n\\treturn dA_prev, dW, db\",\n \"def linear_activation_backward(dA, cache, activation):\\n linear_cache, activation_cache = cache\\n\\n if activation == \\\"relu\\\":\\n dZ = relu_backward(dA, activation_cache)\\n dA_prev, dW, db = linear_backward(dZ, linear_cache)\\n\\n elif activation == \\\"sigmoid\\\":\\n dZ = sigmoid_backward(dA, activation_cache)\\n dA_prev, dW, db = linear_backward(dZ, linear_cache)\\n\\n return dA_prev, dW, db\",\n \"def linear_activation_backward(dA, cache, activation):\\n linear_cache, activation_cache = cache\\n\\n if activation == \\\"relu\\\":\\n dZ = relu_backward(dA,activation_cache)\\n elif activation == \\\"sigmoid\\\":\\n dZ = sigmoid_backward(dA,activation_cache)\\n\\n dA_prev,dW,db = linear_backward(dZ,linear_cache)\\n\\n return dA_prev,dW,db\",\n \"def backward(self, inputs, gradients, **kwargs):\\n grad_relu = inputs > 0\\n return gradients * grad_relu\",\n \"def derived_tanh(x):\\n return 1 - tanh(x)\",\n \"def derived_tanh(x):\\n return 1 - tanh(x)\",\n \"def backwardpass(self, grad):\\n return (self.x>0) * grad\",\n \"def linear_activation_backward(dA, AL, cache, activation):\\n linear_cache, activation_cache = cache\\n \\n if activation == \\\"relu\\\":\\n dZ = relu_backward(dA, activation_cache)\\n dA_prev, dW, db = linear_backward(dZ, linear_cache)\\n \\n elif activation == \\\"softmax\\\":\\n dZ = softmax_backward(dA, AL, activation_cache)\\n dA_prev, dW, db = linear_backward(dZ, linear_cache)\\n \\n return dA_prev, dW, db\",\n \"def sigmoid_backward(dA, Z):\\r\\n dsig = sigmoid(Z) * (1 - sigmoid(Z))\\r\\n return dA * dsig\",\n \"def sigmoid_backward(a, z, g_z):\\r\\n exp_a = np.multiply(z, 1 - z)\\r\\n g_a = g_z * exp_a\\r\\n return g_a\",\n \"def linear_activation_backward_calculation(dA, internal_params, activation_function):\\n if activation_function == \\\"relu\\\":\\n dZ = relu_backward(dA, internal_params)\\n elif activation_function == \\\"sigmoid\\\":\\n dZ = sigmoid_backward(dA, internal_params)\\n else:\\n dZ=tanh_backward(dA,internal_params)\\n dA_prev, dW, db = linear_backward_calculation(dZ, internal_params)\\n return dA_prev, dW, db\\n\\n # raise NotImplementedError\",\n \"def linear_activation_backward(dA, cache, activation):\\n if activation == 'sigmoid':\\n fun = sigmoid_backward\\n else:\\n fun = relu_backward\\n Z = cache[1]\\n dZ = fun(dA, Z)\\n W = cache[0][1]\\n m = Z.shape[1]\\n dA_prev = np.dot(W.transpose(), dZ)\\n dW = np.dot(dZ, cache[0][0].transpose())/m\\n db = np.sum(dZ, axis=1)/m\\n return dA_prev, dW, db\",\n \"def gradient_hidden(self, h):\\n if self.relu:\\n return 1.0*(h > 0)\\n else:\\n return 1 - h * h\",\n \"def backward_pass(architecture,gradient_layerwise,grad_weights,grad_bias):\\n \\n for layer in range(len(architecture)-1,-1,-1):\\n X_input,X_output,weightsi,biasi,X_input_im2col,imi,output_shapei,kernel_shapei,stridei,operationi,imxi = architecture['layer{}'.format(layer+1)]\\n# print(\\\"Operation is:{} and Layer is: {}\\\".format(operationi,layer+1))\\n if operationi == 'softmax': # Last layer -> Dont apply softmax in any layer other than the last layer!\\n # not taking gradients here because we need dz_dX(secondlastlayer) which is y_pred - y\\n continue\\n \\n if operationi == 'conv_bn_relu' or operationi == 'conv_relu' or operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n if operationi__1 == 'softmax':\\n y_pred = architecture['layer{}'.format(layer+2)][1]\\n y_pred = torch.reshape(y_pred,y.shape)\\n dz_dXi = y_pred - y\\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi:\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n \\n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # .\\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # .\\n try:\\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input_im2col)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\\n except:\\n dz_dweightsi = (dz_dXi).mm(X_input_im2col)\\n \\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0\\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi #\\n elif operationi__1 == 'maxpool': # need to do something here to fix the problem\\n None\\n\\n elif 'flatten' in operationi__1:\\n # we currently have dz_doutput of flatten -> we want dz_doutput of the conv_bn_relu before flatten\\n \\n weightsi__1 = architecture['layer{}'.format(layer+2)][2] # weights2\\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput of flatten\\n if len(dz_dXi__1.shape) == 3:\\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\\n imi__1 = architecture['layer{}'.format(layer+2)][5] # i\\n try:\\n dz_dXi = torch.t(weightsi__1).mm(dz_dXi__1)\\n except:\\n dz_dXi = weightsi__1.mm(dz_dXi__1)\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi:\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n\\n dz_dXi = torch.reshape(dz_dXi,(output_shapei[1]*output_shapei[2],-1))\\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\\n dz_dweightsi = X_input_im2col.mm(dz_dXi)\\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\\n dz_dbi = dz_dXi\\n \\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)# Can also set this to layer like in line ~800\\n \\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi) # Can also set this to layer like in line ~800\\n \\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi) # Can also set this to layer like in line ~800\\n \\n else:\\n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dX2 -> backpropagated from maxpool\\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\\n if len(dz_dXi__1.shape) == 3:\\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\\n imi__1 = architecture['layer{}'.format(layer+2)][5]\\n try:\\n Y = weightsi__1.mm(dz_dXi__1)\\n except:\\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\\n dz_dXi = torch.zeros(X_output.shape)\\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\\n for i in range(np.shape(X_output)[0]):\\n for j in range(np.shape(X_output)[1]):\\n for k in range(np.shape(X_output)[2]):\\n idxs = getIndexes(imi__1,(i,j,k))\\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\\n \\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n if 'sigmoid' in operationi__1: # ...\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi__1: # ...\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n \\n dz_dXi = torch.reshape(dz_dXi,(output_shape_current_layer[1]*output_shape_current_layer[2],-1))\\n dz_dbi = torch.reshape(dz_dXi,bias_current_layer.shape)\\n dz_dweightsi = X_im2col_current_layer.mm(dz_dXi)\\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\\n \\n if operationi == 'maxpool':\\n \\n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput -> backpropagated from maxpool\\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\\n \\n if len(dz_dXi__1.shape) == 3:\\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\\n imi__1 = architecture['layer{}'.format(layer+2)][5]\\n try:\\n Y = weightsi__1.mm(dz_dXi__1)\\n except:\\n try:\\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\\n except:\\n Y = torch.t(weightsi__1).mm(dz_dXi__1) # Ensuring valid matrix multiplication here\\n \\n dz_dXi = torch.zeros(X_output.shape)\\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\\n for i in range(np.shape(X_output)[0]):\\n for j in range(np.shape(X_output)[1]):\\n for k in range(np.shape(X_output)[2]):\\n idxs = getIndexes(imi__1,(i,j,k))\\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\\n\\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n \\n if operationi__1 == 'conv_sigmoid' or operationi__1 == 'conv_bn_sigmoid': # ...\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n else:\\n dz_dXi[X_output <= 0] = 0\\n\\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\\n \\n dz_dXinput = torch.zeros((X_input.shape))\\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+1)][0] # output = output of maxpool\\n\\n dz_dXoutput = torch.reshape(dz_dXoutput,(output_shapei[0],X_input_im2col.shape[2]))\\n \\n for i in range(output_shapei[0]):\\n for j in range(X_input_im2col.shape[2]):\\n Xi2ci = X_im2col_current_layer[i,:,:]\\n idx = torch.argmax(Xi2ci[:,j]).item()\\n value = imxi[i][(idx,j)]\\n dz_dXinput[value[0],value[1],value[2]] += float(dz_dXoutput[i,j])\\n\\n# dz_dXinput = torch.reshape(dz_dXinput,output_shapei)\\n \\n X_prev_im2col = architecture['layer{}'.format(layer)][4]\\n X_output_prev = architecture['layer{}'.format(layer)][1]\\n X_output_prev = torch.reshape(X_output_prev,dz_dXinput.shape)\\n X_input_prev = architecture['layer{}'.format(layer)][0]\\n prev_bias = architecture['layer{}'.format(layer)][3]\\n output_shape_prev = architecture['layer{}'.format(layer)][6]\\n prev_operation = architecture['layer{}'.format(layer)][9]\\n \\n if prev_operation == 'conv_sigmoid' or prev_operation == 'conv_bn_sigmoid':\\n dz_dXinput *= sigmoid(X_output_prev)*(1-sigmoid(X_output_prev)) # Taking the derivative of the sigmoid function\\n else:\\n dz_dXinput[X_output_prev <= 0] = 0\\n \\n if len(dz_dXinput.shape) == 3:\\n dz_dXinput = torch.reshape(dz_dXinput,(-1,output_shape_prev[0]))\\n \\n dz_dbi = torch.reshape(dz_dXinput,prev_bias.shape)\\n dz_dweightsi = X_prev_im2col.mm(dz_dXinput)\\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0\\n \\n gradient_layerwise['layer{}'.format(layer)][2] = torch.Tensor(dz_dbi)\\n gradient_layerwise['layer{}'.format(layer)][1] = torch.Tensor(dz_dweightsi)\\n gradient_layerwise['layer{}'.format(layer)][0] = torch.Tensor(dz_dXinput) # ...\\n \\n if 'flatten_dense' in operationi:\\n \\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n \\n if operationi__1 == 'softmax':\\n \\n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\\n X_output = torch.reshape(X_output,(-1,1))\\n y_pred = architecture['layer{}'.format(layer+2)][1]\\n y_pred = torch.reshape(y_pred,y.shape)\\n dz_dXi = y_pred - y\\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n if 'sigmoid' in operationi:\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi:\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n \\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\\n try:\\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\\n except:\\n dz_dweightsi = (dz_dXi).mm(X_input)\\n \\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0\\n \\n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # Can also set this to layer like in line ~800\\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi # Can also set this to layer like in line ~800\\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # Can also set this to layer like in line ~800\\n \\n else:\\n # Have to modify and test this before implementation -> Specifically\\n # the backprop implementation is not consistent with the ones above\\n #\\n X_output = torch.reshape(X_output,(-1,1))\\n weights__i = architecture['layer{}'.format(layer+2)][2]\\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+2)][0]\\n dz_dXoutput = torch.reshape(torch.Tensor(dz_dXoutput),X_output.shape)\\n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\\n\\n if 'relu' in operationi:\\n dz_dXoutput[X_output<0] = 0\\n try:\\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\\n except:\\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\\n try:\\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\\n except:\\n dz_dweightsi = dz_dXoutput.mm(X_input)\\n dz_dbi = dz_dXoutput\\n if 'sigmoid' in operationi:\\n dz_dXoutput*= sigmoid(X_output)*(1-sigmoid(X_output))\\n try:\\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\\n except:\\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\\n try:\\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\\n except:\\n dz_dweightsi = dz_dXoutput.mm(X_input)\\n dz_dbi = dz_dXoutput\\n else:\\n try:\\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\\n except:\\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\\n try:\\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\\n except:\\n dz_dweightsi = dz_dXoutput.mm(X_input)\\n dz_dbi = dz_dXoutput\\n \\n unflattened_Xinput = architecture['layer{}'.format(layer+1)][0]\\n dz_dXinput = torch.reshape(dz_dXinput,unflattened_Xinput.shape)\\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXinput)\\n \\n if gradient_layerwise['layer{}'.format(layer+1)][1] is not None:\\n try:\\n grad_weights['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][1]\\n except:\\n grad_weights['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][1])\\n if gradient_layerwise['layer{}'.format(layer+1)][2] is not None:\\n try:\\n grad_bias['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][2]\\n except:\\n grad_bias['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][2])\\n \\n gc.collect()\\n return\",\n \"def backward(cls, grad_out, activated_out):\\n raise Exception(\\\"Unimplemented\\\")\",\n \"def backward(cls, grad_out, activated_out):\\n raise Exception(\\\"Unimplemented\\\")\",\n \"def tanh(input, inplace=False):\\n return FunctionLib.apply(\\n 'Tanh', input.device, [input],\\n outputs=[input if inplace else None])\",\n \"def activation(x):\\n # return np.tanh(x)\\n return np.maximum(0,x)\",\n \"def backward(cls, grad_out, activated_out):\\n new_grad = grad_out.copy()\\n new_grad[activated_out == 0] = 0\\n return new_grad\",\n \"def sigmoid_backward(dA, internal_params):\\n Z= internal_params\\n dZ=np.multiply(sigmoid(Z)*(1-sigmoid(Z)),dA)\\n # raise NotImplementedError\\n return dZ\",\n \"def backward(self, gradient):\\n raise NotImplementedError()\",\n \"def _forward(z: np.array, W: np.array, b: np.array,\\n activation: str) -> np.array:\\n a = np.dot(z, W) + b\\n if activation == 'sigmoid':\\n return sigmoid(a)\\n elif activation == 'identity':\\n return identity(a)\",\n \"def forward(self, state):\\n\\n x = state # Careful: deepcopy bug?\\n # Intermediate Layers\\n for layer in self.layers[:-1]:\\n\\n x = nn.ReLU()(layer(x))\\n\\n x = nn.Tanh()(self.layers[-1](x))\\n return x\",\n \"def tanh(data):\\n return _make.tanh(data)\",\n \"def backward(self, gradient):\\n #TODO\\n pass\",\n \"def backward(self, gradient):\\n #TODO\\n pass\",\n \"def backward(self, gradient: Tensor) -> Tensor:\\n self.b_grad = np.sum(gradient, axis=0)\\n self.w_grad = self.inputs.T @ gradient\\n return gradient @ self.w.T\",\n \"def backward(\\n self, X: np.ndarray, y: np.ndarray, lr: float, reg: float = 0.0\\n ) -> float:\\n y_hat = self.forward(X)\\n\\n y_one_hot = self.one_hot_encode(y)\\n loss = CrossEntropy.forward(y_one_hot, y_hat)\\n\\n d_layer = CrossEntropy.backward(y, y_hat)\\n\\n w_grads = []\\n b_grads = []\\n\\n for idx, layer in reversed(list(enumerate(self.layers))):\\n # Not output layer\\n if (idx + 1) < len(self.layers):\\n next_layer = self.layers[idx + 1]\\n\\n d_layer = d_layer.dot(next_layer.w.T)\\n d_layer = layer.activation_func.backward(d_layer, layer.activated_out)\\n\\n d_w = layer.linear_in.T.dot(d_layer) + 2 * reg * layer.w\\n d_b = np.sum(d_layer, axis=0)\\n\\n w_grads.insert(0, d_w)\\n b_grads.insert(0, d_b)\\n\\n self.optimizer.step(self.layers, w_grads, b_grads, lr)\\n\\n if self.norm_weights:\\n w_norm = max(np.linalg.norm(l.w) for l in self.layers) / len(self.layers)\\n b_norm = max(np.linalg.norm(l.w) for l in self.layers) / len(self.layers)\\n for layer in self.layers:\\n layer.w /= w_norm\\n layer.b /= b_norm\\n\\n return loss\",\n \"def linear_activation_forward(A_prev, W, b, activation):\\n pass\",\n \"def backward_pass(self, delta, zs, activations, nabla_b, nabla_w):\\n for l in range(2, self.num_layers):\\n delta = np.dot(self.weights[-l + 1].transpose(), delta) * sigmoid_prime(zs[-l])\\n nabla_b[-l] = delta\\n nabla_w[-l] = np.dot(delta, activations[-l - 1].transpose())\\n return nabla_b, nabla_w\",\n \"def backward_pass(self, grad):\\n pass\",\n \"def forward(self, y, h):\\n y = y.transpose(1, 0)\\n\\n t = self.linear_in(h)\\n target = self.linear_in(h).unsqueeze(2) # batch x dim x 1\\n\\n # Get attention\\n attn = torch.bmm(y, target).squeeze(2) # batch x T\\n attn = F.softmax(attn, dim=1)\\n attn3 = attn.view(attn.size(0), 1, attn.size(1)) # batch x 1 x T\\n\\n weighted_y = torch.bmm(attn3, y).squeeze(1) # batch x dim\\n h_tilde = torch.cat((weighted_y, h), 1)\\n\\n h_tilde = torch.tanh(self.linear_out(h_tilde))\\n\\n return h_tilde, attn\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n return F.tanh(self.fc3(x))\",\n \"def sigmoid_grad(z):\\n return Sigmoid(z) * (1 - Sigmoid(z))\",\n \"def forward(self, state):#forward pass\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n return torch.tanh(self.fc3(x))\",\n \"def backward(ctx, grad_A):\\n Z, = ctx.saved_tensors\\n\\n grad_Z = None\\n\\n # We only need to compute gradients for tensors that are flagged to\\n # require gradients!\\n if ctx.needs_input_grad[0]:\\n sigmoid = 1. / (1. + torch.exp(-Z))\\n grad_Z = grad_A * sigmoid * (1. - sigmoid)\\n\\n return grad_Z\",\n \"def backward(self, dout):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n for l in range(len(self.layers)-1,-1,-1):\\n act_dout = self.activations[l].backward(dout)\\n dout = self.layers[l].backward(act_dout)\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return\",\n \"def backward(self, out_grad, input):\\n raise NotImplementedError\",\n \"def backward(self, next_layer_weights, next_layer_delta):\\n delta = np.dot(next_layer_weights.T, next_layer_delta)\\n delta = delta * self.mask * self.activation_derivative(self.z)\\n self.delta = delta\\n return delta\",\n \"def linear_activation_backward(dA: np.array,\\n cache: Tuple, activation: str) -> Tuple:\\n linear_cache, activation_cache = cache\\n dZ = np.array\\n\\n if activation == \\\"sigmoid\\\":\\n dZ = sigmoid_backward(dA, activation_cache)\\n elif activation == \\\"relu\\\":\\n dZ = relu_backward(dA, activation_cache)\\n\\n return linear_backward(dZ, linear_cache)\",\n \"def tanh(x):\\r\\n # see decorator for function body\\r\",\n \"def backward_and_step(self, loss):\\n self.opt.zero_grad()\\n loss.backward()\\n self.opt.step()\",\n \"def calculate_gradient(y, tx, w): \\n return tx.T@(sigmoid(tx@w)-y)\",\n \"def sigmoid_backward(dout, cache):\\n dx = None\\n y = cache\\n ########################################################################\\n # TODO: Implement the Sigmoid backward pass. #\\n ########################################################################\\n\\n dx = dout * y * (1-y)\\n\\n ########################################################################\\n # END OF YOUR CODE #\\n ########################################################################\\n return dx\",\n \"def backwards(delta,params,name='',activation_deriv=sigmoid_deriv):\\n # everything you may need for this layer\\n W = params['W' + name]\\n b = params['b' + name]\\n X, pre_act, post_act = params['cache_' + name]\\n # your code here\\n # do the derivative through activation first\\n # then compute the derivative W,b, and X\\n \\n delta_pre = activation_deriv(post_act) * delta\\n # (in_dim, out_dim) = (in_dim, examples) @ (examples, out_dim)\\n grad_W = X.transpose() @ delta_pre\\n grad_b = np.sum(delta_pre, axis=0, keepdims=True) # (1, out_dim)\\n # (examples, in_dim) = (examples, out_dim) @ (out_dim, in_dim)\\n grad_X = delta_pre @ W.transpose()\\n\\n # store the gradients\\n params['grad_W' + name] = grad_W\\n params['grad_b' + name] = grad_b\\n return grad_X\",\n \"def backward(self, inputs): \\n self.error = self.error * sigmoid(self.output, der=True) # because the activation function of last layer must be sigmoid\\n delta3_weights = np.dot(self.z2.T, self.error)\\n\\n self.error = np.dot(self.error, self.output3_weights.T) * self.af(self.z2, der=True) \\n delta2_weights = np.dot(self.z1.T, self.error)\\n\\n self.error = np.dot(self.error, self.hidden2_weights.T) * self.af(self.z1, der=True)\\n delta1_weights = np.dot(inputs.T, self.error)\\n\\n self.hidden1_weights -= self.lr * delta1_weights\\n self.hidden2_weights -= self.lr * delta2_weights\\n self.output3_weights -= self.lr * delta3_weights\",\n \"def sigmoid_backward(dA, Z):\\n\\n s = 1 / (1 + np.exp(-Z))\\n dZ = dA * s * (1 - s)\\n\\n assert (dZ.shape == Z.shape)\\n\\n return dZ\",\n \"def backward(self, grad):\\n self.grads[\\\"w\\\"] = np.matmul(self.input_data.T, grad)\\n self.grads[\\\"b\\\"] = np.sum(grad, axis=0)\\n return np.matmul(self.input_data.T, grad)\",\n \"def backward(self, gradwrtoutput):\\n if Dropout.train_flag:\\n gradin = torch.empty(self.data.shape).zero_()\\n gradin[self.data > 0] = 1.0\\n return gradin*gradwrtoutput\\n return gradwrtoutput\",\n \"def forward(self, state):\\n x = f.relu(self.fc1(state))\\n x = f.relu(self.fc2(x))\\n return torch.tanh(self.fc3(x))\",\n \"def derivative_activation(z):\\n return activation(z) * (1 - activation(z))\",\n \"def compute_hidden(self, a_h):\\n if self.relu:\\n return a_h*(a_h > 0)\\n else:\\n return np.tanh(a_h)\",\n \"def sigmoid_backward(dA, cache):\\n\\n Z = cache\\n s,_ = sigmoid(Z)\\n dZ = dA * s * (1-s)\\n return dZ\",\n \"def backward(ctx, grad_output):\\n loss, reg, u, lbda = ctx.saved_tensors\\n\\n device = u.device\\n\\n # do clever computations\\n eps = 1e-10\\n grad, = torch.autograd.grad(loss, u, only_inputs=True,\\n retain_graph=True)\\n x = (u - eps * grad).data\\n lbda = lbda.data\\n\\n prox_x = check_tensor(\\n np.array([prox_tv.tv1_1d(xx, eps * lbda) for xx in x]),\\n device=device,\\n )\\n grad_u = (u - prox_x) / eps\\n grad_lbda = reg.clone()\\n return (torch.ones(0), grad_u, grad_lbda)\",\n \"def backward(self):\\n gradient = blah\\n return gradient\",\n \"def backward(self):\\n gradient = blah\\n return gradient\",\n \"def backward(self, grad_output):\\n raise NotImplementedError\",\n \"def backward(last_layer: str) -> Callable:\\n\\n def closure() -> Tuple[Optional[torch.Tensor], torch.Tensor]:\\n optimizer.zero_grad()\\n output = model(data)\\n if last_layer == \\\"output\\\":\\n output.backward(torch.ones_like(target))\\n return None, output\\n elif last_layer == 'loss':\\n loss = compute_loss(output - target)\\n loss.backward()\\n return loss, output\\n else:\\n assert False, 'last layer must be \\\"output\\\" or \\\"loss\\\"'\\n\\n return closure\",\n \"def backward(last_layer: str) -> Callable:\\n\\n def closure() -> Tuple[Optional[torch.Tensor], torch.Tensor]:\\n optimizer.zero_grad()\\n output = model(data)\\n if last_layer == \\\"output\\\":\\n output.backward(torch.ones_like(target))\\n return None, output\\n elif last_layer == 'loss':\\n loss = compute_loss(output - target)\\n loss.backward()\\n return loss, output\\n else:\\n assert False, 'last layer must be \\\"output\\\" or \\\"loss\\\"'\\n\\n return closure\",\n \"def forward_backward_prop(data, labels, params, dimensions):\\n\\n ### Unpack network parameters (do not modify)\\n ofs = 0\\n Dx, H, Dy = (dimensions[0], dimensions[1], dimensions[2])\\n\\n activation = []\\n\\n W1 = np.reshape(params[ofs:ofs+ Dx * H], (Dx, H))\\n ofs += Dx * H\\n b1 = np.reshape(params[ofs:ofs + H], (1, H))\\n ofs += H\\n W2 = np.reshape(params[ofs:ofs + H * Dy], (H, Dy))\\n ofs += H * Dy\\n b2 = np.reshape(params[ofs:ofs + Dy], (1, Dy))\\n\\n ### Forward propagation\\n activation.append(data)\\n\\n # Hidden layer inputs: (N, Dx) * (Dx, H) -> N x H\\n z = np.dot(activation[-1], W1) + b1 \\n # Activations, inputs to the final layer. \\n activation.append(sigmoid(z)) # output of the hidden layer, activation\\n # Final layer outputs: ( N x H ) * ( H, Dy) -> (N, Dy)\\n z = np.dot(activation[-1], W2) + b2\\n activation.append( softmax(z) )\\n\\n # Cross-entropy cost\\n\\n y_p = activation[-1]\\n activation = activation[:-1] # remove activation data (output)\\n\\n cost = -np.sum(labels * np.log(y_p))\\n \\n error = []\\n \\n ### backward propagation\\n sigma = (y_p - labels)\\n error.append(sigma)\\n\\n gradb2 = np.sum(error[-1], axis=0)\\n gradW2 = np.dot(activation[-1].T, error[-1])\\n\\n #\\n sigma = np.dot(W2, error[-1].T)\\n sigma = sigma.T * sigmoid_grad(activation[-1])\\n activation = activation[:-1] # remove activation data ( hidden layer )\\n\\n error.append(sigma)\\n\\n gradb1 = np.sum(error[-1], axis=0)\\n gradW1 = np.dot(activation[-1].T, error[-1])\\n\\n\\n ### Stack gradients (do not modify)\\n grad = np.concatenate((gradW1.flatten(), gradb1.flatten(), \\n gradW2.flatten(), gradb2.flatten()))\\n \\n return cost, grad\",\n \"def tanh(x):\\n return 0.0\",\n \"def forward(self, state):\\n \\n x = F.relu(self.fc1(state)) \\n x = F.relu(self.fc2(x)) \\n x = F.tanh(self.fc3(x)) \\n \\n \\n ####x = F.relu(self.bn1(self.fc1(state)))\\n ####x = F.relu(self.bn2(self.fc2(x)))\\n ####x = torch.tanh(self.bn3(self.fc3(x)))\\n ##x = torch.tanh(self.fc3(x))\\n\\n return x\",\n \"def sigmoid_backward(dA, cache):\\n Z = cache\\n s = 1.0 / (1.0 + np.exp(-Z))\\n dZ = dA * s * (1 - s)\\n return dZ\",\n \"def backward(ctx, grad_output):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n # Retrieve saved tensors and constants\\n gamma, ivar, mean, input = ctx.saved_tensors\\n eps = ctx.saved_tensors\\n\\n # Check which inputs need gradients\\n input_needs_grad, gamma_needs_grad, beta_needs_grad = ctx.needs_input_grad\\n\\n # Get the batch size (=N)\\n N, _ = grad_output.shape\\n\\n # reconstruct the input_norm\\n input_norm = (input - mean) * ivar\\n grand_input_norm = grad_output * gamma\\n\\n ##### Gradient wrt beta #####\\n grad_beta = grad_output.sum(dim=0) if beta_needs_grad else None\\n\\n #### Gradient wrt gamma ####\\n grad_gamma = (input_norm*grad_output).sum(dim=0) if gamma_needs_grad else None\\n \\n #### Gradient wrt input ####\\n term1 = N*grand_input_norm \\n term2 = torch.sum(grand_input_norm, dim=0)\\n term3 = input_norm*torch.sum(grand_input_norm*input_norm, dim=0)\\n grad_input = (1. / N) * ivar * (term1 - term2 - term3) if input_needs_grad else None\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n # return gradients of the three tensor inputs and None for the constant eps\\n return grad_input, grad_gamma, grad_beta, None\",\n \"def lossFunc(inputs, targets, hprev):\\n xs, hs, ys, ps = {}, {}, {}, {} # input, hidden, output, out_prob states for each time t\\n hs[-1] = np.copy(hprev)\\n loss = 0\\n \\n # forward pass\\n for t in xrange(len(inputs)):\\n xs[t] = np.zeros((vocab_size,1)) \\n xs[t][inputs[t]] = 1. # convert input to one-hot\\n hs[t] = np.tanh(np.dot(Wxh, xs[t]) + np.dot(Whh, hs[t-1]) + bh)\\n ys[t] = np.dot(Why, hs[t]) + by\\n ps[t] = np.exp(ys[t]) / np.sum(np.exp(ys[t]))\\n loss += -np.log(ps[t][targets[t],0])\\n \\n # backward pass\\n dWxh, dWhh, dWhy = np.zeros_like(Wxh), np.zeros_like(Whh), np.zeros_like(Why)\\n dbh, dby = np.zeros_like(bh), np.zeros_like(by)\\n dhnext = np.zeros_like(hs[0])\\n for t in reversed(xrange(len(inputs))):\\n # backprop into y\\n dy = np.copy(ps[t])\\n dy[targets[t]] -= 1\\n # backprop into Why, hs, and by\\n dWhy += np.dot(dy, hs[t].T)\\n dby += dy\\n dh = np.dot(Why.T, dy) + dhnext\\n # backprop through tanh activition\\n dhraw = (1 - hs[t] * hs[t]) * dh\\n # backprop into Wxh, Whh, hs, and bh\\n dbh += dhraw\\n dWxh += np.dot(dhraw, xs[t].T)\\n dWhh += np.dot(dhraw, hs[t-1].T)\\n dhnext = np.dot(Whh.T, dhraw)\\n # clip gradient preventing exploding\\n for dparam in [dWxh, dWhh, dWhy, dbh, dby]:\\n np.clip(dparam, -5, 5, out=dparam)\\n\\n return loss, dWxh, dWhh, dWhy, dbh, dby, hs[len(inputs)-1]\",\n \"def tanh_inplace(a):\",\n \"def forward(W,X):\\n return activation_func(np.dot(add_bias(X),W))\",\n \"def affine_sigmoid_backward(dout, cache):\\n\\n # fc_cache contains w (weights), x(input) , b(bias)\\n # sigmoid cache contains the combination wx+b\\n fc_cache, sigmoid_cache = cache\\n da = sigmoid_backward(dout, sigmoid_cache)\\n dx, dw, db = affine_backward(da, fc_cache)\\n return dx, dw, db\",\n \"def tanh(X):\\n\\tif isinstance(X,np.ndarray):\\n\\t\\treturn (2.0/(1.0+np.exp(-(2*X))))-1\\n\\telse:\\n\\t\\tX=np.array(X)\\n\\t\\treturn tanh(X)\",\n \"def create_tanh(x, bias):\\n\\n return tf.nn.tanh(tf.nn.bias_add(x, bias))\",\n \"def tanh(self):\\t\\t\\t\\t\\n\\t\\tval = np.tanh(self.val)\\n\\t\\tif len(self.der.shape):\\n\\t\\t\\tto_multiply = 1 / np.power(np.cosh(self.val), 2)\\n\\t\\t\\tto_multiply = np.expand_dims(to_multiply, 1) if len(self.der.shape) > len(to_multiply.shape) else to_multiply\\n\\t\\t\\tder = to_multiply * self.der\\n\\t\\telse:\\n\\t\\t\\tder = None\\n\\t\\treturn Var(val, der)\",\n \"def backward(self, inputs, grad_loss_input):\\n raise NotImplementedError\",\n \"def tanh(x):\\n raise NotImplementedError\",\n \"def _backward(loss):\\n\\n loss.backward()\",\n \"def backward_pass(self, loss):\\n\\n self.optimizer.zero_grad()\\n self.optimizer.backward(loss)\\n self.optimizer.step()\",\n \"def backward(self, inGradient, lr=0.001): # batchSize = 1\\n wGradient = np.dot(inGradient.T, self.data)\\n bGradient = np.sum(inGradient, axis=0)\\n outGradient = np.dot(inGradient, self.weights)\\n\\n self.weights = self.weights - lr * wGradient\\n self.bias = self.bias - lr * bGradient\\n self.wGradient = wGradient\\n self.bGradient = bGradient\\n\\n #print \\\"weight gradient \\\", wGradient\\n #print \\\"bias gradient \\\", bGradient\\n\\n return outGradient\",\n \"def backward_propagation(self, x, y):\\n\\t\\tnabla_b = [np.zeros(b.shape) for b in self.biases]\\n\\t\\tnabla_w = [np.zeros(w.shape) for w in self.weights]\\n\\n\\t\\t# forward pass from input layer to output layer\\n\\t\\tactivations = [x]\\n\\t\\tzs = []\\n\\t\\tactivation = x\\n\\t\\tfor b,w in zip(self.biases, self.weights):\\n\\t\\t\\tz = np.dot(w, activation) + b\\n\\t\\t\\tzs.append(z)\\n\\t\\t\\tactivation = self.afunc.f(z)\\n\\t\\t\\tactivations.append(activation)\\n\\n\\t\\t# backward pass from output layer to input layer\\n\\t\\tdelta = (activations[-1] - y) * self.afunc.df(zs[-1])\\n\\t\\tnabla_b[-1] = delta\\n\\t\\tnabla_w[-1] = np.dot(delta, activations[-2].transpose())\\n\\t\\t# other layers\\n\\t\\tfor l in xrange(2, self.num_layers):\\n\\t\\t\\tz = zs[-l]\\n\\t\\t\\tdelta = np.dot(self.weights[-l+1].transpose(), delta) * self.afunc.df(z)\\n\\t\\t\\tnabla_b[-l] = delta\\n\\t\\t\\tnabla_w[-l] = np.dot(delta, activations[-l-1].transpose())\\n\\n\\t\\treturn (nabla_b, nabla_w)\",\n \"def forward(self, x):\\n self.y = x.tanh()\\n return self.y\",\n \"def _linear_activation_backward(self, dA, cache, activation_backward):\\n linear_cache, activation_cache = cache\\n dZ = activation_backward[1](dA, activation_cache)\\n dA_prev, dW, db = self._linear_backward(dZ, linear_cache)\\n\\n return dA_prev, dW, db\",\n \"def _backward(self, w=None):\\n grad = self.w # Should be I * self.w . We keep a vector for simplicity\\n\\n # Left multiply input `w` with normalizer gradient\\n return w * grad if w is not None else grad\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74967176","0.73036784","0.72315353","0.7112281","0.7106927","0.70630103","0.70371467","0.70149505","0.69678706","0.6954078","0.6912582","0.6871865","0.6849014","0.6831122","0.6824879","0.6811179","0.68090993","0.6785766","0.67692584","0.6741517","0.6728811","0.669259","0.66580075","0.6653307","0.6650935","0.6650935","0.6634489","0.66294837","0.66290814","0.6621805","0.660409","0.65976816","0.6585623","0.658446","0.6579447","0.6579447","0.6575978","0.6559618","0.6547748","0.65386724","0.6519396","0.6498863","0.64867675","0.64837074","0.64690495","0.64690495","0.64689493","0.6464396","0.6464172","0.64641505","0.64565384","0.64410585","0.6437209","0.6436817","0.64329845","0.64319193","0.6430904","0.64113814","0.6407039","0.64026374","0.6398351","0.63903475","0.6389067","0.63830334","0.6350255","0.63407123","0.6324173","0.63225996","0.63214755","0.6313013","0.6312289","0.63101375","0.6303902","0.6303573","0.63000613","0.63000613","0.6293517","0.62922955","0.62922955","0.6285447","0.62847626","0.6280408","0.6278767","0.62767094","0.62675554","0.6266761","0.6257096","0.6248467","0.624705","0.6243967","0.62299716","0.62236243","0.6219635","0.6218893","0.6210453","0.6209517","0.62060744","0.62028","0.6200523","0.6197799"],"string":"[\n \"0.74967176\",\n \"0.73036784\",\n \"0.72315353\",\n \"0.7112281\",\n \"0.7106927\",\n \"0.70630103\",\n \"0.70371467\",\n \"0.70149505\",\n \"0.69678706\",\n \"0.6954078\",\n \"0.6912582\",\n \"0.6871865\",\n \"0.6849014\",\n \"0.6831122\",\n \"0.6824879\",\n \"0.6811179\",\n \"0.68090993\",\n \"0.6785766\",\n \"0.67692584\",\n \"0.6741517\",\n \"0.6728811\",\n \"0.669259\",\n \"0.66580075\",\n \"0.6653307\",\n \"0.6650935\",\n \"0.6650935\",\n \"0.6634489\",\n \"0.66294837\",\n \"0.66290814\",\n \"0.6621805\",\n \"0.660409\",\n \"0.65976816\",\n \"0.6585623\",\n \"0.658446\",\n \"0.6579447\",\n \"0.6579447\",\n \"0.6575978\",\n \"0.6559618\",\n \"0.6547748\",\n \"0.65386724\",\n \"0.6519396\",\n \"0.6498863\",\n \"0.64867675\",\n \"0.64837074\",\n \"0.64690495\",\n \"0.64690495\",\n \"0.64689493\",\n \"0.6464396\",\n \"0.6464172\",\n \"0.64641505\",\n \"0.64565384\",\n \"0.64410585\",\n \"0.6437209\",\n \"0.6436817\",\n \"0.64329845\",\n \"0.64319193\",\n \"0.6430904\",\n \"0.64113814\",\n \"0.6407039\",\n \"0.64026374\",\n \"0.6398351\",\n \"0.63903475\",\n \"0.6389067\",\n \"0.63830334\",\n \"0.6350255\",\n \"0.63407123\",\n \"0.6324173\",\n \"0.63225996\",\n \"0.63214755\",\n \"0.6313013\",\n \"0.6312289\",\n \"0.63101375\",\n \"0.6303902\",\n \"0.6303573\",\n \"0.63000613\",\n \"0.63000613\",\n \"0.6293517\",\n \"0.62922955\",\n \"0.62922955\",\n \"0.6285447\",\n \"0.62847626\",\n \"0.6280408\",\n \"0.6278767\",\n \"0.62767094\",\n \"0.62675554\",\n \"0.6266761\",\n \"0.6257096\",\n \"0.6248467\",\n \"0.624705\",\n \"0.6243967\",\n \"0.62299716\",\n \"0.62236243\",\n \"0.6219635\",\n \"0.6218893\",\n \"0.6210453\",\n \"0.6209517\",\n \"0.62060744\",\n \"0.62028\",\n \"0.6200523\",\n \"0.6197799\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70860624"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":12194,"cells":{"query":{"kind":"string","value":"Computes the forward pass of a rectified linear unit (ReLU)."},"document":{"kind":"string","value":"def relu_forward(self, x):\n #out = None\n #############################################################################\n # TODO: Implement the ReLU forward pass. #\n #############################################################################\n out = np.array(x, copy=True)\n out[out <= 0] = 0\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n cache = x\n return out, cache"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def relu_forward(x):\n ############################################################################\n # TODO: Implement the ReLU forward pass. #\n ############################################################################\n ############################################################################\n # START OF YOUR CODE #\n ############################################################################\n out = x\n out[out<0] = 0\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n return out","def relu_forward(x):\n out = None\n ###########################################################################\n # TODO: Implement the ReLU forward pass. #\n ###########################################################################\n out = x.copy()\n out[x<=0] = 0\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n cache = x\n return out, cache","def relu_forward(x):\n out = None\n ###########################################################################\n # TODO: Implement the ReLU forward pass. #\n ###########################################################################\n # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n out = np.where(x<=0, 0, x)\n\n pass\n\n # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n cache = x\n return out, cache","def relu_forward(x):\n out = None\n ###########################################################################\n # TODO: Implement the ReLU forward pass. #\n ###########################################################################\n #out = np.zeros(x.shape)\n #np.clip(x, 0, None, out)\n out = np.empty_like(x) #faster than zeros\n np.clip(x, 0, None, out)\n #out = x\n #out [out < 0] = 0\n #print(x)\n #print(out)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n cache = x\n return out, cache","def relu_forward(x):\n out = None\n ###########################################################################\n # TODO: Implement the ReLU forward pass. #\n ###########################################################################\n out = x * (x > 0)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n cache = x\n return out, cache","def forward(self, x):\n assert not torch.isnan(x).any(), f\"NaN in input {x}\"\n x = F.relu(self.l1(x))\n x = F.relu(self.l2(x))\n x = self.l3(x)\n return x","def relu_forward(x):\n out = None\n ###########################################################################\n # TODO: Implement the ReLU forward pass. #\n ###########################################################################\n out = np.maximum(0, x)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n cache = x\n return out, cache","def grad_ReLU(self):\n y = self.x\n y[y<=0] = 0\n y[y>0] = 1\n return y\n raise NotImplementedError(\"ReLU gradient not implemented\")","def forward(self, x):\n res = self.residual(x)\n x = self.gcn(x)\n x = self.tcn(x) + res\n return self.relu(x)","def relu_forward(x):\n out = None\n ###########################################################################\n # TODO: Implement the ReLU forward pass. #\n ###########################################################################\n out = np.maximum(x,0)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n cache = x\n return out, cache","def forward(self, x):\n # Pass the input through all the layers apllying ReLU activation, but the last\n for layer in self.fc_layers[:-1]:\n x = F.relu(layer(x))\n # Pass the result through the output layer apllying hyperbolic tangent function\n x = torch.tanh(self.fc_layers[-1](x))\n # Return the better action for the input state\n return x","def relu_grad(self, X):\n X[X<=0]=0\n X[X>0]=1\n return X","def update_relus(self):\n\n def relu_backward_hook_function(module, grad_in, grad_out):\n \"\"\"\n If there is a negative gradient, change it to zero\n \"\"\"\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)\n\n def relu_forward_hook_function(module, ten_in, ten_out):\n \"\"\"\n Store results of forward pass\n \"\"\"\n self.forward_relu_outputs.append(ten_out)\n\n # Loop through layers, hook up ReLUs","def forward(self, x: torch.Tensor):\n x = self.linear1(x)\n x = torch.relu(x)\n x = self.linear2(x)\n x = self.dropout(x)\n return x","def forward(self, x):\r\n y = self.en_fc1(x)\r\n y = F.relu(y)\r\n y = self.en_fc2(y)\r\n y = F.relu(y)\r\n y = self.en_fc3(y)\r\n y = F.relu(y)\r\n\r\n mean = self.en_mu(y)\r\n stddev_p = self.en_log(y)\r\n \r\n n = x.shape[0]\r\n z = torch.randn(n,self.latent_dim)\r\n std = torch.exp(stddev_p/2.0)\r\n z = z.mul(std) + mean\r\n \r\n xhat = self.de_fc1(z)\r\n xhat = F.relu(xhat)\r\n xhat = self.de_fc2(xhat)\r\n xhat = F.relu(xhat)\r\n xhat = self.de_fc3(xhat)\r\n xhat = F.sigmoid(xhat)\r\n \r\n return y,mean,stddev_p,z,xhat","def forward(self, x):\n x = F.relu(self.fc1(x))\n x = F.relu(self.fc2(x))\n x = self.fc3(x)\n return x","def forward(self, state):\n x = state\n for layer in self.linear_layers[:-1]:\n x = F.relu(layer(x))\n x = self.linear_layers[-1](x)\n return x","def forward(self, x):\n assert not torch.isnan(x).any(), f\"NaN in input {x}\"\n x = F.relu(self.l1(x))\n x = F.relu(self.l2(x))\n x = self.l3(x)\n return torch.clamp(x, -1, 1)","def update_relus(self):\n def relu_backward_hook_function(module, grad_in, grad_out):\n \"\"\"\n If there is a negative gradient, change it to zero\n \"\"\"\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)\n\n def relu_forward_hook_function(module, ten_in, ten_out):\n \"\"\"\n Store results of forward pass\n \"\"\"\n self.forward_relu_outputs.append(ten_out)\n\n # Loop through layers, hook up ReLUs\n for pos, module in self.model.features._modules.items():\n if isinstance(module, ReLU):\n module.register_backward_hook(relu_backward_hook_function)\n module.register_forward_hook(relu_forward_hook_function)","def forward(self, x):\n # x = state\n \n x = F.relu(self.input(x))\n x = self.output(x)\n \n return x","def forward(self, state):\r\n x = F.relu(self.linear1(state))\r\n x = F.relu(self.linear2(x))\r\n #x = torch.tanh(self.linear3(x))\r\n #x = F.relu(self.linear3(x))\r\n #x = nn.LeakyReLU(self.linear3(x), negative_slope=0.1)# .negativ_slope nur für leakyReLU relevant\r\n x = F.leaky_relu(self.linear3(x), 0.1)\r\n #x = F.softmax(self.linear3(x), dim=0)\r\n \r\n return x#.negativ_slope","def update_relus(self):\n def relu_backward_hook_function(module, grad_in, grad_out):\n \"\"\"\n If there is a negative gradient, change it to zero\n \"\"\"\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)\n\n def relu_forward_hook_function(module, ten_in, ten_out):\n \"\"\"\n Store results of forward pass\n \"\"\"\n self.forward_relu_outputs.append(ten_out)\n\n # Loop through layers, hook up ReLUs\n for pos, module in self.model._features_extractor._modules.items():\n for layer in module:\n if isinstance(layer, LeakyReLU):\n layer.register_backward_hook(relu_backward_hook_function)\n layer.register_forward_hook(relu_forward_hook_function)","def forward(self, x):\n return self.relu(self.conv(x))","def forward(self, x):\n x = self.first_deconv(x)\n x = self.first_batch_norm(x)\n x = F.leaky_relu(x)\n\n x = self.second_deconv(x)\n x = self.second_batch_norm(x)\n x = F.leaky_relu(x)\n\n x = self.third_deconv(x)\n x = self.third_batch_norm(x)\n x = F.leaky_relu(x)\n\n x = self.fourth_deconv(x)\n x = self.fourth_batch_norm(x)\n\n x = self.fifth_deconv(x)\n x = self.fifth_batch_norm(x)\n\n x = self.sixth_deconv(x)\n x = self.sixth_batch_norm(x)\n\n x = self.seventh_deconv(x)\n\n # sigmoid_out = nn.functional.sigmoid(x)\n tanh_out = nn.functional.tanh(x)\n\n out = (tanh_out + 1) * 255 / 2\n\n # print 'out.shape =', out.shape\n\n return out","def forward(self, state):\n x = F.relu(self.linear1(state))\n x = F.relu(self.linear2(x))\n x = self.linear3(x)\n return x","def update_relus(self):\n def relu_backward_hook_function(module, grad_in, grad_out):\n \"\"\"\n If there is a negative gradient, change it to zero\n \"\"\"\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)\n\n def relu_forward_hook_function(module, ten_in, ten_out):\n \"\"\"\n Store results of forward pass\n \"\"\"\n self.forward_relu_outputs.append(ten_out)\n\n # Loop through layers, hook up ReLUs\n for pos, module in self.model.named_modules():\n if isinstance(module, nn.ReLU):\n module.register_backward_hook(relu_backward_hook_function)\n module.register_forward_hook(relu_forward_hook_function)","def update_relus(self):\n def relu_backward_hook_function(module, grad_in, grad_out):\n \"\"\"\n If there is a negative gradient, change it to zero\n \"\"\"\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)\n\n def relu_forward_hook_function(module, ten_in, ten_out):\n \"\"\"\n Store results of forward pass\n \"\"\"\n self.forward_relu_outputs.append(ten_out)\n\n # Loop through layers, hook up ReLUs\n for pos, module in self.model.named_modules():\n if isinstance(module, ReLU):\n module.register_backward_hook(relu_backward_hook_function)\n module.register_forward_hook(relu_forward_hook_function)","def forward(self, state):\n x = F.relu(self.linear1(state))\n x = F.relu(self.linear2(x))\n x = torch.tanh(self.linear3(x))\n\n return x","def relu_backward(dout, x):\n ############################################################################\n # TODO: Implement the ReLU backward pass. #\n ############################################################################\n ############################################################################\n # START OF YOUR CODE #\n ############################################################################\n judge = x>0\n dx = dout*judge\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n return dx","def relu(input, inplace=False):\n return FunctionLib.apply(\n 'Relu', input.device, [input],\n outputs=[input if inplace else None], alpha=0.)","def forward(self,x):\n x = x.transpose(1,2).contiguous()\n x = F.leaky_relu(self.fc1(x), 0.2)\n x = F.leaky_relu(self.bn2(self.fc2(x)), 0.2)\n x = F.leaky_relu(self.bn3(self.fc3(x)), 0.2)\n x = torch.sigmoid(self.fc4(x))\n return x.transpose(1,2)","def forward(self, state):\n\n x = state # Careful: deepcopy bug?\n # Intermediate Layers\n for layer in self.layers[:-1]:\n\n x = nn.ReLU()(layer(x))\n\n x = nn.Tanh()(self.layers[-1](x))\n return x","def relu_forward(x):\n #raise NotImplementedError\n #######################################################################\n # #\n # #\n # TODO: YOUR CODE HERE #\n # #\n # #\n #######################################################################\n out=np.maximum(0,x)\n cache=x\n return out,cache","def grad_ReLU(self):\n grad = np.where(self.x > 0, 1, 0)\n return grad","def relu_backward(dout, cache):\n dx, x = None, cache\n ###########################################################################\n # TODO: Implement the ReLU backward pass. #\n ###########################################################################\n # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n dx = np.where(x<=0, 0, 1) * dout\n \n\n pass\n\n # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n return dx","def forward(self, input_):\n out = self.fc(input_)\n out = self.bn(out)\n out = self.relu(out)\n return torch.cat([out, input_], dim=1)","def forward(self, x):\n l1 = self.dropout(F.relu(self.linear1(x)))\n l2 = self.linear2(l1)\n return l2","def forward(self, state):#forward pass\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n return torch.tanh(self.fc3(x))","def forward(self, x):\n for i, layer in enumerate(self.layers):\n x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x)\n return x.squeeze(0)","def relu_backward(self, dUpper, cache):\n x = cache\n #############################################################################\n # TODO: Implement the ReLU backward pass. #\n #############################################################################\n x = np.array(x , copy=True)\n x[x <= 0] = 0\n x[x > 0] = 1\n drelu = dUpper * x\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n return drelu","def backward_deconvnet_relu(x):\n def grad(dy):\n return tf.nn.relu(dy)\n return tf.nn.relu(x), grad","def affine_layernorm_relu_forward(x, w, b, gamma, beta, ln_param):\n fc_out, fc_cache = affine_forward(x, w, b)\n norm_out, norm_cache = layernorm_forward(fc_out, gamma, beta, ln_param)\n out, relu_cache = relu_forward(norm_out)\n cache = (fc_cache, norm_cache, relu_cache)\n return out, cache","def update_relus(self):\n def relu_backward_hook_function(module, grad_in, grad_out):\n \"\"\"\n If there is a negative gradient, change it to zero\n \"\"\"\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)\n\n def relu_forward_hook_function(module, ten_in, ten_out):\n \"\"\"\n Store results of forward pass\n \"\"\"\n self.forward_relu_outputs.append(ten_out)\n\n # Loop through layers, hook up ReLUs\n for pos, module in self.model.encoder._modules.items():\n if isinstance(module, ReLU):\n module.register_backward_hook(relu_backward_hook_function)\n module.register_forward_hook(relu_forward_hook_function)","def reglu(x: Tensor) ->Tensor:\n assert x.shape[-1] % 2 == 0\n a, b = x.chunk(2, dim=-1)\n return a * F.relu(b)","def forward(self, state):\n \n x = F.relu(self.fc1(state)) \n x = F.relu(self.fc2(x)) \n x = F.tanh(self.fc3(x)) \n \n \n ####x = F.relu(self.bn1(self.fc1(state)))\n ####x = F.relu(self.bn2(self.fc2(x)))\n ####x = torch.tanh(self.bn3(self.fc3(x)))\n ##x = torch.tanh(self.fc3(x))\n\n return x","def forward(self, t, x):\n\n out = F.relu(self.l1(t, x))\n out = F.sigmoid(self.l2(t, out))\n\n return out","def test_rnnt_loss_basic_forward_no_grad(self):\n logits, targets, logit_lengths, target_lengths = rnnt_utils.get_basic_data(self.device)\n logits.requires_grad_(False)\n F.rnnt_loss(logits, targets, logit_lengths, target_lengths)","def relu_forward(x):\r\n cache = x\r\n out = np.maximum(0, x)\r\n return out, cache","def training_step(self, x):\n self.train() # Sets network to train mode\n rec_error, feat, y = self.forward(x)\n # Reconstruction Loss\n rec_loss = torch.mean(rec_error)\n loss = rec_loss\n\n self.zero_grad()\n loss.backward()\n self.optimizer.step()\n self.eval() # Sets network to evaluation mode\n print('Rec Loss: {}'.format(rec_loss.cpu().data))\n print()\n return loss, feat, y","def relu_forward(x):\n out = None\n out = np.maximum(0.0, x)\n cache = x\n return out, cache","def _relu(layer):\n return tf.nn.relu(layer)","def training_step(self, x):\n self.train()\n rec_error, feat, y = self.forward(x)\n # Reconstruction Loss\n rec_loss = torch.mean(rec_error)\n loss = rec_loss\n\n self.zero_grad()\n loss.backward()\n self.optimizer.step()\n self.eval()\n print('Rec Loss: {}'.format(rec_loss.cpu().data))\n print()\n return loss, feat, y","def forward(self, x):\r\n\r\n y = self.conv1(x)\r\n y = self.bn1(y)\r\n y = F.relu(y, inplace = True)\r\n y = self.conv2(y)\r\n y = self.bn2(y)\r\n y = F.relu(y, inplace = True)\r\n\r\n return y","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n x = F.relu(self.fc3(x))\n return self.fc4(x)","def L_model_forward(X, parameters):\n pass","def conv_relu_forward(x, w, b, conv_param):\n a, conv_cache = conv_forward_fast(x, w, b, conv_param)\n out, relu_cache = relu_forward(a)\n cache = (conv_cache, relu_cache)\n return out, cache","def conv_relu_forward(x, w, b, conv_param):\n a, conv_cache = conv_forward_fast(x, w, b, conv_param)\n out, relu_cache = relu_forward(a)\n cache = (conv_cache, relu_cache)\n return out, cache","def relu_backward(dout, cache):\n dx, x = None, cache\n ###########################################################################\n # TODO: Implement the ReLU backward pass. #\n ###########################################################################\n #print(dout)\n dx = np.empty_like(dout)\n np.copyto(dx, dout)\n dx[x < 0] = 0\n #print(dx)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n return dx","def test_lu_forward_sub():\t\n\t# test 1\n\tL = np.array([\n\t\t[ 2, 3,-4, 2],\n\t\t[-2, 1,-2, 1],\n\t\t[ 1,-1, 3,-1],\n\t\t[-3, 2, 2, 2]])\t\n\n\tb = np.array([4, -8, 9, 6])\n\n\ty = lu_forward_sub(L, b) \t\t\n\ty_soln = np.array([4,0,5,8])\t\t\t\t\t\t# correct output of LU_FORWARD_SUB\n\tassert norm(y - y_soln) < 1.e-10\n\n\t# test 2\n\tL2 = np.array([\n\t\t [0.01, 0., 0., 0., 0., 0., 0., 0., 0., 0., 1],\n\t\t [-100., 0.01, 0., 0., 0., 0., 0., 0., 0., 0., 100],\n\t\t [0., -100., 0.01, 0., 0., 0., 0., 0., 0., 0., 10000],\n\t\t [0., 0., -100., 0.01, 0., 0., 0., 0., 0., 0., 1000000],\n\t\t [0., 0., 0., -100., 0.01, 0., 0., 0., 0., 0., 100000000],\n\t\t [0., 0., 0., 0., -100., 0.01, 0., 0., 0., 0., 10000000000],\n\t\t [0., 0., 0., 0., 0., -100., 0.01, 0., 0., 0., 1000000000000],\n\t\t [0., 0., 0., 0., 0., 0., -100., 0.01, 0., 0., 100000000000000],\n\t\t [0., 0., 0., 0., 0., 0., 0., -100., 0.01, 0., 10000000000000000],\n\t\t [0., 0., 0., 0., 0., 0., 0., 0., -100, 0.01, 1000000000000000000],\n\t\t [0., 0., 0., 0., 0., 0., 0., 0., 0., -100., 100000000000000000000]])\n\n\tb2 = np.array ([[1.01], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [0.]])\n\n\ty2 = lu_forward_sub(L2, b2) \t\t\n\ty_soln2 = np.array([1.01, -101.99, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 99])\t\t\t\t\t\t# correct output of LU_FORWARD_SUB\n\tassert norm(y2 - y_soln2) < 1.e-10","def forward(self, x: torch.Tensor) -> torch.Tensor:\n identity = x\n\n out = self.conv_reduce(x)\n out = self.relu(self.bn_reduce(out))\n\n out = self.conv_conv(out)\n out = self.relu(self.bn(out))\n\n out = self.conv_expand(out)\n out = self.bn_expand(out)\n\n res = self.shortcut(identity)\n return self.relu(res + out)","def forward(self, x):\n lay1 = self.linear1(x)\n lay1 = nn.functional.relu(lay1)\n\n lay2 = self.linear2(lay1)\n lay2 = nn.functional.relu(lay2)\n \n lay3_1 = self.linear3_1(lay2)\n lay3_1 = nn.functional.relu(lay3_1)\n\n ## CHECK HERE TOO!!!\n out_1 = self.linear4_1(lay3_1)\n out_1 = out_1.view(-1, ) # reshape it to a 1d-array\n \n # taken care by BCEWithLogitsLoss\n # out_1 = nn.functional.softmax(out_1, dim=0) \n \n lay3_2 = self.linear3_2(lay2)\n lay3_2 = nn.functional.relu(lay3_2)\n \n out_2 = self.linear4_2(lay3_2)\n \n return out_1, out_2","def forward(self, x):\n h_relu = self.linear1(x).clamp(min=0)\n y_pred = self.linear2(h_relu)\n return y_pred","def forward_step_layer(t1, t2, activation_f=torchfun.relu):\n return batch_norm_tensor(activation_f(t1.bmm(t2)))","def forward(self, x):\r\n x = self.conv1(x)\r\n x = self.conv1_BN(x)\r\n x = F.relu(x)\r\n x = self.conv1_dp(x)\r\n x = self.Block2_1(x)\r\n x = self.Block2_2(x)\r\n x = self.Block3_1(x)\r\n x = self.Block3_2(x)\r\n x = self.Block3_3(x)\r\n x = self.Block3_4(x)\r\n x = self.Block4_1(x)\r\n x = self.Block4_2(x)\r\n x = self.Block4_3(x)\r\n x = self.Block4_4(x)\r\n x = self.Block5_1(x)\r\n x = self.Block5_2(x)\r\n x = self.MP(x)\r\n x = x.view(x.size(0),-1)\r\n x = self.fc(x)\r\n \r\n return x","def forward(self, state):\n '''\n state = F.relu(self.conv1(state))\n state = F.relu(self.conv2(state))\n state = F.relu(self.conv3(state))\n state = F.relu(self.fc1(state))\n \n action = F.relu(self.fc2(state))\n \n return action\n '''\n \n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n x = self.fc3(x)\n \n return x","def forward(self, x):\r\n x = x.reshape(x.shape[0], x.shape[1], 1 , 1)\r\n x = self.input(x)\r\n x = self.bn(x)\r\n x = F.relu(x)\r\n for i in range(len(self.DV)-1, -1, -1):\r\n x = self.DV[i](x)\r\n if i != 0:\r\n x = self.BN[i](x)\r\n x = F.relu(x)\r\n for col, t in enumerate(self.col_type):\r\n i = int(col/self.shape)\r\n j = col % self.shape\r\n if t == \"binary\":\r\n x[:,:,i,j] = torch.sigmoid(x[:,:,i,j])\r\n elif t == \"normalize\":\r\n x[:,:,i,j] = torch.tanh(x[:,:,i,j])\r\n else:\r\n x[:,:,i,j] = torch.relu(x[:,:,i,j])\r\n return x","def test_relu(self):\n activation_name = 'ReLU'\n args = {}\n\n activation = activation_factory.create(activation_name, **args)\n self.assertEqual(activation._get_name(), activation_name)\n\n x = torch.ones(10) * -1\n y = activation(x)\n self.assertEqual(len(torch.nonzero(y, as_tuple=False)), 0)","def forward(self, x):\n\n out = torch.relu(self.conv1(x))\n out = torch.relu(self.conv2(out))\n\n out = torch.relu(self.resnet_block(out))\n\n out = torch.relu(self.deconv1(out))\n out = torch.tanh(self.deconv2(out))\n\n return out","def forward(self, x):\n h_relu = self.linear1(x).clamp(min=0)\n h_relu2 = self.linear2(h_relu)\n h_relu3 = self.linear3(h_relu2)\n y_pred = self.linear4(h_relu3)\n return y_pred","def relu_backward(dout, cache):\n dx, x = None, cache\n ###########################################################################\n # TODO: Implement the ReLU backward pass. #\n ###########################################################################\n dx = dout * (x > 0)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n return dx","def relu_backward(dout, cache):\n dx, x = None, cache\n ###########################################################################\n # TODO: Implement the ReLU backward pass. #\n ###########################################################################\n dx = dout * (x > 0)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n return dx","def forward(self, x):\n x=T.div(x,255.0)\n \n #print(state[20:,20:,0])\n #print(state[:,0,:,:])\n conv1 = F.relu(self.conv1(x))\n conv2 = F.relu(self.conv2(conv1))\n conv3 = F.relu(self.conv3(conv2))\n ###\n conv_state = conv3.view(conv3.size()[0], -1)\n flat1 = F.relu(self.fc1(conv_state))\n flat2 = F.relu(self.fc2(flat1))\n\n V = self.V(flat2)\n A = self.A(flat2)\n\n return V, A\n return x","def relu_backward(dout, cache):\n dx, x = None, cache\n ###########################################################################\n # TODO: Implement the ReLU backward pass. #\n ###########################################################################\n dx = dout.copy()\n dx[x<=0] = 0\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n return dx","def guided_backpropagation_relu(x):\n def grad(dy):\n return tf.nn.relu(dy) * tf.cast(x > 0.0, x.dtype)\n return tf.nn.relu(x), grad","def forward(self, state):\n x = state.unsqueeze(1)\n x = F.relu(self.cnl1(x))\n x = F.relu(self.cnl2(x))\n x = F.relu(self.cnl3(x))\n x = x.view(x.shape[0], -1) # flatten\n x = F.relu(self.dense1(x))\n x = self.out(x)\n return x","def forward(self, state):\n x = f.relu(self.fc1(state))\n x = f.relu(self.fc2(x))\n return torch.tanh(self.fc3(x))","def lrelu(self):\n return self.add_layer(lrelu)","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n return self.fc3(x)","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n return self.fc3(x)","def forward(self, state):\n x = F.relu(self.fc1(state))\n x = F.relu(self.fc2(x))\n return self.fc3(x)","def __call__(self, x):\n h = F.relu(self.l0(x))\n h = F.relu(self.l1(h))\n return self.l2(h)","def forward(self, x):\n h = self.linear1(x)\n h = torch.nn.functional.relu(h)\n h = self.linear2(h)\n h = torch.nn.functional.relu(h)\n h = self.linear3(h)\n y_pred = torch.sigmoid(h)\n return y_pred","def forward(self, x, h_last=None):\n\n # forward pass of the RNNLM network\n\n embedding = self.emb(x)\n y, h = self.gru(embedding, h_last)\n out = self.linear(y)\n return out, h","def forward(self, x):\n h_relu = self.linear1(x).clamp(min=0)\n h_relu2 = self.linear2(h_relu)\n y_pred = self.linear4(h_relu2)\n return y_pred","def test_relu_activation(self):\n self.assertEqual([0, 0.5], list(\n af.Relu().output(np.array([-0.5, 0.5]))))\n self.assertEqual([0, 1], list(\n af.Relu().derivative(np.array([-0.5, 0.5]))))","def forward(self, state):\n \n for linear in self.hidden_layers:\n state = F.relu(linear(state))\n \n return self.output(state)","def forward(self, x):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n\n x = self.pool1(F.relu(self.batch1(self.conv1(x))))\n x = self.pool2(F.relu(self.batch2(self.conv2(x))))\n x = F.relu(self.batch3a(self.conv3a(x)))\n x = self.pool3(F.relu(self.batch3b(self.conv3b(x))))\n x = F.relu(self.batch4a(self.conv4a(x)))\n x = self.pool4(F.relu(self.batch4b(self.conv4b(x))))\n x = F.relu(self.batch5a(self.conv5a(x)))\n x = self.pool5(F.relu(self.batch5b(self.conv5b(x))))\n x = self.avgpool(x)\n x = x.reshape(x.shape[0], -1)\n out = self.fc1(x)\n\n# raise NotImplementedError\n ########################\n # END OF YOUR CODE #\n #######################\n\n return out","def forward(self, x):\n # define feedforward behavior, applying activations as necessary\n out = self.leaky_relu(self.conv1(x))\n out = self.leaky_relu(self.conv2(out))\n out = self.leaky_relu(self.conv3(out))\n out = self.leaky_relu(self.conv4(out))\n\n out = self.res_blocks(out)\n\n out = self.leaky_relu(self.deconv1(out))\n out = self.leaky_relu(self.deconv2(out))\n out = self.leaky_relu(self.deconv3(out))\n\n # tanh applied to last layer\n out = F.tanh(self.out_layer(out))\n out = torch.clamp(out, min=-0.5, max=0.5)\n\n return out","def forward(self, x):\n \n x = F.relu(self.conv1_bn(self.conv1(self.conv0_bn(x))))\n x = F.relu(self.conv2_bn(self.conv2(x)))\n x = F.relu(self.conv3_bn(self.conv3( self.maxpool2(x))))\n x = F.relu(self.conv4_bn(self.conv4( self.maxpool3(x))))\n x = self.maxpool4(x) \n x = x.view(-1, 1184)\n x = F.relu(self.fc1(x))\n x = self.dense1_bn(x)\n x = F.dropout(x, training=self.training)\n x = self.fc2(x)\n return F.log_softmax(x)","def forward(self,x):\n \n out,_ = self.lstm(x,self.hidden)\n out = out.detach()\n x = out[:,-1,:][-1]\n x = self.relu(x)\n if self.stochastic:\n x= x+ (x- self.memory[0]).detach()* torch.rand(x.shape) * self.sigmoid(self.SM.gamma[0])\n self.memory[0] = x.clone().detach()\n\n x = self.relu(self.layer1(x))\n if self.stochastic:\n x= x+ (x- self.memory[1]).detach()* torch.rand(x.shape) * self.sigmoid(self.SM.gamma[1])\n self.memory[1] = x.clone().detach()\n\n x = self.relu(self.layer2(x))\n if self.stochastic:\n x= x+ (x- self.memory[2]).detach()* torch.rand(x.shape) * self.sigmoid(self.SM.gamma[2])\n self.memory[2] = x.clone().detach()\n\n x = self.relu(self.layer3(x))\n if self.stochastic:\n x= x+ (x- self.memory[3]).detach()* torch.rand(x.shape) * self.sigmoid(self.SM.gamma[3])\n self.memory[3] = x.clone().detach()\n\n x = self.relu(self.layer4(x))\n return x","def eval_forward(self, x, u):\n\n if self.eval_forward_f is None:\n\n # conditional input\n tt_x = tt.matrix('x')\n\n # masked random numbers\n tt_u = tt.matrix('u')\n mu = self.mask * tt_u\n\n # scale net\n s_net = nn.FeedforwardNet(self.n_inputs + self.n_outputs, tt.concatenate([tt_x, mu], axis=1))\n for h in self.s_hiddens:\n s_net.addLayer(h, self.s_act)\n s_net.addLayer(self.n_outputs, 'linear')\n util.copy_model_parms(self.s_net, s_net)\n s = s_net.output\n\n # translate net\n t_net = nn.FeedforwardNet(self.n_inputs + self.n_outputs, tt.concatenate([tt_x, mu], axis=1))\n for h in self.t_hiddens:\n t_net.addLayer(h, self.t_act)\n t_net.addLayer(self.n_outputs, 'linear')\n util.copy_model_parms(self.t_net, t_net)\n t = t_net.output\n\n # transform (x,u) -> y\n y = mu + (1.0 - self.mask) * (tt_u * tt.exp(s) + t)\n\n # compile theano function\n self.eval_forward_f = theano.function(\n inputs=[tt_x, tt_u],\n outputs=y\n )\n\n return self.eval_forward_f(x.astype(dtype), u.astype(dtype))","def forward(self, state):\n\t\tx = F.relu(self.fc1(state))\n\t\tx = F.relu(self.fc2(x))\n\t\tx = F.tanh(self.fc3(x)) # outputs are in the range [-1, 1]\n\n\t\treturn x","def relu_backward(dout, cache):\n dx, x = None, cache\n dx = dout\n dout[x <= 0] = 0.0\n return dx","def relu_forward_hook_function(module, ten_in, ten_out):\n self.forward_relu_outputs.append(ten_out)","def relu(x, name):\n\n with tf.name_scope(name):\n outputs = tf.nn.relu(x)\n # Return layer's output\n return outputs"],"string":"[\n \"def relu_forward(x):\\n ############################################################################\\n # TODO: Implement the ReLU forward pass. #\\n ############################################################################\\n ############################################################################\\n # START OF YOUR CODE #\\n ############################################################################\\n out = x\\n out[out<0] = 0\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n return out\",\n \"def relu_forward(x):\\n out = None\\n ###########################################################################\\n # TODO: Implement the ReLU forward pass. #\\n ###########################################################################\\n out = x.copy()\\n out[x<=0] = 0\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n cache = x\\n return out, cache\",\n \"def relu_forward(x):\\n out = None\\n ###########################################################################\\n # TODO: Implement the ReLU forward pass. #\\n ###########################################################################\\n # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\\n out = np.where(x<=0, 0, x)\\n\\n pass\\n\\n # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n cache = x\\n return out, cache\",\n \"def relu_forward(x):\\n out = None\\n ###########################################################################\\n # TODO: Implement the ReLU forward pass. #\\n ###########################################################################\\n #out = np.zeros(x.shape)\\n #np.clip(x, 0, None, out)\\n out = np.empty_like(x) #faster than zeros\\n np.clip(x, 0, None, out)\\n #out = x\\n #out [out < 0] = 0\\n #print(x)\\n #print(out)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n cache = x\\n return out, cache\",\n \"def relu_forward(x):\\n out = None\\n ###########################################################################\\n # TODO: Implement the ReLU forward pass. #\\n ###########################################################################\\n out = x * (x > 0)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n cache = x\\n return out, cache\",\n \"def forward(self, x):\\n assert not torch.isnan(x).any(), f\\\"NaN in input {x}\\\"\\n x = F.relu(self.l1(x))\\n x = F.relu(self.l2(x))\\n x = self.l3(x)\\n return x\",\n \"def relu_forward(x):\\n out = None\\n ###########################################################################\\n # TODO: Implement the ReLU forward pass. #\\n ###########################################################################\\n out = np.maximum(0, x)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n cache = x\\n return out, cache\",\n \"def grad_ReLU(self):\\n y = self.x\\n y[y<=0] = 0\\n y[y>0] = 1\\n return y\\n raise NotImplementedError(\\\"ReLU gradient not implemented\\\")\",\n \"def forward(self, x):\\n res = self.residual(x)\\n x = self.gcn(x)\\n x = self.tcn(x) + res\\n return self.relu(x)\",\n \"def relu_forward(x):\\n out = None\\n ###########################################################################\\n # TODO: Implement the ReLU forward pass. #\\n ###########################################################################\\n out = np.maximum(x,0)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n cache = x\\n return out, cache\",\n \"def forward(self, x):\\n # Pass the input through all the layers apllying ReLU activation, but the last\\n for layer in self.fc_layers[:-1]:\\n x = F.relu(layer(x))\\n # Pass the result through the output layer apllying hyperbolic tangent function\\n x = torch.tanh(self.fc_layers[-1](x))\\n # Return the better action for the input state\\n return x\",\n \"def relu_grad(self, X):\\n X[X<=0]=0\\n X[X>0]=1\\n return X\",\n \"def update_relus(self):\\n\\n def relu_backward_hook_function(module, grad_in, grad_out):\\n \\\"\\\"\\\"\\n If there is a negative gradient, change it to zero\\n \\\"\\\"\\\"\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\\n\\n def relu_forward_hook_function(module, ten_in, ten_out):\\n \\\"\\\"\\\"\\n Store results of forward pass\\n \\\"\\\"\\\"\\n self.forward_relu_outputs.append(ten_out)\\n\\n # Loop through layers, hook up ReLUs\",\n \"def forward(self, x: torch.Tensor):\\n x = self.linear1(x)\\n x = torch.relu(x)\\n x = self.linear2(x)\\n x = self.dropout(x)\\n return x\",\n \"def forward(self, x):\\r\\n y = self.en_fc1(x)\\r\\n y = F.relu(y)\\r\\n y = self.en_fc2(y)\\r\\n y = F.relu(y)\\r\\n y = self.en_fc3(y)\\r\\n y = F.relu(y)\\r\\n\\r\\n mean = self.en_mu(y)\\r\\n stddev_p = self.en_log(y)\\r\\n \\r\\n n = x.shape[0]\\r\\n z = torch.randn(n,self.latent_dim)\\r\\n std = torch.exp(stddev_p/2.0)\\r\\n z = z.mul(std) + mean\\r\\n \\r\\n xhat = self.de_fc1(z)\\r\\n xhat = F.relu(xhat)\\r\\n xhat = self.de_fc2(xhat)\\r\\n xhat = F.relu(xhat)\\r\\n xhat = self.de_fc3(xhat)\\r\\n xhat = F.sigmoid(xhat)\\r\\n \\r\\n return y,mean,stddev_p,z,xhat\",\n \"def forward(self, x):\\n x = F.relu(self.fc1(x))\\n x = F.relu(self.fc2(x))\\n x = self.fc3(x)\\n return x\",\n \"def forward(self, state):\\n x = state\\n for layer in self.linear_layers[:-1]:\\n x = F.relu(layer(x))\\n x = self.linear_layers[-1](x)\\n return x\",\n \"def forward(self, x):\\n assert not torch.isnan(x).any(), f\\\"NaN in input {x}\\\"\\n x = F.relu(self.l1(x))\\n x = F.relu(self.l2(x))\\n x = self.l3(x)\\n return torch.clamp(x, -1, 1)\",\n \"def update_relus(self):\\n def relu_backward_hook_function(module, grad_in, grad_out):\\n \\\"\\\"\\\"\\n If there is a negative gradient, change it to zero\\n \\\"\\\"\\\"\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\\n\\n def relu_forward_hook_function(module, ten_in, ten_out):\\n \\\"\\\"\\\"\\n Store results of forward pass\\n \\\"\\\"\\\"\\n self.forward_relu_outputs.append(ten_out)\\n\\n # Loop through layers, hook up ReLUs\\n for pos, module in self.model.features._modules.items():\\n if isinstance(module, ReLU):\\n module.register_backward_hook(relu_backward_hook_function)\\n module.register_forward_hook(relu_forward_hook_function)\",\n \"def forward(self, x):\\n # x = state\\n \\n x = F.relu(self.input(x))\\n x = self.output(x)\\n \\n return x\",\n \"def forward(self, state):\\r\\n x = F.relu(self.linear1(state))\\r\\n x = F.relu(self.linear2(x))\\r\\n #x = torch.tanh(self.linear3(x))\\r\\n #x = F.relu(self.linear3(x))\\r\\n #x = nn.LeakyReLU(self.linear3(x), negative_slope=0.1)# .negativ_slope nur für leakyReLU relevant\\r\\n x = F.leaky_relu(self.linear3(x), 0.1)\\r\\n #x = F.softmax(self.linear3(x), dim=0)\\r\\n \\r\\n return x#.negativ_slope\",\n \"def update_relus(self):\\n def relu_backward_hook_function(module, grad_in, grad_out):\\n \\\"\\\"\\\"\\n If there is a negative gradient, change it to zero\\n \\\"\\\"\\\"\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\\n\\n def relu_forward_hook_function(module, ten_in, ten_out):\\n \\\"\\\"\\\"\\n Store results of forward pass\\n \\\"\\\"\\\"\\n self.forward_relu_outputs.append(ten_out)\\n\\n # Loop through layers, hook up ReLUs\\n for pos, module in self.model._features_extractor._modules.items():\\n for layer in module:\\n if isinstance(layer, LeakyReLU):\\n layer.register_backward_hook(relu_backward_hook_function)\\n layer.register_forward_hook(relu_forward_hook_function)\",\n \"def forward(self, x):\\n return self.relu(self.conv(x))\",\n \"def forward(self, x):\\n x = self.first_deconv(x)\\n x = self.first_batch_norm(x)\\n x = F.leaky_relu(x)\\n\\n x = self.second_deconv(x)\\n x = self.second_batch_norm(x)\\n x = F.leaky_relu(x)\\n\\n x = self.third_deconv(x)\\n x = self.third_batch_norm(x)\\n x = F.leaky_relu(x)\\n\\n x = self.fourth_deconv(x)\\n x = self.fourth_batch_norm(x)\\n\\n x = self.fifth_deconv(x)\\n x = self.fifth_batch_norm(x)\\n\\n x = self.sixth_deconv(x)\\n x = self.sixth_batch_norm(x)\\n\\n x = self.seventh_deconv(x)\\n\\n # sigmoid_out = nn.functional.sigmoid(x)\\n tanh_out = nn.functional.tanh(x)\\n\\n out = (tanh_out + 1) * 255 / 2\\n\\n # print 'out.shape =', out.shape\\n\\n return out\",\n \"def forward(self, state):\\n x = F.relu(self.linear1(state))\\n x = F.relu(self.linear2(x))\\n x = self.linear3(x)\\n return x\",\n \"def update_relus(self):\\n def relu_backward_hook_function(module, grad_in, grad_out):\\n \\\"\\\"\\\"\\n If there is a negative gradient, change it to zero\\n \\\"\\\"\\\"\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\\n\\n def relu_forward_hook_function(module, ten_in, ten_out):\\n \\\"\\\"\\\"\\n Store results of forward pass\\n \\\"\\\"\\\"\\n self.forward_relu_outputs.append(ten_out)\\n\\n # Loop through layers, hook up ReLUs\\n for pos, module in self.model.named_modules():\\n if isinstance(module, nn.ReLU):\\n module.register_backward_hook(relu_backward_hook_function)\\n module.register_forward_hook(relu_forward_hook_function)\",\n \"def update_relus(self):\\n def relu_backward_hook_function(module, grad_in, grad_out):\\n \\\"\\\"\\\"\\n If there is a negative gradient, change it to zero\\n \\\"\\\"\\\"\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\\n\\n def relu_forward_hook_function(module, ten_in, ten_out):\\n \\\"\\\"\\\"\\n Store results of forward pass\\n \\\"\\\"\\\"\\n self.forward_relu_outputs.append(ten_out)\\n\\n # Loop through layers, hook up ReLUs\\n for pos, module in self.model.named_modules():\\n if isinstance(module, ReLU):\\n module.register_backward_hook(relu_backward_hook_function)\\n module.register_forward_hook(relu_forward_hook_function)\",\n \"def forward(self, state):\\n x = F.relu(self.linear1(state))\\n x = F.relu(self.linear2(x))\\n x = torch.tanh(self.linear3(x))\\n\\n return x\",\n \"def relu_backward(dout, x):\\n ############################################################################\\n # TODO: Implement the ReLU backward pass. #\\n ############################################################################\\n ############################################################################\\n # START OF YOUR CODE #\\n ############################################################################\\n judge = x>0\\n dx = dout*judge\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n return dx\",\n \"def relu(input, inplace=False):\\n return FunctionLib.apply(\\n 'Relu', input.device, [input],\\n outputs=[input if inplace else None], alpha=0.)\",\n \"def forward(self,x):\\n x = x.transpose(1,2).contiguous()\\n x = F.leaky_relu(self.fc1(x), 0.2)\\n x = F.leaky_relu(self.bn2(self.fc2(x)), 0.2)\\n x = F.leaky_relu(self.bn3(self.fc3(x)), 0.2)\\n x = torch.sigmoid(self.fc4(x))\\n return x.transpose(1,2)\",\n \"def forward(self, state):\\n\\n x = state # Careful: deepcopy bug?\\n # Intermediate Layers\\n for layer in self.layers[:-1]:\\n\\n x = nn.ReLU()(layer(x))\\n\\n x = nn.Tanh()(self.layers[-1](x))\\n return x\",\n \"def relu_forward(x):\\n #raise NotImplementedError\\n #######################################################################\\n # #\\n # #\\n # TODO: YOUR CODE HERE #\\n # #\\n # #\\n #######################################################################\\n out=np.maximum(0,x)\\n cache=x\\n return out,cache\",\n \"def grad_ReLU(self):\\n grad = np.where(self.x > 0, 1, 0)\\n return grad\",\n \"def relu_backward(dout, cache):\\n dx, x = None, cache\\n ###########################################################################\\n # TODO: Implement the ReLU backward pass. #\\n ###########################################################################\\n # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\\n dx = np.where(x<=0, 0, 1) * dout\\n \\n\\n pass\\n\\n # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n return dx\",\n \"def forward(self, input_):\\n out = self.fc(input_)\\n out = self.bn(out)\\n out = self.relu(out)\\n return torch.cat([out, input_], dim=1)\",\n \"def forward(self, x):\\n l1 = self.dropout(F.relu(self.linear1(x)))\\n l2 = self.linear2(l1)\\n return l2\",\n \"def forward(self, state):#forward pass\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n return torch.tanh(self.fc3(x))\",\n \"def forward(self, x):\\n for i, layer in enumerate(self.layers):\\n x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x)\\n return x.squeeze(0)\",\n \"def relu_backward(self, dUpper, cache):\\n x = cache\\n #############################################################################\\n # TODO: Implement the ReLU backward pass. #\\n #############################################################################\\n x = np.array(x , copy=True)\\n x[x <= 0] = 0\\n x[x > 0] = 1\\n drelu = dUpper * x\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n return drelu\",\n \"def backward_deconvnet_relu(x):\\n def grad(dy):\\n return tf.nn.relu(dy)\\n return tf.nn.relu(x), grad\",\n \"def affine_layernorm_relu_forward(x, w, b, gamma, beta, ln_param):\\n fc_out, fc_cache = affine_forward(x, w, b)\\n norm_out, norm_cache = layernorm_forward(fc_out, gamma, beta, ln_param)\\n out, relu_cache = relu_forward(norm_out)\\n cache = (fc_cache, norm_cache, relu_cache)\\n return out, cache\",\n \"def update_relus(self):\\n def relu_backward_hook_function(module, grad_in, grad_out):\\n \\\"\\\"\\\"\\n If there is a negative gradient, change it to zero\\n \\\"\\\"\\\"\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\\n\\n def relu_forward_hook_function(module, ten_in, ten_out):\\n \\\"\\\"\\\"\\n Store results of forward pass\\n \\\"\\\"\\\"\\n self.forward_relu_outputs.append(ten_out)\\n\\n # Loop through layers, hook up ReLUs\\n for pos, module in self.model.encoder._modules.items():\\n if isinstance(module, ReLU):\\n module.register_backward_hook(relu_backward_hook_function)\\n module.register_forward_hook(relu_forward_hook_function)\",\n \"def reglu(x: Tensor) ->Tensor:\\n assert x.shape[-1] % 2 == 0\\n a, b = x.chunk(2, dim=-1)\\n return a * F.relu(b)\",\n \"def forward(self, state):\\n \\n x = F.relu(self.fc1(state)) \\n x = F.relu(self.fc2(x)) \\n x = F.tanh(self.fc3(x)) \\n \\n \\n ####x = F.relu(self.bn1(self.fc1(state)))\\n ####x = F.relu(self.bn2(self.fc2(x)))\\n ####x = torch.tanh(self.bn3(self.fc3(x)))\\n ##x = torch.tanh(self.fc3(x))\\n\\n return x\",\n \"def forward(self, t, x):\\n\\n out = F.relu(self.l1(t, x))\\n out = F.sigmoid(self.l2(t, out))\\n\\n return out\",\n \"def test_rnnt_loss_basic_forward_no_grad(self):\\n logits, targets, logit_lengths, target_lengths = rnnt_utils.get_basic_data(self.device)\\n logits.requires_grad_(False)\\n F.rnnt_loss(logits, targets, logit_lengths, target_lengths)\",\n \"def relu_forward(x):\\r\\n cache = x\\r\\n out = np.maximum(0, x)\\r\\n return out, cache\",\n \"def training_step(self, x):\\n self.train() # Sets network to train mode\\n rec_error, feat, y = self.forward(x)\\n # Reconstruction Loss\\n rec_loss = torch.mean(rec_error)\\n loss = rec_loss\\n\\n self.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n self.eval() # Sets network to evaluation mode\\n print('Rec Loss: {}'.format(rec_loss.cpu().data))\\n print()\\n return loss, feat, y\",\n \"def relu_forward(x):\\n out = None\\n out = np.maximum(0.0, x)\\n cache = x\\n return out, cache\",\n \"def _relu(layer):\\n return tf.nn.relu(layer)\",\n \"def training_step(self, x):\\n self.train()\\n rec_error, feat, y = self.forward(x)\\n # Reconstruction Loss\\n rec_loss = torch.mean(rec_error)\\n loss = rec_loss\\n\\n self.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n self.eval()\\n print('Rec Loss: {}'.format(rec_loss.cpu().data))\\n print()\\n return loss, feat, y\",\n \"def forward(self, x):\\r\\n\\r\\n y = self.conv1(x)\\r\\n y = self.bn1(y)\\r\\n y = F.relu(y, inplace = True)\\r\\n y = self.conv2(y)\\r\\n y = self.bn2(y)\\r\\n y = F.relu(y, inplace = True)\\r\\n\\r\\n return y\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n x = F.relu(self.fc3(x))\\n return self.fc4(x)\",\n \"def L_model_forward(X, parameters):\\n pass\",\n \"def conv_relu_forward(x, w, b, conv_param):\\n a, conv_cache = conv_forward_fast(x, w, b, conv_param)\\n out, relu_cache = relu_forward(a)\\n cache = (conv_cache, relu_cache)\\n return out, cache\",\n \"def conv_relu_forward(x, w, b, conv_param):\\n a, conv_cache = conv_forward_fast(x, w, b, conv_param)\\n out, relu_cache = relu_forward(a)\\n cache = (conv_cache, relu_cache)\\n return out, cache\",\n \"def relu_backward(dout, cache):\\n dx, x = None, cache\\n ###########################################################################\\n # TODO: Implement the ReLU backward pass. #\\n ###########################################################################\\n #print(dout)\\n dx = np.empty_like(dout)\\n np.copyto(dx, dout)\\n dx[x < 0] = 0\\n #print(dx)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n return dx\",\n \"def test_lu_forward_sub():\\t\\n\\t# test 1\\n\\tL = np.array([\\n\\t\\t[ 2, 3,-4, 2],\\n\\t\\t[-2, 1,-2, 1],\\n\\t\\t[ 1,-1, 3,-1],\\n\\t\\t[-3, 2, 2, 2]])\\t\\n\\n\\tb = np.array([4, -8, 9, 6])\\n\\n\\ty = lu_forward_sub(L, b) \\t\\t\\n\\ty_soln = np.array([4,0,5,8])\\t\\t\\t\\t\\t\\t# correct output of LU_FORWARD_SUB\\n\\tassert norm(y - y_soln) < 1.e-10\\n\\n\\t# test 2\\n\\tL2 = np.array([\\n\\t\\t [0.01, 0., 0., 0., 0., 0., 0., 0., 0., 0., 1],\\n\\t\\t [-100., 0.01, 0., 0., 0., 0., 0., 0., 0., 0., 100],\\n\\t\\t [0., -100., 0.01, 0., 0., 0., 0., 0., 0., 0., 10000],\\n\\t\\t [0., 0., -100., 0.01, 0., 0., 0., 0., 0., 0., 1000000],\\n\\t\\t [0., 0., 0., -100., 0.01, 0., 0., 0., 0., 0., 100000000],\\n\\t\\t [0., 0., 0., 0., -100., 0.01, 0., 0., 0., 0., 10000000000],\\n\\t\\t [0., 0., 0., 0., 0., -100., 0.01, 0., 0., 0., 1000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., -100., 0.01, 0., 0., 100000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., -100., 0.01, 0., 10000000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., 0., -100, 0.01, 1000000000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., 0., 0., -100., 100000000000000000000]])\\n\\n\\tb2 = np.array ([[1.01], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [-0.99], [0.]])\\n\\n\\ty2 = lu_forward_sub(L2, b2) \\t\\t\\n\\ty_soln2 = np.array([1.01, -101.99, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 98.01, 99])\\t\\t\\t\\t\\t\\t# correct output of LU_FORWARD_SUB\\n\\tassert norm(y2 - y_soln2) < 1.e-10\",\n \"def forward(self, x: torch.Tensor) -> torch.Tensor:\\n identity = x\\n\\n out = self.conv_reduce(x)\\n out = self.relu(self.bn_reduce(out))\\n\\n out = self.conv_conv(out)\\n out = self.relu(self.bn(out))\\n\\n out = self.conv_expand(out)\\n out = self.bn_expand(out)\\n\\n res = self.shortcut(identity)\\n return self.relu(res + out)\",\n \"def forward(self, x):\\n lay1 = self.linear1(x)\\n lay1 = nn.functional.relu(lay1)\\n\\n lay2 = self.linear2(lay1)\\n lay2 = nn.functional.relu(lay2)\\n \\n lay3_1 = self.linear3_1(lay2)\\n lay3_1 = nn.functional.relu(lay3_1)\\n\\n ## CHECK HERE TOO!!!\\n out_1 = self.linear4_1(lay3_1)\\n out_1 = out_1.view(-1, ) # reshape it to a 1d-array\\n \\n # taken care by BCEWithLogitsLoss\\n # out_1 = nn.functional.softmax(out_1, dim=0) \\n \\n lay3_2 = self.linear3_2(lay2)\\n lay3_2 = nn.functional.relu(lay3_2)\\n \\n out_2 = self.linear4_2(lay3_2)\\n \\n return out_1, out_2\",\n \"def forward(self, x):\\n h_relu = self.linear1(x).clamp(min=0)\\n y_pred = self.linear2(h_relu)\\n return y_pred\",\n \"def forward_step_layer(t1, t2, activation_f=torchfun.relu):\\n return batch_norm_tensor(activation_f(t1.bmm(t2)))\",\n \"def forward(self, x):\\r\\n x = self.conv1(x)\\r\\n x = self.conv1_BN(x)\\r\\n x = F.relu(x)\\r\\n x = self.conv1_dp(x)\\r\\n x = self.Block2_1(x)\\r\\n x = self.Block2_2(x)\\r\\n x = self.Block3_1(x)\\r\\n x = self.Block3_2(x)\\r\\n x = self.Block3_3(x)\\r\\n x = self.Block3_4(x)\\r\\n x = self.Block4_1(x)\\r\\n x = self.Block4_2(x)\\r\\n x = self.Block4_3(x)\\r\\n x = self.Block4_4(x)\\r\\n x = self.Block5_1(x)\\r\\n x = self.Block5_2(x)\\r\\n x = self.MP(x)\\r\\n x = x.view(x.size(0),-1)\\r\\n x = self.fc(x)\\r\\n \\r\\n return x\",\n \"def forward(self, state):\\n '''\\n state = F.relu(self.conv1(state))\\n state = F.relu(self.conv2(state))\\n state = F.relu(self.conv3(state))\\n state = F.relu(self.fc1(state))\\n \\n action = F.relu(self.fc2(state))\\n \\n return action\\n '''\\n \\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n x = self.fc3(x)\\n \\n return x\",\n \"def forward(self, x):\\r\\n x = x.reshape(x.shape[0], x.shape[1], 1 , 1)\\r\\n x = self.input(x)\\r\\n x = self.bn(x)\\r\\n x = F.relu(x)\\r\\n for i in range(len(self.DV)-1, -1, -1):\\r\\n x = self.DV[i](x)\\r\\n if i != 0:\\r\\n x = self.BN[i](x)\\r\\n x = F.relu(x)\\r\\n for col, t in enumerate(self.col_type):\\r\\n i = int(col/self.shape)\\r\\n j = col % self.shape\\r\\n if t == \\\"binary\\\":\\r\\n x[:,:,i,j] = torch.sigmoid(x[:,:,i,j])\\r\\n elif t == \\\"normalize\\\":\\r\\n x[:,:,i,j] = torch.tanh(x[:,:,i,j])\\r\\n else:\\r\\n x[:,:,i,j] = torch.relu(x[:,:,i,j])\\r\\n return x\",\n \"def test_relu(self):\\n activation_name = 'ReLU'\\n args = {}\\n\\n activation = activation_factory.create(activation_name, **args)\\n self.assertEqual(activation._get_name(), activation_name)\\n\\n x = torch.ones(10) * -1\\n y = activation(x)\\n self.assertEqual(len(torch.nonzero(y, as_tuple=False)), 0)\",\n \"def forward(self, x):\\n\\n out = torch.relu(self.conv1(x))\\n out = torch.relu(self.conv2(out))\\n\\n out = torch.relu(self.resnet_block(out))\\n\\n out = torch.relu(self.deconv1(out))\\n out = torch.tanh(self.deconv2(out))\\n\\n return out\",\n \"def forward(self, x):\\n h_relu = self.linear1(x).clamp(min=0)\\n h_relu2 = self.linear2(h_relu)\\n h_relu3 = self.linear3(h_relu2)\\n y_pred = self.linear4(h_relu3)\\n return y_pred\",\n \"def relu_backward(dout, cache):\\n dx, x = None, cache\\n ###########################################################################\\n # TODO: Implement the ReLU backward pass. #\\n ###########################################################################\\n dx = dout * (x > 0)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n return dx\",\n \"def relu_backward(dout, cache):\\n dx, x = None, cache\\n ###########################################################################\\n # TODO: Implement the ReLU backward pass. #\\n ###########################################################################\\n dx = dout * (x > 0)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n return dx\",\n \"def forward(self, x):\\n x=T.div(x,255.0)\\n \\n #print(state[20:,20:,0])\\n #print(state[:,0,:,:])\\n conv1 = F.relu(self.conv1(x))\\n conv2 = F.relu(self.conv2(conv1))\\n conv3 = F.relu(self.conv3(conv2))\\n ###\\n conv_state = conv3.view(conv3.size()[0], -1)\\n flat1 = F.relu(self.fc1(conv_state))\\n flat2 = F.relu(self.fc2(flat1))\\n\\n V = self.V(flat2)\\n A = self.A(flat2)\\n\\n return V, A\\n return x\",\n \"def relu_backward(dout, cache):\\n dx, x = None, cache\\n ###########################################################################\\n # TODO: Implement the ReLU backward pass. #\\n ###########################################################################\\n dx = dout.copy()\\n dx[x<=0] = 0\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n return dx\",\n \"def guided_backpropagation_relu(x):\\n def grad(dy):\\n return tf.nn.relu(dy) * tf.cast(x > 0.0, x.dtype)\\n return tf.nn.relu(x), grad\",\n \"def forward(self, state):\\n x = state.unsqueeze(1)\\n x = F.relu(self.cnl1(x))\\n x = F.relu(self.cnl2(x))\\n x = F.relu(self.cnl3(x))\\n x = x.view(x.shape[0], -1) # flatten\\n x = F.relu(self.dense1(x))\\n x = self.out(x)\\n return x\",\n \"def forward(self, state):\\n x = f.relu(self.fc1(state))\\n x = f.relu(self.fc2(x))\\n return torch.tanh(self.fc3(x))\",\n \"def lrelu(self):\\n return self.add_layer(lrelu)\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n return self.fc3(x)\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n return self.fc3(x)\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n return self.fc3(x)\",\n \"def __call__(self, x):\\n h = F.relu(self.l0(x))\\n h = F.relu(self.l1(h))\\n return self.l2(h)\",\n \"def forward(self, x):\\n h = self.linear1(x)\\n h = torch.nn.functional.relu(h)\\n h = self.linear2(h)\\n h = torch.nn.functional.relu(h)\\n h = self.linear3(h)\\n y_pred = torch.sigmoid(h)\\n return y_pred\",\n \"def forward(self, x, h_last=None):\\n\\n # forward pass of the RNNLM network\\n\\n embedding = self.emb(x)\\n y, h = self.gru(embedding, h_last)\\n out = self.linear(y)\\n return out, h\",\n \"def forward(self, x):\\n h_relu = self.linear1(x).clamp(min=0)\\n h_relu2 = self.linear2(h_relu)\\n y_pred = self.linear4(h_relu2)\\n return y_pred\",\n \"def test_relu_activation(self):\\n self.assertEqual([0, 0.5], list(\\n af.Relu().output(np.array([-0.5, 0.5]))))\\n self.assertEqual([0, 1], list(\\n af.Relu().derivative(np.array([-0.5, 0.5]))))\",\n \"def forward(self, state):\\n \\n for linear in self.hidden_layers:\\n state = F.relu(linear(state))\\n \\n return self.output(state)\",\n \"def forward(self, x):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n\\n x = self.pool1(F.relu(self.batch1(self.conv1(x))))\\n x = self.pool2(F.relu(self.batch2(self.conv2(x))))\\n x = F.relu(self.batch3a(self.conv3a(x)))\\n x = self.pool3(F.relu(self.batch3b(self.conv3b(x))))\\n x = F.relu(self.batch4a(self.conv4a(x)))\\n x = self.pool4(F.relu(self.batch4b(self.conv4b(x))))\\n x = F.relu(self.batch5a(self.conv5a(x)))\\n x = self.pool5(F.relu(self.batch5b(self.conv5b(x))))\\n x = self.avgpool(x)\\n x = x.reshape(x.shape[0], -1)\\n out = self.fc1(x)\\n\\n# raise NotImplementedError\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return out\",\n \"def forward(self, x):\\n # define feedforward behavior, applying activations as necessary\\n out = self.leaky_relu(self.conv1(x))\\n out = self.leaky_relu(self.conv2(out))\\n out = self.leaky_relu(self.conv3(out))\\n out = self.leaky_relu(self.conv4(out))\\n\\n out = self.res_blocks(out)\\n\\n out = self.leaky_relu(self.deconv1(out))\\n out = self.leaky_relu(self.deconv2(out))\\n out = self.leaky_relu(self.deconv3(out))\\n\\n # tanh applied to last layer\\n out = F.tanh(self.out_layer(out))\\n out = torch.clamp(out, min=-0.5, max=0.5)\\n\\n return out\",\n \"def forward(self, x):\\n \\n x = F.relu(self.conv1_bn(self.conv1(self.conv0_bn(x))))\\n x = F.relu(self.conv2_bn(self.conv2(x)))\\n x = F.relu(self.conv3_bn(self.conv3( self.maxpool2(x))))\\n x = F.relu(self.conv4_bn(self.conv4( self.maxpool3(x))))\\n x = self.maxpool4(x) \\n x = x.view(-1, 1184)\\n x = F.relu(self.fc1(x))\\n x = self.dense1_bn(x)\\n x = F.dropout(x, training=self.training)\\n x = self.fc2(x)\\n return F.log_softmax(x)\",\n \"def forward(self,x):\\n \\n out,_ = self.lstm(x,self.hidden)\\n out = out.detach()\\n x = out[:,-1,:][-1]\\n x = self.relu(x)\\n if self.stochastic:\\n x= x+ (x- self.memory[0]).detach()* torch.rand(x.shape) * self.sigmoid(self.SM.gamma[0])\\n self.memory[0] = x.clone().detach()\\n\\n x = self.relu(self.layer1(x))\\n if self.stochastic:\\n x= x+ (x- self.memory[1]).detach()* torch.rand(x.shape) * self.sigmoid(self.SM.gamma[1])\\n self.memory[1] = x.clone().detach()\\n\\n x = self.relu(self.layer2(x))\\n if self.stochastic:\\n x= x+ (x- self.memory[2]).detach()* torch.rand(x.shape) * self.sigmoid(self.SM.gamma[2])\\n self.memory[2] = x.clone().detach()\\n\\n x = self.relu(self.layer3(x))\\n if self.stochastic:\\n x= x+ (x- self.memory[3]).detach()* torch.rand(x.shape) * self.sigmoid(self.SM.gamma[3])\\n self.memory[3] = x.clone().detach()\\n\\n x = self.relu(self.layer4(x))\\n return x\",\n \"def eval_forward(self, x, u):\\n\\n if self.eval_forward_f is None:\\n\\n # conditional input\\n tt_x = tt.matrix('x')\\n\\n # masked random numbers\\n tt_u = tt.matrix('u')\\n mu = self.mask * tt_u\\n\\n # scale net\\n s_net = nn.FeedforwardNet(self.n_inputs + self.n_outputs, tt.concatenate([tt_x, mu], axis=1))\\n for h in self.s_hiddens:\\n s_net.addLayer(h, self.s_act)\\n s_net.addLayer(self.n_outputs, 'linear')\\n util.copy_model_parms(self.s_net, s_net)\\n s = s_net.output\\n\\n # translate net\\n t_net = nn.FeedforwardNet(self.n_inputs + self.n_outputs, tt.concatenate([tt_x, mu], axis=1))\\n for h in self.t_hiddens:\\n t_net.addLayer(h, self.t_act)\\n t_net.addLayer(self.n_outputs, 'linear')\\n util.copy_model_parms(self.t_net, t_net)\\n t = t_net.output\\n\\n # transform (x,u) -> y\\n y = mu + (1.0 - self.mask) * (tt_u * tt.exp(s) + t)\\n\\n # compile theano function\\n self.eval_forward_f = theano.function(\\n inputs=[tt_x, tt_u],\\n outputs=y\\n )\\n\\n return self.eval_forward_f(x.astype(dtype), u.astype(dtype))\",\n \"def forward(self, state):\\n\\t\\tx = F.relu(self.fc1(state))\\n\\t\\tx = F.relu(self.fc2(x))\\n\\t\\tx = F.tanh(self.fc3(x)) # outputs are in the range [-1, 1]\\n\\n\\t\\treturn x\",\n \"def relu_backward(dout, cache):\\n dx, x = None, cache\\n dx = dout\\n dout[x <= 0] = 0.0\\n return dx\",\n \"def relu_forward_hook_function(module, ten_in, ten_out):\\n self.forward_relu_outputs.append(ten_out)\",\n \"def relu(x, name):\\n\\n with tf.name_scope(name):\\n outputs = tf.nn.relu(x)\\n # Return layer's output\\n return outputs\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6923425","0.6670239","0.6663412","0.6650045","0.6630312","0.65392053","0.64895386","0.648836","0.64600945","0.6429588","0.6399773","0.63981783","0.63528794","0.63357466","0.63077855","0.62966233","0.6285175","0.6278084","0.62459034","0.62427825","0.6203059","0.6195473","0.6194887","0.61704004","0.61551404","0.61313015","0.6124539","0.61058307","0.610198","0.610122","0.6096404","0.60958433","0.6087261","0.6077667","0.6052422","0.60494035","0.6037721","0.60364366","0.60275775","0.5979795","0.5964194","0.5949849","0.59453547","0.5936542","0.5935005","0.59293693","0.5925396","0.5924298","0.59238154","0.59177035","0.590718","0.58984226","0.5898301","0.5889265","0.588795","0.58806723","0.58806723","0.58792156","0.58746916","0.5866597","0.5861221","0.5857868","0.5852536","0.58447963","0.58409965","0.5838333","0.5836605","0.5831384","0.58281267","0.5827927","0.5827927","0.5825631","0.58165324","0.5812338","0.5811397","0.5806171","0.5794222","0.5790487","0.5790487","0.5790487","0.5790487","0.5790487","0.57844543","0.57844543","0.57844543","0.57831377","0.5781299","0.578086","0.5780857","0.5775545","0.57733357","0.5772581","0.57708067","0.576802","0.57586265","0.57557106","0.5753156","0.57520837","0.5751358","0.57509285"],"string":"[\n \"0.6923425\",\n \"0.6670239\",\n \"0.6663412\",\n \"0.6650045\",\n \"0.6630312\",\n \"0.65392053\",\n \"0.64895386\",\n \"0.648836\",\n \"0.64600945\",\n \"0.6429588\",\n \"0.6399773\",\n \"0.63981783\",\n \"0.63528794\",\n \"0.63357466\",\n \"0.63077855\",\n \"0.62966233\",\n \"0.6285175\",\n \"0.6278084\",\n \"0.62459034\",\n \"0.62427825\",\n \"0.6203059\",\n \"0.6195473\",\n \"0.6194887\",\n \"0.61704004\",\n \"0.61551404\",\n \"0.61313015\",\n \"0.6124539\",\n \"0.61058307\",\n \"0.610198\",\n \"0.610122\",\n \"0.6096404\",\n \"0.60958433\",\n \"0.6087261\",\n \"0.6077667\",\n \"0.6052422\",\n \"0.60494035\",\n \"0.6037721\",\n \"0.60364366\",\n \"0.60275775\",\n \"0.5979795\",\n \"0.5964194\",\n \"0.5949849\",\n \"0.59453547\",\n \"0.5936542\",\n \"0.5935005\",\n \"0.59293693\",\n \"0.5925396\",\n \"0.5924298\",\n \"0.59238154\",\n \"0.59177035\",\n \"0.590718\",\n \"0.58984226\",\n \"0.5898301\",\n \"0.5889265\",\n \"0.588795\",\n \"0.58806723\",\n \"0.58806723\",\n \"0.58792156\",\n \"0.58746916\",\n \"0.5866597\",\n \"0.5861221\",\n \"0.5857868\",\n \"0.5852536\",\n \"0.58447963\",\n \"0.58409965\",\n \"0.5838333\",\n \"0.5836605\",\n \"0.5831384\",\n \"0.58281267\",\n \"0.5827927\",\n \"0.5827927\",\n \"0.5825631\",\n \"0.58165324\",\n \"0.5812338\",\n \"0.5811397\",\n \"0.5806171\",\n \"0.5794222\",\n \"0.5790487\",\n \"0.5790487\",\n \"0.5790487\",\n \"0.5790487\",\n \"0.5790487\",\n \"0.57844543\",\n \"0.57844543\",\n \"0.57844543\",\n \"0.57831377\",\n \"0.5781299\",\n \"0.578086\",\n \"0.5780857\",\n \"0.5775545\",\n \"0.57733357\",\n \"0.5772581\",\n \"0.57708067\",\n \"0.576802\",\n \"0.57586265\",\n \"0.57557106\",\n \"0.5753156\",\n \"0.57520837\",\n \"0.5751358\",\n \"0.57509285\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67316556"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":12195,"cells":{"query":{"kind":"string","value":"Computes the backward pass for a layer of rectified linear units (ReLUs)."},"document":{"kind":"string","value":"def relu_backward(self, dUpper, cache):\n x = cache\n #############################################################################\n # TODO: Implement the ReLU backward pass. #\n #############################################################################\n x = np.array(x , copy=True)\n x[x <= 0] = 0\n x[x > 0] = 1\n drelu = dUpper * x\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n return drelu"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def backward(ctx, grad_output):\n loss, reg, u, lbda = ctx.saved_tensors\n\n device = u.device\n\n # do clever computations\n eps = 1e-10\n grad, = torch.autograd.grad(loss, u, only_inputs=True,\n retain_graph=True)\n x = (u - eps * grad).data\n lbda = lbda.data\n\n prox_x = check_tensor(\n np.array([prox_tv.tv1_1d(xx, eps * lbda) for xx in x]),\n device=device,\n )\n grad_u = (u - prox_x) / eps\n grad_lbda = reg.clone()\n return (torch.ones(0), grad_u, grad_lbda)","def conv_relu_backward(dout, cache):\n conv_cache, relu_cache = cache\n da = layers.relu_backward(dout, relu_cache)\n dx, dw, db = layers.conv_backward_fast(da, conv_cache)\n return dx, dw, db","def conv_relu_backward(dout, cache):\n conv_cache, relu_cache = cache\n da = relu_backward(dout, relu_cache)\n dx, dw, db = conv_backward_fast(da, conv_cache)\n return dx, dw, db","def conv_relu_backward(dout, cache):\n conv_cache, relu_cache = cache\n da = relu_backward(dout, relu_cache)\n dx, dw, db = conv_backward_fast(da, conv_cache)\n return dx, dw, db","def backward_deconvnet_relu(x):\n def grad(dy):\n return tf.nn.relu(dy)\n return tf.nn.relu(x), grad","def relu_backward(dout, cache):\n dx, x = None, cache\n ###########################################################################\n # TODO: Implement the ReLU backward pass. #\n ###########################################################################\n # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n dx = np.where(x<=0, 0, 1) * dout\n \n\n pass\n\n # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n return dx","def backward_pass(self, loss):\n\n self.optimizer.zero_grad()\n self.optimizer.backward(loss)\n self.optimizer.step()","def backward_D(self):\n self.loss_D.backward()","def backward(ctx, grad_L):\n A, T = ctx.saved_tensors\n\n grad_A = None\n grad_T = None\n\n B = A.shape[0]\n\n # We only need to compute gradients for tensors that are flagged to\n # require gradients!\n if ctx.needs_input_grad[0]:\n grad_A = (A - T) / B\n\n if ctx.needs_input_grad[1]:\n grad_T = (T - A) / B\n\n return grad_A, grad_T","def _backward(loss):\n\n loss.backward()","def backward_pass(self, grad):\n pass","def L_model_backward(AL, Y, caches):\n pass","def relu_backward(dout, cache):\n dx, x = None, cache\n ###########################################################################\n # TODO: Implement the ReLU backward pass. #\n ###########################################################################\n dx = dout.copy()\n dx[x<=0] = 0\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n return dx","def backward(self, inputs, grad_loss_input):\n raise NotImplementedError","def relu_backward(dout, x):\n ############################################################################\n # TODO: Implement the ReLU backward pass. #\n ############################################################################\n ############################################################################\n # START OF YOUR CODE #\n ############################################################################\n judge = x>0\n dx = dout*judge\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n return dx","def backward_G(self):\n self.loss_G.backward()","def relu_backward(dout, cache):\n dx, x = None, cache\n ###########################################################################\n # TODO: Implement the ReLU backward pass. #\n ###########################################################################\n dx = dout * (x > 0)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n return dx","def relu_backward(dout, cache):\n dx, x = None, cache\n ###########################################################################\n # TODO: Implement the ReLU backward pass. #\n ###########################################################################\n dx = dout * (x > 0)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n return dx","def backward(self, lhs: Tensor, rhs: Tensor, acc_grad: np.ndarray):\n raise NotImplementedError","def relu_backward_hook_function(module, grad_in, grad_out):\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)","def relu_backward_hook_function(module, grad_in, grad_out):\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)","def relu_backward_hook_function(module, grad_in, grad_out):\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)","def relu_backward_hook_function(module, grad_in, grad_out):\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)","def relu_backward_hook_function(module, grad_in, grad_out):\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)","def backward(ctx, dy):\n y = ctx.y\n if ctx.eagerly_discard_variables:\n del ctx.y\n for i in range(len(ctx.reversible_blocks) - 1, -1, -1):\n y, dy = ctx.reversible_blocks[i].backward_pass(y, dy, not ctx.eagerly_discard_variables)\n if ctx.eagerly_discard_variables:\n del ctx.reversible_blocks\n return dy, None, None","def relu_backward(dout, cache):\n dx, x = None, cache\n ###########################################################################\n # TODO: Implement the ReLU backward pass. #\n ###########################################################################\n #print(dout)\n dx = np.empty_like(dout)\n np.copyto(dx, dout)\n dx[x < 0] = 0\n #print(dx)\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n return dx","def relu_backward_hook_function(module, grad_in, grad_out):\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)","def L_model_backward(AL, Y, caches):\n grads = {}\n L = len(caches) # the number of layers\n m = AL.shape[1]\n Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL\n\n dAL = -(np.divide(Y,AL)-np.divide(1-Y,1-AL))\n \"\"\"\n cache = caches[-1]\n grads[\"dA\"+str(L)],grads[\"dW\"+str(L)],grads[\"db\"+str(L)] = linear_activation_backward(dAL,cache,activation = 'sigmoid')\n\n for i in reversed(range(L-1)):\n grads[\"dA\"+str(i+1)],grads[\"dW\"+str(i+1)],grads[\"db\"+str(i+1)] = linear_activation_backward(grads[\"dA\"+str(i+2)],caches[i],activation = 'relu')\n \"\"\"\n\n current_cache = caches[-1]\n grads[\"dA\" + str(L)], grads[\"dW\" + str(L)], grads[\"db\" + str(L)] = linear_backward(sigmoid_backward(dAL, current_cache[1]),current_cache[0])\n\n for l in reversed(range(L - 1)):\n # lth layer: (RELU -> LINEAR) gradients.\n # Inputs: \"grads[\"dA\" + str(l + 2)], caches\". Outputs: \"grads[\"dA\" + str(l + 1)] , grads[\"dW\" + str(l + 1)] , grads[\"db\" + str(l + 1)]\n ### START CODE HERE ### (approx. 5 lines)\n current_cache = caches[l]\n dA_prev_temp, dW_temp, db_temp = linear_backward(sigmoid_backward(dAL, current_cache[1]), current_cache[0])\n grads[\"dA\" + str(l + 1)] = dA_prev_temp\n grads[\"dW\" + str(l + 1)] = dW_temp\n grads[\"db\" + str(l + 1)] = db_temp\n ### END CODE HERE ###\n\n return grads","def _AffLayerReluDrop_Backprop(self, dscores, cache):\n grads = {}\n loss = None\n #Last Softmax Layer\n ##Add L2 Regularization loss\n loss = 0.5 * self.reg * np.sum(self.params['W{0}'.format(self.num_layers)]**2)\n ##Calculate grads for last Affine\n dhid, grads['W{0}'.format(self.num_layers)], grads['b{0}'.format(self.num_layers)] =\\\n affine_backward(dscores, cache[-1])\n grads['W{0}'.format(self.num_layers)] += self.reg * self.params['W{0}'.format(self.num_layers)]\n\n for i in range(self.num_layers-1, 0, -1): #hidden layers\n ##L2 Reg. loss\n loss += 0.5 * self.reg * np.sum(self.params['W{0}'.format(i)]**2)\n ##Calculate grads for [{affine-Batchnorm-relu} X (L-1)]\n dhid = dropout_backward(dhid, cache[i]['drop'])\n dhid = relu_backward(dhid, cache[i]['relu'])\n dhid, grads['gamma{0}'.format(i)], grads['beta{0}'.format(i)] = \\\n layernorm_backward(dhid, cache[i]['layernorm'])\n dhid, grads['W{0}'.format(i)], grads['b{0}'.format(i)] = \\\n affine_backward(dhid, cache[i]['affine']) \n grads['W{0}'.format(i)] += self.reg * self.params['W{0}'.format(i)]\n\n return grads, loss","def backward(self, inputs, gradients, **kwargs):\n grad_relu = inputs > 0\n return gradients * grad_relu","def backward(self, loss):\n global_timer.my_timer.start_profile(\"BWD\")\n mgr = PatrickStarManager()\n mgr.set_training_stage(TrainingStage.BWD)\n\n for param_fp16 in self.client.chunk_based_param_fp16:\n param_fp16.ps_attr.bwd_used_cnt = 0\n\n self.optimizer.zero_grad()\n if self.loss_scaler:\n self.loss_scaler.backward(loss)\n else:\n loss.backward()\n mgr.update_margin_mem()\n global_timer.my_timer.finish_profile(\"BWD\")","def relu_backward(dout, cache):\n #raise NotImplementedError\n #######################################################################\n # #\n # #\n # TODO: YOUR CODE HERE #\n # #\n # #\n #######################################################################\n x=cache\n dout[x<=0]=0\n dx=dout\n return dx","def affine_relu_backward(dout, cache):\n fc_cache, relu_cache = cache\n da = layers.relu_backward(dout, relu_cache)\n dx, dw, db = layers.affine_backward(da, fc_cache)\n return dx, dw, db","def relu_backward(dA, internal_params):\n\n Z = internal_params\n dZ = np.array(dA, copy=True)\n\n dZ[Z <= 0] = 0\n\n return dZ","def backward(\n self, X: np.ndarray, y: np.ndarray, lr: float, reg: float = 0.0\n ) -> float:\n y_hat = self.forward(X)\n\n y_one_hot = self.one_hot_encode(y)\n loss = CrossEntropy.forward(y_one_hot, y_hat)\n\n d_layer = CrossEntropy.backward(y, y_hat)\n\n w_grads = []\n b_grads = []\n\n for idx, layer in reversed(list(enumerate(self.layers))):\n # Not output layer\n if (idx + 1) < len(self.layers):\n next_layer = self.layers[idx + 1]\n\n d_layer = d_layer.dot(next_layer.w.T)\n d_layer = layer.activation_func.backward(d_layer, layer.activated_out)\n\n d_w = layer.linear_in.T.dot(d_layer) + 2 * reg * layer.w\n d_b = np.sum(d_layer, axis=0)\n\n w_grads.insert(0, d_w)\n b_grads.insert(0, d_b)\n\n self.optimizer.step(self.layers, w_grads, b_grads, lr)\n\n if self.norm_weights:\n w_norm = max(np.linalg.norm(l.w) for l in self.layers) / len(self.layers)\n b_norm = max(np.linalg.norm(l.w) for l in self.layers) / len(self.layers)\n for layer in self.layers:\n layer.w /= w_norm\n layer.b /= b_norm\n\n return loss","def backward_pass(self):\r\n # the gradient of cross-entropy on top of softmax is (t-y)\r\n back_output = (self.targets - self.y) / self.y.shape[0]\r\n\r\n for layer in reversed(self.layers):\r\n back_output = layer.backward_pass(back_output)","def backward_and_step(self, loss):\n self.opt.zero_grad()\n loss.backward()\n self.opt.step()","def backward(self, X, Y, P, H, lmd):\n G = - (Y - P)\n _, Npts = P.shape\n n_layers = len(self.hidden_units)\n\n gradients_W = []\n gradients_b = []\n\n for i in range(n_layers, -1, -1):\n\n if i == 0:\n grad_W = G @ X.T * (1/Npts) + 2 * lmd * self.W[i]\n grad_b = G @ np.ones((Npts, 1)) * (1/Npts)\n\n else:\n\n h = H[i - 1]\n w = self.W[i]\n grad_W = G @ h.T * (1/Npts) + 2 * lmd * w\n grad_b = G @ np.ones((Npts, 1)) * (1/Npts)\n\n G = w.T @ G\n G = G * np.where(h > 0, 1, 0)\n\n gradients_W.append(grad_W)\n gradients_b.append(grad_b)\n\n return gradients_W, gradients_b","def leakrelu_backward(dA, Z):\n\n # When z <= 0, dz = 0.01\n derivative = np.ones(Z.shape)\n derivative[Z < 0] = 0.01\n\n dZ = dA * derivative\n\n assert (dZ.shape == Z.shape)\n\n return dZ","def conv_bn_relu_backward(dout, cache):\n conv_cache, sbn_cache, relu_cache = cache\n da = relu_backward(dout, relu_cache)\n dan, dgamma, dbeta = spatial_batchnorm_backward(da, sbn_cache)\n dx, dw, db = conv_backward_fast(dan, conv_cache)\n return dx, dw, db, dgamma, dbeta","def update_relus(self):\n\n def relu_backward_hook_function(module, grad_in, grad_out):\n \"\"\"\n If there is a negative gradient, change it to zero\n \"\"\"\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)\n\n def relu_forward_hook_function(module, ten_in, ten_out):\n \"\"\"\n Store results of forward pass\n \"\"\"\n self.forward_relu_outputs.append(ten_out)\n\n # Loop through layers, hook up ReLUs","def backward(self, gradient):\n raise NotImplementedError()","def relu_backward(dout, cache):\n dx, x = None, cache\n ###########################################################################\n # TODO: Implement the ReLU backward pass. #\n ###########################################################################\n dx = dout * ((x > 0).astype(int))\n ###########################################################################\n # END OF YOUR CODE #\n ###########################################################################\n return dx","def relu_backward(dout, cache):\n dx, x = None, cache\n dx = dout\n dout[x <= 0] = 0.0\n return dx","def affine_relu_backward(dout, cache):\n fc_cache, relu_cache = cache\n da = relu_backward(dout, relu_cache)\n dx, dw, db = affine_backward(da, fc_cache)\n return dx, dw, db","def affine_relu_backward(dout, cache):\n fc_cache, relu_cache = cache\n da = relu_backward(dout, relu_cache)\n dx, dw, db = affine_backward(da, fc_cache)\n return dx, dw, db","def affine_relu_backward(dout, cache):\n fc_cache, relu_cache = cache\n da = relu_backward(dout, relu_cache)\n dx, dw, db = affine_backward(da, fc_cache)\n return dx, dw, db","def affine_relu_backward(dout, cache):\n fc_cache, relu_cache = cache\n da = relu_backward(dout, relu_cache)\n dx, dw, db = affine_backward(da, fc_cache)\n return dx, dw, db","def backward(self, gradient):\n #TODO\n pass","def backward(self, gradient):\n #TODO\n pass","def L_model_backward(AL, Y, caches, use_batchnorm, batchnorm_cache, dropout_cache):\n\n grads = {}\n num_layers = len(caches)\n use_dropout = len(dropout_cache) != 0\n\n last_layer_idx = num_layers\n dA, dW, db = linear_backward(AL - Y, caches[-1]['linear_cache'])\n grads['dA' + str(last_layer_idx)] = dA\n grads['dW' + str(last_layer_idx)] = dW\n grads['db' + str(last_layer_idx)] = db\n\n for layer_idx in reversed(range(1, num_layers)):\n if use_dropout:\n dA = dropout_backward(dA, dropout_cache[layer_idx])\n\n dA, dW, db = linear_activation_backward(dA , caches[layer_idx - 1], \"relu\", use_batchnorm, batchnorm_cache[layer_idx])\n grads['dA' + str(layer_idx)] = dA\n grads['dW' + str(layer_idx)] = dW\n grads['db' + str(layer_idx)] = db\n\n return grads","def backwards(delta,params,name='',activation_deriv=sigmoid_deriv):\n # everything you may need for this layer\n W = params['W' + name]\n b = params['b' + name]\n X, pre_act, post_act = params['cache_' + name]\n # your code here\n # do the derivative through activation first\n # then compute the derivative W,b, and X\n \n delta_pre = activation_deriv(post_act) * delta\n # (in_dim, out_dim) = (in_dim, examples) @ (examples, out_dim)\n grad_W = X.transpose() @ delta_pre\n grad_b = np.sum(delta_pre, axis=0, keepdims=True) # (1, out_dim)\n # (examples, in_dim) = (examples, out_dim) @ (out_dim, in_dim)\n grad_X = delta_pre @ W.transpose()\n\n # store the gradients\n params['grad_W' + name] = grad_W\n params['grad_b' + name] = grad_b\n return grad_X","def relu_backward(dout, cache):\r\n x = cache\r\n dx = dout * (x > 0)\r\n return dx","def update_relus(self):\n def relu_backward_hook_function(module, grad_in, grad_out):\n \"\"\"\n If there is a negative gradient, change it to zero\n \"\"\"\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)\n\n def relu_forward_hook_function(module, ten_in, ten_out):\n \"\"\"\n Store results of forward pass\n \"\"\"\n self.forward_relu_outputs.append(ten_out)\n\n # Loop through layers, hook up ReLUs\n for pos, module in self.model._features_extractor._modules.items():\n for layer in module:\n if isinstance(layer, LeakyReLU):\n layer.register_backward_hook(relu_backward_hook_function)\n layer.register_forward_hook(relu_forward_hook_function)","def backward(self, dout):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n for l in range(len(self.layers)-1,-1,-1):\n act_dout = self.activations[l].backward(dout)\n dout = self.layers[l].backward(act_dout)\n ########################\n # END OF YOUR CODE #\n #######################\n\n return","def grad_ReLU(self):\n y = self.x\n y[y<=0] = 0\n y[y>0] = 1\n return y\n raise NotImplementedError(\"ReLU gradient not implemented\")","def conv_relu_backward_naive(dout, cache):\n\tconv_cache, relu_cache = cache\n\tda = relu_backward(dout, relu_cache)\n\tdx, dw, db = conv_backward_naive(da, conv_cache)\n\treturn dx, dw, db","def _AffLayerRelu_Backprop(self, dscores, cache):\n grads = {}\n loss = None\n #Last Softmax Layer\n ##Add L2 Regularization loss\n loss = 0.5 * self.reg * np.sum(self.params['W{0}'.format(self.num_layers)]**2)\n ##Calculate grads for last Affine\n dhid, grads['W{0}'.format(self.num_layers)], grads['b{0}'.format(self.num_layers)] =\\\n affine_backward(dscores, cache[-1])\n grads['W{0}'.format(self.num_layers)] += self.reg * self.params['W{0}'.format(self.num_layers)]\n\n for i in range(self.num_layers-1, 0, -1): #hidden layers\n ##L2 Reg. loss\n loss += 0.5 * self.reg * np.sum(self.params['W{0}'.format(i)]**2)\n ##Calculate grads for [{affine-Batchnorm-relu} X (L-1)]\n dhid = relu_backward(dhid, cache[i]['relu'])\n dhid, grads['gamma{0}'.format(i)], grads['beta{0}'.format(i)] = \\\n layernorm_backward(dhid, cache[i]['layernorm'])\n dhid, grads['W{0}'.format(i)], grads['b{0}'.format(i)] = \\\n affine_backward(dhid, cache[i]['affine']) \n grads['W{0}'.format(i)] += self.reg * self.params['W{0}'.format(i)]\n\n return grads, loss","def backward_pass(self, delta):\n\n a = config['learning_rate']\n y = config['momentum_gamma']\n m = config['momentum']\n l = config['L2_penalty']\n\n # print(\"shape of delta incoming: \", delta.shape, \"shape of x: \", self.x.shape)\n self.d_x = delta.T @ self.x\n # print(\"SHAPE OF GRADIENT: \", self.d_x.shape)\n\n # gradient momentum\n self.w_inc = (a * self.d_x.T) + (y * self.d_v) - l * self.w\n \n # saving \n if m:\n self.d_v = self.w_inc\n else:\n self.d_v = np.zeros(self.w.shape)\n\n # backprop for bias weights\n x_0 = np.ones([len(delta), 1])\n\n self.d_b = delta.T @ x_0\n\n # print(\"shape of BIAS GRAD: \", self.d_b.shape)\n\n self.d_w = delta @ self.w.T\n # print(\"shape of w.T: \", self.w.T.shape, \"shape of RETURN delta: \", self.d_w.shape)\n #print(self.w.shape)\n return self.d_w","def on_iter_backward(self, runner):\n runner.optimizer.zero_grad()\n runner.loss.backward()\n runner.optimizer.step()","def _AffBatchReluDrop_Backprop(self, dscores, cache):\n grads = {}\n loss = None\n #Last Softmax Layer\n ##Add L2 Regularization loss\n loss = 0.5 * self.reg * np.sum(self.params['W{0}'.format(self.num_layers)]**2)\n ##Calculate grads for last Affine\n dhid, grads['W{0}'.format(self.num_layers)], grads['b{0}'.format(self.num_layers)] =\\\n affine_backward(dscores, cache[-1])\n grads['W{0}'.format(self.num_layers)] += self.reg * self.params['W{0}'.format(self.num_layers)]\n\n for i in range(self.num_layers-1, 0, -1): #hidden layers\n ##L2 Reg. loss\n loss += 0.5 * self.reg * np.sum(self.params['W{0}'.format(i)]**2)\n ##Calculate grads for [{affine-Batchnorm-relu-drop} X (L-1)]\n dhid = dropout_backward(dhid, cache[i]['drop'])\n dhid = relu_backward(dhid, cache[i]['relu'])\n dhid, grads['gamma{0}'.format(i)], grads['beta{0}'.format(i)] = \\\n batchnorm_backward_alt(dhid, cache[i]['batchnorm'])\n dhid, grads['W{0}'.format(i)], grads['b{0}'.format(i)] = \\\n affine_backward(dhid, cache[i]['affine']) \n grads['W{0}'.format(i)] += self.reg * self.params['W{0}'.format(i)]\n\n return grads, loss","def linear_backward(dZ, cache):\n pass","def relu_backward(dA, Z):\n\n dZ = np.array(dA, copy=True) # just converting dz to a correct object.\n\n # When z <= 0, you should set dz to 0 as well.\n dZ[Z <= 0] = 0\n\n assert (dZ.shape == Z.shape)\n\n return dZ","def update_relus(self):\n def relu_backward_hook_function(module, grad_in, grad_out):\n \"\"\"\n If there is a negative gradient, change it to zero\n \"\"\"\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)\n\n def relu_forward_hook_function(module, ten_in, ten_out):\n \"\"\"\n Store results of forward pass\n \"\"\"\n self.forward_relu_outputs.append(ten_out)\n\n # Loop through layers, hook up ReLUs\n for pos, module in self.model.features._modules.items():\n if isinstance(module, ReLU):\n module.register_backward_hook(relu_backward_hook_function)\n module.register_forward_hook(relu_forward_hook_function)","def unrolled_backward(self, trn_X, trn_y, val_X, val_y, lr, w_optim, amended: bool = False):\n # do virtual step (calc w`)\n self.virtual_step(trn_X, trn_y, lr, w_optim)\n\n # calc unrolled loss\n normal_alphas, reduce_alphas = self.v_net.alpha_weights()\n loss = self.v_net.loss(val_X, val_y) # L_val(w`)\n\n # Loss += SUM[ none - mean(others) ]\n loss += self.normal_none_penalty * sum([(alpha[:, -1] - alpha[:, :-1].mean()).sum() for alpha in normal_alphas])\n loss += self.reduce_none_penalty * sum([(alpha[:, -1] - alpha[:, :-1].mean()).sum() for alpha in reduce_alphas])\n\n # compute gradient\n v_alphas = tuple(self.v_net.alphas())\n v_weights = tuple(self.v_net.weights())\n v_grads = torch.autograd.grad(loss, v_alphas + v_weights)\n dalpha = v_grads[:len(v_alphas)]\n dw = v_grads[len(v_alphas):]\n\n hessian = self.amended_gradient(dw, trn_X, trn_y) if amended else self.compute_hessian(dw, trn_X, trn_y)\n\n # update final gradient = dalpha - lr*hessian\n with torch.no_grad():\n for alpha, da, h in zip(self.net.alphas(), dalpha, hessian):\n alpha.grad = da - lr * h","def backward(self, grad_z):\n\t\t#######################################################################\n\t\t# ** START OF YOUR CODE **\n\t\t#######################################################################\n\n\t\tgradient = self._layers[-1].backward(grad_z)\n\t\tfor i in range(len(self._layers) - 2, -1, -1):\n\t\t\tgradient = self._layers[i].backward(gradient)\n\t\treturn gradient\n\n\t\t#######################################################################\n\t\t# ** END OF YOUR CODE **\n\t\t#######################################################################","def backward(self, upstream_grad):\n # couple upstream gradient with local gradient, the result will be sent back to the Linear layer\n self.dZ = upstream_grad * self.A*(1-self.A)","def L_model_backward(AL, Y, caches, X):\n grads = {}\n L = len(caches) # the number of layers\n m = AL.shape[1]\n Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL\n \n # Initializing the backpropagation \n dZ = AL - Y # Derivative of Cross Entropy Loss with Softmax\n \n # Lth layer (SOFTMAX -> LINEAR) gradients. Inputs: \"AL, Y, caches\". Outputs: \"grads[\"dAL\"], grads[\"dWL\"], grads[\"dbL\"]\n current_cache = caches[L-1]\n grads[\"dA\" + str(L)], grads[\"dW\" + str(L)], grads[\"db\" + str(L)] = linear_activation_backward(dZ, AL, current_cache, activation = \"softmax\")\n \n for l in reversed(range(L-1)):\n # lth layer: (RELU -> LINEAR) gradients.\n current_cache = caches[l]\n dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads[\"dA\" + str(l + 2)], AL, current_cache, activation = \"relu\")\n grads[\"dA\" + str(l + 1)] = dA_prev_temp\n grads[\"dW\" + str(l + 1)] = dW_temp\n grads[\"db\" + str(l + 1)] = db_temp\n\n return grads","def backward(self):\n gradient = blah\n return gradient","def backward(self):\n gradient = blah\n return gradient","def backward_step(activations, targets, layers):\n param_grads = collections.deque() # List of parameter gradients for each layer\n output_grad = None # The error gradient at the output of the current layer\n # Propagate the error backwards through all the layers.\n # Use reversed to iterate backwards over the list of layers.\n for i, layer in enumerate(reversed(layers)):\n cur_layer_idx = len(layers) - i - 1\n if cur_layer_idx <= NUM_LAYERS_SKIP:\n # implement short circuit here\n if layer.is_fc_layer:\n grads = [0.0 for _ in range(layer.W.shape[0]*layer.W.shape[1]+layer.W.shape[1])]\n else:\n # normal gradient computation \n Y = activations.pop() # Get the activations of the last layer on the stack\n # Compute the error at the output layer.\n # The output layer error is calculated different then hidden layer error.\n if output_grad is None:\n input_grad = layer.get_input_grad(Y, targets)\n else: # output_grad is not None (layer is not output layer)\n input_grad = layer.get_input_grad(Y, output_grad)\n # Get the input of this layer (activations of the previous layer)\n X = activations[-1]\n # Compute the layer parameter gradients used to update the parameters\n grads = layer.get_params_grad(X, output_grad)\n param_grads.appendleft(grads)\n # Compute gradient at output of previous layer (input of current layer):\n output_grad = input_grad\n return list(param_grads) # Return the parameter gradients","def affine_batchnorm_relu_backward(dout, cache):\n fc_cache, norm_cache, relu_cache = cache\n d_norm_out = relu_backward(dout, relu_cache)\n d_affine_out, dgamma, dbeta = batchnorm_backward_alt(d_norm_out, norm_cache)\n dx, dw, db = affine_backward(d_affine_out, fc_cache)\n return dx, dw, db, dgamma, dbeta","def backward(self, delta):\n if self.activation_type == \"sigmoid\":\n grad = self.grad_sigmoid()\n\n elif self.activation_type == \"tanh\":\n grad = self.grad_tanh()\n\n elif self.activation_type == \"ReLU\":\n grad = self.grad_ReLU()\n\n return grad * delta","def backward_step(activations, targets, layers):\n param_grads = collections.deque() # List of parameter gradients for each layer\n output_grad = None # The error gradient at the output of the current layer\n # Propagate the error backwards through all the layers.\n # Use reversed to iterate backwards over the list of layers.\n for layer in reversed(layers): \n Y = activations.pop() # Get the activations of the last layer on the stack\n # Compute the error at the output layer.\n # The output layer error is calculated different then hidden layer error.\n if output_grad is None:\n input_grad = layer.get_input_grad(Y, targets)\n else: # output_grad is not None (layer is not output layer)\n input_grad = layer.get_input_grad(Y, output_grad)\n # Get the input of this layer (activations of the previous layer)\n X = activations[-1]\n # Compute the layer parameter gradients used to update the parameters\n grads = layer.get_params_grad(X, output_grad)\n param_grads.appendleft(grads)\n # Compute gradient at output of previous layer (input of current layer):\n output_grad = input_grad\n return list(param_grads) # Return the parameter gradients","def update_relus(self):\n def relu_backward_hook_function(module, grad_in, grad_out):\n \"\"\"\n If there is a negative gradient, change it to zero\n \"\"\"\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)\n\n def relu_forward_hook_function(module, ten_in, ten_out):\n \"\"\"\n Store results of forward pass\n \"\"\"\n self.forward_relu_outputs.append(ten_out)\n\n # Loop through layers, hook up ReLUs\n for pos, module in self.model.named_modules():\n if isinstance(module, ReLU):\n module.register_backward_hook(relu_backward_hook_function)\n module.register_forward_hook(relu_forward_hook_function)","def update_relus(self):\n def relu_backward_hook_function(module, grad_in, grad_out):\n \"\"\"\n If there is a negative gradient, change it to zero\n \"\"\"\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)\n\n def relu_forward_hook_function(module, ten_in, ten_out):\n \"\"\"\n Store results of forward pass\n \"\"\"\n self.forward_relu_outputs.append(ten_out)\n\n # Loop through layers, hook up ReLUs\n for pos, module in self.model.named_modules():\n if isinstance(module, nn.ReLU):\n module.register_backward_hook(relu_backward_hook_function)\n module.register_forward_hook(relu_forward_hook_function)","def backward(self, out_grad, input):\n raise NotImplementedError","def affine_layernorm_relu_backward(dout, cache):\n fc_cache, norm_cache, relu_cache = cache\n d_norm_out = relu_backward(dout, relu_cache)\n d_affine_out, dgamma, dbeta = layernorm_backward(d_norm_out, norm_cache)\n dx, dw, db = affine_backward(d_affine_out, fc_cache)\n return dx, dw, db, dgamma, dbeta","def rnn_backward(dh, cache):\n dx, dh_prev, dWx, dWh, db = None, None, None, None, None\n ##############################################################################\n # TODO: Implement the backward pass for a vanilla RNN running an entire #\n # sequence of data. You should use the rnn_step_backward function that you #\n # defined above. #\n ##############################################################################\n \"\"\"\n x, next_h, prev_h, Wx, Wh, b = cache\n dz = (1-next_h*next_h)*dnext_h\n # THIS ERROR IS SPREAD AMONG THE\n # np.dot(x, Wx) + np.dot(prev_h, Wh) + b)\n dx = np.dot(dz,Wx.T)\n dprev_h = np.dot(dz,Wh.T)\n db = np.sum(dz,axis=0)\n dWx = np.dot(x.T,dz)\n dWh = np.dot(prev_h.T,dz)\n #d(tanh) = 1- tanh*tanh\n \"\"\"\n #pdb.set_trace()\n # dh is not result of forward prop\n # but\n N,T,H = dh.shape\n tmp_x, tmp_next_h, tmp_prev_h, tmp_Wx, tmp_Wh, tmp_b = cache[T-1]\n D = tmp_x.shape[1]\n\n\n dx = np.zeros((N,T,D))\n dh_prev = np.zeros((N,H))\n dWx = np.zeros((D,H))\n dWh = np.zeros((H,H))\n db = np.zeros((H))\n\n for i in reversed(list(range(0,T))):\n # current gradient at timestep is the upstream gradient (provided as input)\n # this may be coming from the Y as in the min_char_rnn.py (see line 59)\n # + downstream gradient provided by rnn_step_backward.\n dh_curr = dh[:,i,:] + dh_prev\n dx_, dh_prev, dWx_, dWh_, db_ = rnn_step_backward(dh_curr, cache[i])\n dWx += dWx_\n dWh += dWh_\n db += db_\n dx[:,i,:]=dx_\n\n\n ##############################################################################\n # END OF YOUR CODE #\n ##############################################################################\n return dx, dh_prev, dWx, dWh, db","def backward(ctx, grad_output):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n # Retrieve saved tensors and constants\n gamma, ivar, mean, input = ctx.saved_tensors\n eps = ctx.saved_tensors\n\n # Check which inputs need gradients\n input_needs_grad, gamma_needs_grad, beta_needs_grad = ctx.needs_input_grad\n\n # Get the batch size (=N)\n N, _ = grad_output.shape\n\n # reconstruct the input_norm\n input_norm = (input - mean) * ivar\n grand_input_norm = grad_output * gamma\n\n ##### Gradient wrt beta #####\n grad_beta = grad_output.sum(dim=0) if beta_needs_grad else None\n\n #### Gradient wrt gamma ####\n grad_gamma = (input_norm*grad_output).sum(dim=0) if gamma_needs_grad else None\n \n #### Gradient wrt input ####\n term1 = N*grand_input_norm \n term2 = torch.sum(grand_input_norm, dim=0)\n term3 = input_norm*torch.sum(grand_input_norm*input_norm, dim=0)\n grad_input = (1. / N) * ivar * (term1 - term2 - term3) if input_needs_grad else None\n\n ########################\n # END OF YOUR CODE #\n #######################\n\n # return gradients of the three tensor inputs and None for the constant eps\n return grad_input, grad_gamma, grad_beta, None","def affine_batchnorm_relu_backward(dout, cache):\n af_cache, bf_cache, relu_cache = cache\n \n dbf_out = relu_backward(dout, relu_cache)\n daf_out, dgamma, dbeta = batchnorm_backward(dbf_out, bf_cache)\n dx, dw, db = affine_backward(daf_out, af_cache)\n return dx, dw, db, dgamma, dbeta","def backward_pass(architecture,gradient_layerwise,grad_weights,grad_bias):\n \n for layer in range(len(architecture)-1,-1,-1):\n X_input,X_output,weightsi,biasi,X_input_im2col,imi,output_shapei,kernel_shapei,stridei,operationi,imxi = architecture['layer{}'.format(layer+1)]\n# print(\"Operation is:{} and Layer is: {}\".format(operationi,layer+1))\n if operationi == 'softmax': # Last layer -> Dont apply softmax in any layer other than the last layer!\n # not taking gradients here because we need dz_dX(secondlastlayer) which is y_pred - y\n continue\n \n if operationi == 'conv_bn_relu' or operationi == 'conv_relu' or operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\n if operationi__1 == 'softmax':\n y_pred = architecture['layer{}'.format(layer+2)][1]\n y_pred = torch.reshape(y_pred,y.shape)\n dz_dXi = y_pred - y\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\n X_output = torch.reshape(X_output,dz_dXi.shape)\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n elif 'relu' in operationi:\n dz_dXi[X_output <= 0] = 0\n else:\n None\n \n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # .\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # .\n try:\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input_im2col)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\n except:\n dz_dweightsi = (dz_dXi).mm(X_input_im2col)\n \n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi #\n elif operationi__1 == 'maxpool': # need to do something here to fix the problem\n None\n\n elif 'flatten' in operationi__1:\n # we currently have dz_doutput of flatten -> we want dz_doutput of the conv_bn_relu before flatten\n \n weightsi__1 = architecture['layer{}'.format(layer+2)][2] # weights2\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput of flatten\n if len(dz_dXi__1.shape) == 3:\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\n imi__1 = architecture['layer{}'.format(layer+2)][5] # i\n try:\n dz_dXi = torch.t(weightsi__1).mm(dz_dXi__1)\n except:\n dz_dXi = weightsi__1.mm(dz_dXi__1)\n X_output = torch.reshape(X_output,dz_dXi.shape)\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n elif 'relu' in operationi:\n dz_dXi[X_output <= 0] = 0\n else:\n None\n\n dz_dXi = torch.reshape(dz_dXi,(output_shapei[1]*output_shapei[2],-1))\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\n dz_dweightsi = X_input_im2col.mm(dz_dXi)\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\n dz_dbi = dz_dXi\n \n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)# Can also set this to layer like in line ~800\n \n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi) # Can also set this to layer like in line ~800\n \n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi) # Can also set this to layer like in line ~800\n \n else:\n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dX2 -> backpropagated from maxpool\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\n if len(dz_dXi__1.shape) == 3:\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\n imi__1 = architecture['layer{}'.format(layer+2)][5]\n try:\n Y = weightsi__1.mm(dz_dXi__1)\n except:\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\n dz_dXi = torch.zeros(X_output.shape)\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\n for i in range(np.shape(X_output)[0]):\n for j in range(np.shape(X_output)[1]):\n for k in range(np.shape(X_output)[2]):\n idxs = getIndexes(imi__1,(i,j,k))\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\n \n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\n if 'sigmoid' in operationi__1: # ...\n X_output = torch.reshape(X_output,dz_dXi.shape)\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n elif 'relu' in operationi__1: # ...\n dz_dXi[X_output <= 0] = 0\n else:\n None\n \n dz_dXi = torch.reshape(dz_dXi,(output_shape_current_layer[1]*output_shape_current_layer[2],-1))\n dz_dbi = torch.reshape(dz_dXi,bias_current_layer.shape)\n dz_dweightsi = X_im2col_current_layer.mm(dz_dXi)\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\n \n if operationi == 'maxpool':\n \n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput -> backpropagated from maxpool\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\n \n if len(dz_dXi__1.shape) == 3:\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\n imi__1 = architecture['layer{}'.format(layer+2)][5]\n try:\n Y = weightsi__1.mm(dz_dXi__1)\n except:\n try:\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\n except:\n Y = torch.t(weightsi__1).mm(dz_dXi__1) # Ensuring valid matrix multiplication here\n \n dz_dXi = torch.zeros(X_output.shape)\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\n for i in range(np.shape(X_output)[0]):\n for j in range(np.shape(X_output)[1]):\n for k in range(np.shape(X_output)[2]):\n idxs = getIndexes(imi__1,(i,j,k))\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\n\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\n \n if operationi__1 == 'conv_sigmoid' or operationi__1 == 'conv_bn_sigmoid': # ...\n X_output = torch.reshape(X_output,dz_dXi.shape)\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n else:\n dz_dXi[X_output <= 0] = 0\n\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\n \n dz_dXinput = torch.zeros((X_input.shape))\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+1)][0] # output = output of maxpool\n\n dz_dXoutput = torch.reshape(dz_dXoutput,(output_shapei[0],X_input_im2col.shape[2]))\n \n for i in range(output_shapei[0]):\n for j in range(X_input_im2col.shape[2]):\n Xi2ci = X_im2col_current_layer[i,:,:]\n idx = torch.argmax(Xi2ci[:,j]).item()\n value = imxi[i][(idx,j)]\n dz_dXinput[value[0],value[1],value[2]] += float(dz_dXoutput[i,j])\n\n# dz_dXinput = torch.reshape(dz_dXinput,output_shapei)\n \n X_prev_im2col = architecture['layer{}'.format(layer)][4]\n X_output_prev = architecture['layer{}'.format(layer)][1]\n X_output_prev = torch.reshape(X_output_prev,dz_dXinput.shape)\n X_input_prev = architecture['layer{}'.format(layer)][0]\n prev_bias = architecture['layer{}'.format(layer)][3]\n output_shape_prev = architecture['layer{}'.format(layer)][6]\n prev_operation = architecture['layer{}'.format(layer)][9]\n \n if prev_operation == 'conv_sigmoid' or prev_operation == 'conv_bn_sigmoid':\n dz_dXinput *= sigmoid(X_output_prev)*(1-sigmoid(X_output_prev)) # Taking the derivative of the sigmoid function\n else:\n dz_dXinput[X_output_prev <= 0] = 0\n \n if len(dz_dXinput.shape) == 3:\n dz_dXinput = torch.reshape(dz_dXinput,(-1,output_shape_prev[0]))\n \n dz_dbi = torch.reshape(dz_dXinput,prev_bias.shape)\n dz_dweightsi = X_prev_im2col.mm(dz_dXinput)\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0\n \n gradient_layerwise['layer{}'.format(layer)][2] = torch.Tensor(dz_dbi)\n gradient_layerwise['layer{}'.format(layer)][1] = torch.Tensor(dz_dweightsi)\n gradient_layerwise['layer{}'.format(layer)][0] = torch.Tensor(dz_dXinput) # ...\n \n if 'flatten_dense' in operationi:\n \n operationi__1 = architecture['layer{}'.format(layer+2)][9]\n \n if operationi__1 == 'softmax':\n \n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\n X_output = torch.reshape(X_output,(-1,1))\n y_pred = architecture['layer{}'.format(layer+2)][1]\n y_pred = torch.reshape(y_pred,y.shape)\n dz_dXi = y_pred - y\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\n X_output = torch.reshape(X_output,dz_dXi.shape)\n if 'sigmoid' in operationi:\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\n elif 'relu' in operationi:\n dz_dXi[X_output <= 0] = 0\n else:\n None\n \n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\n try:\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\n except:\n dz_dweightsi = (dz_dXi).mm(X_input)\n \n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\n dz_dweightsi[dz_dweightsi < -clip] = 0\n \n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # Can also set this to layer like in line ~800\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi # Can also set this to layer like in line ~800\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # Can also set this to layer like in line ~800\n \n else:\n # Have to modify and test this before implementation -> Specifically\n # the backprop implementation is not consistent with the ones above\n #\n X_output = torch.reshape(X_output,(-1,1))\n weights__i = architecture['layer{}'.format(layer+2)][2]\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+2)][0]\n dz_dXoutput = torch.reshape(torch.Tensor(dz_dXoutput),X_output.shape)\n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\n\n if 'relu' in operationi:\n dz_dXoutput[X_output<0] = 0\n try:\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\n except:\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\n try:\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\n except:\n dz_dweightsi = dz_dXoutput.mm(X_input)\n dz_dbi = dz_dXoutput\n if 'sigmoid' in operationi:\n dz_dXoutput*= sigmoid(X_output)*(1-sigmoid(X_output))\n try:\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\n except:\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\n try:\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\n except:\n dz_dweightsi = dz_dXoutput.mm(X_input)\n dz_dbi = dz_dXoutput\n else:\n try:\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\n except:\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\n try:\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\n except:\n dz_dweightsi = dz_dXoutput.mm(X_input)\n dz_dbi = dz_dXoutput\n \n unflattened_Xinput = architecture['layer{}'.format(layer+1)][0]\n dz_dXinput = torch.reshape(dz_dXinput,unflattened_Xinput.shape)\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXinput)\n \n if gradient_layerwise['layer{}'.format(layer+1)][1] is not None:\n try:\n grad_weights['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][1]\n except:\n grad_weights['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][1])\n if gradient_layerwise['layer{}'.format(layer+1)][2] is not None:\n try:\n grad_bias['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][2]\n except:\n grad_bias['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][2])\n \n gc.collect()\n return","def backward(self, grad_z):\n\t\t#######################################################################\n\t\t# ** START OF YOUR CODE **\n\t\t#######################################################################\n\n\t\tself._grad_W_current = self._cache_current.T @ grad_z\n\t\tself._grad_b_current = np.ones((1,self._cache_current.shape[0])) @ grad_z\n\n\t\treturn grad_z @ self._W.T\n\n\t\t#######################################################################\n\t\t# ** END OF YOUR CODE **\n\t\t#######################################################################","def backward(self, gradient: Tensor) -> Tensor:\n self.b_grad = np.sum(gradient, axis=0)\n self.w_grad = self.inputs.T @ gradient\n return gradient @ self.w.T","def _AffReluDrop_Backprop(self, dscores, cache):\n grads = {}\n loss = None\n #Last Softmax Layer\n ##Add L2 Regularization loss\n loss = 0.5 * self.reg * np.sum(self.params['W{0}'.format(self.num_layers)]**2)\n ##Calculate grads for last Affine\n dhid, grads['W{0}'.format(self.num_layers)], grads['b{0}'.format(self.num_layers)] =\\\n affine_backward(dscores, cache[-1])\n grads['W{0}'.format(self.num_layers)] += self.reg * self.params['W{0}'.format(self.num_layers)]\n\n for i in range(self.num_layers-1, 0, -1): #hidden layers\n thiscache = cache[i]\n ##L2 Reg. loss\n loss += 0.5 * self.reg * np.sum(self.params['W{0}'.format(i)]**2)\n ##Calculate grads for [{affine-relu-drop} X (L-1)]\n dhid = dropout_backward(dhid, thiscache['drop'])\n dhid, grads['W{0}'.format(i)], grads['b{0}'.format(i)] = \\\n affine_relu_backward(dhid, thiscache['affine_relu']) \n grads['W{0}'.format(i)] += self.reg * self.params['W{0}'.format(i)]\n\n return grads, loss","def backwardpass(self, grad):\n return (self.x>0) * grad","def compute_backsubstitution(self, length: int, dim: int, layer_gradient_manager=None):\n if self.args.cpu:\n self.lb = torch.zeros(length, dim)\n else:\n self.lb = torch.zeros(length, dim).cuda()\n self.ub = self.lb.clone()\n self.final_lw = self.final_uw = None\n self.final_lb = self.final_ub = None\n\n original_layers = self.layers[:] # We keep a copy, because layers might get modified during the backsubstitution with jacobian\n for layer in self.layers[::-1]:\n if layer.lw is not None:\n layer.backward(layer_gradient_manager)\n # print(\"Controller has grad: \", self.lb.requires_grad)\n self.layers = original_layers # We restore the original layers","def update_relus(self):\n def relu_backward_hook_function(module, grad_in, grad_out):\n \"\"\"\n If there is a negative gradient, change it to zero\n \"\"\"\n # Get last forward output\n corresponding_forward_output = self.forward_relu_outputs[-1]\n corresponding_forward_output[corresponding_forward_output > 0] = 1\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\n del self.forward_relu_outputs[-1] # Remove last forward output\n return (modified_grad_out,)\n\n def relu_forward_hook_function(module, ten_in, ten_out):\n \"\"\"\n Store results of forward pass\n \"\"\"\n self.forward_relu_outputs.append(ten_out)\n\n # Loop through layers, hook up ReLUs\n for pos, module in self.model.encoder._modules.items():\n if isinstance(module, ReLU):\n module.register_backward_hook(relu_backward_hook_function)\n module.register_forward_hook(relu_forward_hook_function)","def relu_backward(dA, Z):\r\n dZ = np.array(dA, copy=True)\r\n dZ[Z <= 0] = 0\r\n return dZ","def backward(self, residuals):\n in_channel, out_channel, kernel_size, a = self.weights.shape\n dw = np.zeros_like(self.weights) \n \n for i in range(in_channel):\n for o in range(out_channel):\n dw[i, o] += inv_conv2(self.in_val[:,:,i], \n residuals[:,:,o], \n self.stride)\n\n self.db += residuals.sum(axis=1).sum(axis=0)\n self.dw += dw \n gradient_x = np.zeros_like(self.in_val)\n \n for i in range(in_channel):\n for o in range(out_channel):\n gradient_x[:,:,i] += conv_delta(residuals[:,:,o] \n , self.weights[i][o]\n , self.stride\n , self.in_val.shape[0])\n \n return gradient_x","def L_model_backward(AL, Y, caches):\n grads = {}\n dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))\n L = len(caches)\n cache = caches[L-1]\n dA, dW, db = linear_activation_backward(dAL, cache, 'sigmoid')\n grads['dA'+str(L)] = dAL\n grads['dW'+str(L)] = dW\n grads['db'+str(L)] = db\n for i in range(L-2, -1, -1):\n grads['dA' + str(i + 1)] = dA\n cache = caches[i]\n dA, dW, db = linear_activation_backward(dA, cache, 'relu')\n grads['dW' + str(i + 1)] = dW\n grads['db' + str(i + 1)] = db\n return grads","def backward(self, inGradient, lr=0.001): # batchSize = 1\n wGradient = np.dot(inGradient.T, self.data)\n bGradient = np.sum(inGradient, axis=0)\n outGradient = np.dot(inGradient, self.weights)\n\n self.weights = self.weights - lr * wGradient\n self.bias = self.bias - lr * bGradient\n self.wGradient = wGradient\n self.bGradient = bGradient\n\n #print \"weight gradient \", wGradient\n #print \"bias gradient \", bGradient\n\n return outGradient","def relu_backward(dA, cache):\n\n Z = cache\n dZ = np.array(dA, copy=True) # just converting dz to a correct object.\n\n # When z <= 0, you should set dz to 0 as well.\n dZ[Z <= 0] = 0\n\n assert (dZ.shape == Z.shape)\n\n return dZ","def backward(self, accum_grad):\n\n W = self.W\n\n grad_w = self.layer_input.T.dot(accum_grad)\n grad_b = np.sum(accum_grad, axis=0, keepdims=True)\n\n # Update the layer weights\n self.W = self.W_optimizer.update(self.W, grad_w)\n self.b = self.b_optimizer.update(self.b, grad_b)\n\n accum_grad = accum_grad.dot(W.T)\n return accum_grad","def backward_linear(Data):\n\n # data\n graph = tf.Graph()\n X = Data[0]\n Y_ = Data[1]\n\n if X.shape[0] != Y_.shape[0]:\n raise Exception(\"The quantity of Input X and Compare Y_ are not same!\")\n\n Loss = []\n with graph.as_default():\n print(\"This is the process of all the Dose!\")\n print(\"There are %d data in this process.\" % X.shape[0])\n print(\"Features of X: %d\" % X.shape[1])\n print(\"Learning rate is: %f\" % learning_rate)\n # Init all the parameters\n global_step = tf.Variable(0, trainable=False)\n\n STEPS = int(Epoch * X.shape[0] / BATCH_SIZE) + 1\n epoch = 0\n\n with tf.name_scope('inputs'):\n x = tf.placeholder(tf.float32, [None, Forward.INPUT_NODE], name='x_Input')\n y_ = tf.placeholder(tf.float32, [None, Forward.OUTPUT_NODE], name='y_Exact')\n y = Forward.forward_linear(x, regularizer=None)\n\n # lost function\n with tf.name_scope('loss'):\n loss_mse = tf.reduce_mean(tf.square(y - y_))\n loss = loss_mse + tf.add_n(tf.get_collection(\"losses\"))\n tf.summary.scalar('loss', loss)\n\n # Todo\n # LM algorithm\n\n # learning_rate = tf.train.exponential_decay(\n # LEARNING_RATE_BASE,\n # global_step,\n # X.shape[0] / BATCH_SIZE,\n # LEARNING_RATE_DECAY,\n # staircase=True\n # )\n\n with tf.name_scope('train'):\n # train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step)\n # train_step = tf.train.MomentumOptimizer(learning_rate, momentum=0.9).minimize(loss, global_step)\n train_step = tf.train.AdamOptimizer(learning_rate, beta1=0.9, beta2=0.99).minimize(loss, global_step)\n\n # EMA algorithm\n ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)\n ema_op = ema.apply(tf.trainable_variables())\n with tf.control_dependencies([train_step, ema_op]):\n train_op = tf.no_op(name='train')\n\n # ready for storing the model\n saver = tf.train.Saver()\n\n with tf.Session() as sess:\n init_op = tf.global_variables_initializer()\n sess.run(init_op)\n\n # Get the check point\n ckpt = tf.train.get_checkpoint_state(MODEL_SAVE_PATH_LINEAR)\n if ckpt and ckpt.model_checkpoint_path:\n saver.restore(sess, ckpt.model_checkpoint_path)\n\n # begin multi threads\n coord = tf.train.Coordinator()\n threads = tf.train.start_queue_runners(sess, coord)\n print(\"Begin the multi threads!\")\n\n # Graph\n merged = tf.summary.merge_all()\n writer = tf.summary.FileWriter(\"./logs_linear/\", sess.graph)\n\n # Training\n for i in range(STEPS):\n start = (i * BATCH_SIZE) % int(X.shape[0])\n end = start + BATCH_SIZE\n # if finish all the data\n if end >= X.shape[0]:\n end = X.shape[0]\n\n _, loss_value, step = sess.run([train_op, loss, global_step],\n feed_dict={x: X[start:end], y_: Y_[start:end]})\n\n if i % 4000 == 0:\n print(\"Steps are: %d , loss is: %g.\" % (step, loss_value))\n rs = sess.run(merged, feed_dict={x: X[start:end], y_: Y_[start:end]})\n writer.add_summary(rs, i)\n saver.save(sess, os.path.join(MODEL_SAVE_PATH_LINEAR, MODEL_NAME), global_step)\n\n # a round\n if end == X.shape[0]:\n # get the results\n epoch += 1\n loss_total = sess.run(loss, feed_dict={x: X, y_: Y_})\n\n Loss.append(loss_total)\n # Loss.append(loss_total*10000)\n print(\"After %d epoch(s), steps are: %d, loss total is: %g.\\n\" % (epoch, step, loss_total))\n saver.save(sess, os.path.join(MODEL_SAVE_PATH_LINEAR, MODEL_NAME), global_step)\n\n # close the multi threads\n coord.request_stop()\n coord.join(threads)\n print(\"Close the multi threads!\")\n\n return Loss","def _backward(self):\n if self.units[0].value > 0:\n self.units[0].gradient += 1 * self.utop.gradient\n else:\n self.units[0].gradient += 0 * self.utop.gradient","def backward(last_layer: str) -> Callable:\n\n def closure() -> Tuple[Optional[torch.Tensor], torch.Tensor]:\n optimizer.zero_grad()\n output = model(data)\n if last_layer == \"output\":\n output.backward(torch.ones_like(target))\n return None, output\n elif last_layer == 'loss':\n loss = compute_loss(output - target)\n loss.backward()\n return loss, output\n else:\n assert False, 'last layer must be \"output\" or \"loss\"'\n\n return closure","def backward(last_layer: str) -> Callable:\n\n def closure() -> Tuple[Optional[torch.Tensor], torch.Tensor]:\n optimizer.zero_grad()\n output = model(data)\n if last_layer == \"output\":\n output.backward(torch.ones_like(target))\n return None, output\n elif last_layer == 'loss':\n loss = compute_loss(output - target)\n loss.backward()\n return loss, output\n else:\n assert False, 'last layer must be \"output\" or \"loss\"'\n\n return closure","def _backward(self, w=None):\n grad = self.w # Should be I * self.w . We keep a vector for simplicity\n\n # Left multiply input `w` with normalizer gradient\n return w * grad if w is not None else grad","def lstm_backward(dh, cache):\n dx, dh_prev, dWx, dWh, db = None, None, None, None, None\n #############################################################################\n # TODO: Implement the backward pass for an LSTM over an entire timeseries. #\n # You should use the lstm_step_backward function that you just defined. #\n #############################################################################\n\n N,T,H = dh.shape\n tmp_x = cache[T-1][0]\n D = tmp_x.shape[1]\n # cache is a list of these values -- so cache[0] is\n # x, i, f, o, g, prev_h, next_h, prev_c, next_c, Wx, Wh, b = cache\n dnext_h = dh\n\n dx = np.zeros((N,T,D))\n dh_prev = np.zeros((N,H))\n dc_prev = np.zeros((N,H))\n dWx = np.zeros((D,4*H))\n dWh = np.zeros((H,4*H))\n db = np.zeros((4*H))\n\n for t in reversed(range(0,T)):\n # current gradient at timestep is the upstream gradient (provided as input)\n # this may be coming from the Y as in the min_char_rnn.py (see line 59)\n # + downstream gradient provided by rnn_step_backward.\n dh_curr = dh[:,t,:] + dh_prev\n dx_, dh_prev, dc_prev, dWx_, dWh_, db_ = lstm_step_backward(dh_curr, dc_prev, cache[t])\n dWx += dWx_\n dWh += dWh_\n db += db_\n dx[:,t,:]=dx_\n\n ##############################################################################\n # END OF YOUR CODE #\n ##############################################################################\n\n return dx, dh_prev, dWx, dWh, db"],"string":"[\n \"def backward(ctx, grad_output):\\n loss, reg, u, lbda = ctx.saved_tensors\\n\\n device = u.device\\n\\n # do clever computations\\n eps = 1e-10\\n grad, = torch.autograd.grad(loss, u, only_inputs=True,\\n retain_graph=True)\\n x = (u - eps * grad).data\\n lbda = lbda.data\\n\\n prox_x = check_tensor(\\n np.array([prox_tv.tv1_1d(xx, eps * lbda) for xx in x]),\\n device=device,\\n )\\n grad_u = (u - prox_x) / eps\\n grad_lbda = reg.clone()\\n return (torch.ones(0), grad_u, grad_lbda)\",\n \"def conv_relu_backward(dout, cache):\\n conv_cache, relu_cache = cache\\n da = layers.relu_backward(dout, relu_cache)\\n dx, dw, db = layers.conv_backward_fast(da, conv_cache)\\n return dx, dw, db\",\n \"def conv_relu_backward(dout, cache):\\n conv_cache, relu_cache = cache\\n da = relu_backward(dout, relu_cache)\\n dx, dw, db = conv_backward_fast(da, conv_cache)\\n return dx, dw, db\",\n \"def conv_relu_backward(dout, cache):\\n conv_cache, relu_cache = cache\\n da = relu_backward(dout, relu_cache)\\n dx, dw, db = conv_backward_fast(da, conv_cache)\\n return dx, dw, db\",\n \"def backward_deconvnet_relu(x):\\n def grad(dy):\\n return tf.nn.relu(dy)\\n return tf.nn.relu(x), grad\",\n \"def relu_backward(dout, cache):\\n dx, x = None, cache\\n ###########################################################################\\n # TODO: Implement the ReLU backward pass. #\\n ###########################################################################\\n # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\\n dx = np.where(x<=0, 0, 1) * dout\\n \\n\\n pass\\n\\n # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n return dx\",\n \"def backward_pass(self, loss):\\n\\n self.optimizer.zero_grad()\\n self.optimizer.backward(loss)\\n self.optimizer.step()\",\n \"def backward_D(self):\\n self.loss_D.backward()\",\n \"def backward(ctx, grad_L):\\n A, T = ctx.saved_tensors\\n\\n grad_A = None\\n grad_T = None\\n\\n B = A.shape[0]\\n\\n # We only need to compute gradients for tensors that are flagged to\\n # require gradients!\\n if ctx.needs_input_grad[0]:\\n grad_A = (A - T) / B\\n\\n if ctx.needs_input_grad[1]:\\n grad_T = (T - A) / B\\n\\n return grad_A, grad_T\",\n \"def _backward(loss):\\n\\n loss.backward()\",\n \"def backward_pass(self, grad):\\n pass\",\n \"def L_model_backward(AL, Y, caches):\\n pass\",\n \"def relu_backward(dout, cache):\\n dx, x = None, cache\\n ###########################################################################\\n # TODO: Implement the ReLU backward pass. #\\n ###########################################################################\\n dx = dout.copy()\\n dx[x<=0] = 0\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n return dx\",\n \"def backward(self, inputs, grad_loss_input):\\n raise NotImplementedError\",\n \"def relu_backward(dout, x):\\n ############################################################################\\n # TODO: Implement the ReLU backward pass. #\\n ############################################################################\\n ############################################################################\\n # START OF YOUR CODE #\\n ############################################################################\\n judge = x>0\\n dx = dout*judge\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n return dx\",\n \"def backward_G(self):\\n self.loss_G.backward()\",\n \"def relu_backward(dout, cache):\\n dx, x = None, cache\\n ###########################################################################\\n # TODO: Implement the ReLU backward pass. #\\n ###########################################################################\\n dx = dout * (x > 0)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n return dx\",\n \"def relu_backward(dout, cache):\\n dx, x = None, cache\\n ###########################################################################\\n # TODO: Implement the ReLU backward pass. #\\n ###########################################################################\\n dx = dout * (x > 0)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n return dx\",\n \"def backward(self, lhs: Tensor, rhs: Tensor, acc_grad: np.ndarray):\\n raise NotImplementedError\",\n \"def relu_backward_hook_function(module, grad_in, grad_out):\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\",\n \"def relu_backward_hook_function(module, grad_in, grad_out):\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\",\n \"def relu_backward_hook_function(module, grad_in, grad_out):\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\",\n \"def relu_backward_hook_function(module, grad_in, grad_out):\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\",\n \"def relu_backward_hook_function(module, grad_in, grad_out):\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\",\n \"def backward(ctx, dy):\\n y = ctx.y\\n if ctx.eagerly_discard_variables:\\n del ctx.y\\n for i in range(len(ctx.reversible_blocks) - 1, -1, -1):\\n y, dy = ctx.reversible_blocks[i].backward_pass(y, dy, not ctx.eagerly_discard_variables)\\n if ctx.eagerly_discard_variables:\\n del ctx.reversible_blocks\\n return dy, None, None\",\n \"def relu_backward(dout, cache):\\n dx, x = None, cache\\n ###########################################################################\\n # TODO: Implement the ReLU backward pass. #\\n ###########################################################################\\n #print(dout)\\n dx = np.empty_like(dout)\\n np.copyto(dx, dout)\\n dx[x < 0] = 0\\n #print(dx)\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n return dx\",\n \"def relu_backward_hook_function(module, grad_in, grad_out):\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\",\n \"def L_model_backward(AL, Y, caches):\\n grads = {}\\n L = len(caches) # the number of layers\\n m = AL.shape[1]\\n Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL\\n\\n dAL = -(np.divide(Y,AL)-np.divide(1-Y,1-AL))\\n \\\"\\\"\\\"\\n cache = caches[-1]\\n grads[\\\"dA\\\"+str(L)],grads[\\\"dW\\\"+str(L)],grads[\\\"db\\\"+str(L)] = linear_activation_backward(dAL,cache,activation = 'sigmoid')\\n\\n for i in reversed(range(L-1)):\\n grads[\\\"dA\\\"+str(i+1)],grads[\\\"dW\\\"+str(i+1)],grads[\\\"db\\\"+str(i+1)] = linear_activation_backward(grads[\\\"dA\\\"+str(i+2)],caches[i],activation = 'relu')\\n \\\"\\\"\\\"\\n\\n current_cache = caches[-1]\\n grads[\\\"dA\\\" + str(L)], grads[\\\"dW\\\" + str(L)], grads[\\\"db\\\" + str(L)] = linear_backward(sigmoid_backward(dAL, current_cache[1]),current_cache[0])\\n\\n for l in reversed(range(L - 1)):\\n # lth layer: (RELU -> LINEAR) gradients.\\n # Inputs: \\\"grads[\\\"dA\\\" + str(l + 2)], caches\\\". Outputs: \\\"grads[\\\"dA\\\" + str(l + 1)] , grads[\\\"dW\\\" + str(l + 1)] , grads[\\\"db\\\" + str(l + 1)]\\n ### START CODE HERE ### (approx. 5 lines)\\n current_cache = caches[l]\\n dA_prev_temp, dW_temp, db_temp = linear_backward(sigmoid_backward(dAL, current_cache[1]), current_cache[0])\\n grads[\\\"dA\\\" + str(l + 1)] = dA_prev_temp\\n grads[\\\"dW\\\" + str(l + 1)] = dW_temp\\n grads[\\\"db\\\" + str(l + 1)] = db_temp\\n ### END CODE HERE ###\\n\\n return grads\",\n \"def _AffLayerReluDrop_Backprop(self, dscores, cache):\\n grads = {}\\n loss = None\\n #Last Softmax Layer\\n ##Add L2 Regularization loss\\n loss = 0.5 * self.reg * np.sum(self.params['W{0}'.format(self.num_layers)]**2)\\n ##Calculate grads for last Affine\\n dhid, grads['W{0}'.format(self.num_layers)], grads['b{0}'.format(self.num_layers)] =\\\\\\n affine_backward(dscores, cache[-1])\\n grads['W{0}'.format(self.num_layers)] += self.reg * self.params['W{0}'.format(self.num_layers)]\\n\\n for i in range(self.num_layers-1, 0, -1): #hidden layers\\n ##L2 Reg. loss\\n loss += 0.5 * self.reg * np.sum(self.params['W{0}'.format(i)]**2)\\n ##Calculate grads for [{affine-Batchnorm-relu} X (L-1)]\\n dhid = dropout_backward(dhid, cache[i]['drop'])\\n dhid = relu_backward(dhid, cache[i]['relu'])\\n dhid, grads['gamma{0}'.format(i)], grads['beta{0}'.format(i)] = \\\\\\n layernorm_backward(dhid, cache[i]['layernorm'])\\n dhid, grads['W{0}'.format(i)], grads['b{0}'.format(i)] = \\\\\\n affine_backward(dhid, cache[i]['affine']) \\n grads['W{0}'.format(i)] += self.reg * self.params['W{0}'.format(i)]\\n\\n return grads, loss\",\n \"def backward(self, inputs, gradients, **kwargs):\\n grad_relu = inputs > 0\\n return gradients * grad_relu\",\n \"def backward(self, loss):\\n global_timer.my_timer.start_profile(\\\"BWD\\\")\\n mgr = PatrickStarManager()\\n mgr.set_training_stage(TrainingStage.BWD)\\n\\n for param_fp16 in self.client.chunk_based_param_fp16:\\n param_fp16.ps_attr.bwd_used_cnt = 0\\n\\n self.optimizer.zero_grad()\\n if self.loss_scaler:\\n self.loss_scaler.backward(loss)\\n else:\\n loss.backward()\\n mgr.update_margin_mem()\\n global_timer.my_timer.finish_profile(\\\"BWD\\\")\",\n \"def relu_backward(dout, cache):\\n #raise NotImplementedError\\n #######################################################################\\n # #\\n # #\\n # TODO: YOUR CODE HERE #\\n # #\\n # #\\n #######################################################################\\n x=cache\\n dout[x<=0]=0\\n dx=dout\\n return dx\",\n \"def affine_relu_backward(dout, cache):\\n fc_cache, relu_cache = cache\\n da = layers.relu_backward(dout, relu_cache)\\n dx, dw, db = layers.affine_backward(da, fc_cache)\\n return dx, dw, db\",\n \"def relu_backward(dA, internal_params):\\n\\n Z = internal_params\\n dZ = np.array(dA, copy=True)\\n\\n dZ[Z <= 0] = 0\\n\\n return dZ\",\n \"def backward(\\n self, X: np.ndarray, y: np.ndarray, lr: float, reg: float = 0.0\\n ) -> float:\\n y_hat = self.forward(X)\\n\\n y_one_hot = self.one_hot_encode(y)\\n loss = CrossEntropy.forward(y_one_hot, y_hat)\\n\\n d_layer = CrossEntropy.backward(y, y_hat)\\n\\n w_grads = []\\n b_grads = []\\n\\n for idx, layer in reversed(list(enumerate(self.layers))):\\n # Not output layer\\n if (idx + 1) < len(self.layers):\\n next_layer = self.layers[idx + 1]\\n\\n d_layer = d_layer.dot(next_layer.w.T)\\n d_layer = layer.activation_func.backward(d_layer, layer.activated_out)\\n\\n d_w = layer.linear_in.T.dot(d_layer) + 2 * reg * layer.w\\n d_b = np.sum(d_layer, axis=0)\\n\\n w_grads.insert(0, d_w)\\n b_grads.insert(0, d_b)\\n\\n self.optimizer.step(self.layers, w_grads, b_grads, lr)\\n\\n if self.norm_weights:\\n w_norm = max(np.linalg.norm(l.w) for l in self.layers) / len(self.layers)\\n b_norm = max(np.linalg.norm(l.w) for l in self.layers) / len(self.layers)\\n for layer in self.layers:\\n layer.w /= w_norm\\n layer.b /= b_norm\\n\\n return loss\",\n \"def backward_pass(self):\\r\\n # the gradient of cross-entropy on top of softmax is (t-y)\\r\\n back_output = (self.targets - self.y) / self.y.shape[0]\\r\\n\\r\\n for layer in reversed(self.layers):\\r\\n back_output = layer.backward_pass(back_output)\",\n \"def backward_and_step(self, loss):\\n self.opt.zero_grad()\\n loss.backward()\\n self.opt.step()\",\n \"def backward(self, X, Y, P, H, lmd):\\n G = - (Y - P)\\n _, Npts = P.shape\\n n_layers = len(self.hidden_units)\\n\\n gradients_W = []\\n gradients_b = []\\n\\n for i in range(n_layers, -1, -1):\\n\\n if i == 0:\\n grad_W = G @ X.T * (1/Npts) + 2 * lmd * self.W[i]\\n grad_b = G @ np.ones((Npts, 1)) * (1/Npts)\\n\\n else:\\n\\n h = H[i - 1]\\n w = self.W[i]\\n grad_W = G @ h.T * (1/Npts) + 2 * lmd * w\\n grad_b = G @ np.ones((Npts, 1)) * (1/Npts)\\n\\n G = w.T @ G\\n G = G * np.where(h > 0, 1, 0)\\n\\n gradients_W.append(grad_W)\\n gradients_b.append(grad_b)\\n\\n return gradients_W, gradients_b\",\n \"def leakrelu_backward(dA, Z):\\n\\n # When z <= 0, dz = 0.01\\n derivative = np.ones(Z.shape)\\n derivative[Z < 0] = 0.01\\n\\n dZ = dA * derivative\\n\\n assert (dZ.shape == Z.shape)\\n\\n return dZ\",\n \"def conv_bn_relu_backward(dout, cache):\\n conv_cache, sbn_cache, relu_cache = cache\\n da = relu_backward(dout, relu_cache)\\n dan, dgamma, dbeta = spatial_batchnorm_backward(da, sbn_cache)\\n dx, dw, db = conv_backward_fast(dan, conv_cache)\\n return dx, dw, db, dgamma, dbeta\",\n \"def update_relus(self):\\n\\n def relu_backward_hook_function(module, grad_in, grad_out):\\n \\\"\\\"\\\"\\n If there is a negative gradient, change it to zero\\n \\\"\\\"\\\"\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\\n\\n def relu_forward_hook_function(module, ten_in, ten_out):\\n \\\"\\\"\\\"\\n Store results of forward pass\\n \\\"\\\"\\\"\\n self.forward_relu_outputs.append(ten_out)\\n\\n # Loop through layers, hook up ReLUs\",\n \"def backward(self, gradient):\\n raise NotImplementedError()\",\n \"def relu_backward(dout, cache):\\n dx, x = None, cache\\n ###########################################################################\\n # TODO: Implement the ReLU backward pass. #\\n ###########################################################################\\n dx = dout * ((x > 0).astype(int))\\n ###########################################################################\\n # END OF YOUR CODE #\\n ###########################################################################\\n return dx\",\n \"def relu_backward(dout, cache):\\n dx, x = None, cache\\n dx = dout\\n dout[x <= 0] = 0.0\\n return dx\",\n \"def affine_relu_backward(dout, cache):\\n fc_cache, relu_cache = cache\\n da = relu_backward(dout, relu_cache)\\n dx, dw, db = affine_backward(da, fc_cache)\\n return dx, dw, db\",\n \"def affine_relu_backward(dout, cache):\\n fc_cache, relu_cache = cache\\n da = relu_backward(dout, relu_cache)\\n dx, dw, db = affine_backward(da, fc_cache)\\n return dx, dw, db\",\n \"def affine_relu_backward(dout, cache):\\n fc_cache, relu_cache = cache\\n da = relu_backward(dout, relu_cache)\\n dx, dw, db = affine_backward(da, fc_cache)\\n return dx, dw, db\",\n \"def affine_relu_backward(dout, cache):\\n fc_cache, relu_cache = cache\\n da = relu_backward(dout, relu_cache)\\n dx, dw, db = affine_backward(da, fc_cache)\\n return dx, dw, db\",\n \"def backward(self, gradient):\\n #TODO\\n pass\",\n \"def backward(self, gradient):\\n #TODO\\n pass\",\n \"def L_model_backward(AL, Y, caches, use_batchnorm, batchnorm_cache, dropout_cache):\\n\\n grads = {}\\n num_layers = len(caches)\\n use_dropout = len(dropout_cache) != 0\\n\\n last_layer_idx = num_layers\\n dA, dW, db = linear_backward(AL - Y, caches[-1]['linear_cache'])\\n grads['dA' + str(last_layer_idx)] = dA\\n grads['dW' + str(last_layer_idx)] = dW\\n grads['db' + str(last_layer_idx)] = db\\n\\n for layer_idx in reversed(range(1, num_layers)):\\n if use_dropout:\\n dA = dropout_backward(dA, dropout_cache[layer_idx])\\n\\n dA, dW, db = linear_activation_backward(dA , caches[layer_idx - 1], \\\"relu\\\", use_batchnorm, batchnorm_cache[layer_idx])\\n grads['dA' + str(layer_idx)] = dA\\n grads['dW' + str(layer_idx)] = dW\\n grads['db' + str(layer_idx)] = db\\n\\n return grads\",\n \"def backwards(delta,params,name='',activation_deriv=sigmoid_deriv):\\n # everything you may need for this layer\\n W = params['W' + name]\\n b = params['b' + name]\\n X, pre_act, post_act = params['cache_' + name]\\n # your code here\\n # do the derivative through activation first\\n # then compute the derivative W,b, and X\\n \\n delta_pre = activation_deriv(post_act) * delta\\n # (in_dim, out_dim) = (in_dim, examples) @ (examples, out_dim)\\n grad_W = X.transpose() @ delta_pre\\n grad_b = np.sum(delta_pre, axis=0, keepdims=True) # (1, out_dim)\\n # (examples, in_dim) = (examples, out_dim) @ (out_dim, in_dim)\\n grad_X = delta_pre @ W.transpose()\\n\\n # store the gradients\\n params['grad_W' + name] = grad_W\\n params['grad_b' + name] = grad_b\\n return grad_X\",\n \"def relu_backward(dout, cache):\\r\\n x = cache\\r\\n dx = dout * (x > 0)\\r\\n return dx\",\n \"def update_relus(self):\\n def relu_backward_hook_function(module, grad_in, grad_out):\\n \\\"\\\"\\\"\\n If there is a negative gradient, change it to zero\\n \\\"\\\"\\\"\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\\n\\n def relu_forward_hook_function(module, ten_in, ten_out):\\n \\\"\\\"\\\"\\n Store results of forward pass\\n \\\"\\\"\\\"\\n self.forward_relu_outputs.append(ten_out)\\n\\n # Loop through layers, hook up ReLUs\\n for pos, module in self.model._features_extractor._modules.items():\\n for layer in module:\\n if isinstance(layer, LeakyReLU):\\n layer.register_backward_hook(relu_backward_hook_function)\\n layer.register_forward_hook(relu_forward_hook_function)\",\n \"def backward(self, dout):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n for l in range(len(self.layers)-1,-1,-1):\\n act_dout = self.activations[l].backward(dout)\\n dout = self.layers[l].backward(act_dout)\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return\",\n \"def grad_ReLU(self):\\n y = self.x\\n y[y<=0] = 0\\n y[y>0] = 1\\n return y\\n raise NotImplementedError(\\\"ReLU gradient not implemented\\\")\",\n \"def conv_relu_backward_naive(dout, cache):\\n\\tconv_cache, relu_cache = cache\\n\\tda = relu_backward(dout, relu_cache)\\n\\tdx, dw, db = conv_backward_naive(da, conv_cache)\\n\\treturn dx, dw, db\",\n \"def _AffLayerRelu_Backprop(self, dscores, cache):\\n grads = {}\\n loss = None\\n #Last Softmax Layer\\n ##Add L2 Regularization loss\\n loss = 0.5 * self.reg * np.sum(self.params['W{0}'.format(self.num_layers)]**2)\\n ##Calculate grads for last Affine\\n dhid, grads['W{0}'.format(self.num_layers)], grads['b{0}'.format(self.num_layers)] =\\\\\\n affine_backward(dscores, cache[-1])\\n grads['W{0}'.format(self.num_layers)] += self.reg * self.params['W{0}'.format(self.num_layers)]\\n\\n for i in range(self.num_layers-1, 0, -1): #hidden layers\\n ##L2 Reg. loss\\n loss += 0.5 * self.reg * np.sum(self.params['W{0}'.format(i)]**2)\\n ##Calculate grads for [{affine-Batchnorm-relu} X (L-1)]\\n dhid = relu_backward(dhid, cache[i]['relu'])\\n dhid, grads['gamma{0}'.format(i)], grads['beta{0}'.format(i)] = \\\\\\n layernorm_backward(dhid, cache[i]['layernorm'])\\n dhid, grads['W{0}'.format(i)], grads['b{0}'.format(i)] = \\\\\\n affine_backward(dhid, cache[i]['affine']) \\n grads['W{0}'.format(i)] += self.reg * self.params['W{0}'.format(i)]\\n\\n return grads, loss\",\n \"def backward_pass(self, delta):\\n\\n a = config['learning_rate']\\n y = config['momentum_gamma']\\n m = config['momentum']\\n l = config['L2_penalty']\\n\\n # print(\\\"shape of delta incoming: \\\", delta.shape, \\\"shape of x: \\\", self.x.shape)\\n self.d_x = delta.T @ self.x\\n # print(\\\"SHAPE OF GRADIENT: \\\", self.d_x.shape)\\n\\n # gradient momentum\\n self.w_inc = (a * self.d_x.T) + (y * self.d_v) - l * self.w\\n \\n # saving \\n if m:\\n self.d_v = self.w_inc\\n else:\\n self.d_v = np.zeros(self.w.shape)\\n\\n # backprop for bias weights\\n x_0 = np.ones([len(delta), 1])\\n\\n self.d_b = delta.T @ x_0\\n\\n # print(\\\"shape of BIAS GRAD: \\\", self.d_b.shape)\\n\\n self.d_w = delta @ self.w.T\\n # print(\\\"shape of w.T: \\\", self.w.T.shape, \\\"shape of RETURN delta: \\\", self.d_w.shape)\\n #print(self.w.shape)\\n return self.d_w\",\n \"def on_iter_backward(self, runner):\\n runner.optimizer.zero_grad()\\n runner.loss.backward()\\n runner.optimizer.step()\",\n \"def _AffBatchReluDrop_Backprop(self, dscores, cache):\\n grads = {}\\n loss = None\\n #Last Softmax Layer\\n ##Add L2 Regularization loss\\n loss = 0.5 * self.reg * np.sum(self.params['W{0}'.format(self.num_layers)]**2)\\n ##Calculate grads for last Affine\\n dhid, grads['W{0}'.format(self.num_layers)], grads['b{0}'.format(self.num_layers)] =\\\\\\n affine_backward(dscores, cache[-1])\\n grads['W{0}'.format(self.num_layers)] += self.reg * self.params['W{0}'.format(self.num_layers)]\\n\\n for i in range(self.num_layers-1, 0, -1): #hidden layers\\n ##L2 Reg. loss\\n loss += 0.5 * self.reg * np.sum(self.params['W{0}'.format(i)]**2)\\n ##Calculate grads for [{affine-Batchnorm-relu-drop} X (L-1)]\\n dhid = dropout_backward(dhid, cache[i]['drop'])\\n dhid = relu_backward(dhid, cache[i]['relu'])\\n dhid, grads['gamma{0}'.format(i)], grads['beta{0}'.format(i)] = \\\\\\n batchnorm_backward_alt(dhid, cache[i]['batchnorm'])\\n dhid, grads['W{0}'.format(i)], grads['b{0}'.format(i)] = \\\\\\n affine_backward(dhid, cache[i]['affine']) \\n grads['W{0}'.format(i)] += self.reg * self.params['W{0}'.format(i)]\\n\\n return grads, loss\",\n \"def linear_backward(dZ, cache):\\n pass\",\n \"def relu_backward(dA, Z):\\n\\n dZ = np.array(dA, copy=True) # just converting dz to a correct object.\\n\\n # When z <= 0, you should set dz to 0 as well.\\n dZ[Z <= 0] = 0\\n\\n assert (dZ.shape == Z.shape)\\n\\n return dZ\",\n \"def update_relus(self):\\n def relu_backward_hook_function(module, grad_in, grad_out):\\n \\\"\\\"\\\"\\n If there is a negative gradient, change it to zero\\n \\\"\\\"\\\"\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\\n\\n def relu_forward_hook_function(module, ten_in, ten_out):\\n \\\"\\\"\\\"\\n Store results of forward pass\\n \\\"\\\"\\\"\\n self.forward_relu_outputs.append(ten_out)\\n\\n # Loop through layers, hook up ReLUs\\n for pos, module in self.model.features._modules.items():\\n if isinstance(module, ReLU):\\n module.register_backward_hook(relu_backward_hook_function)\\n module.register_forward_hook(relu_forward_hook_function)\",\n \"def unrolled_backward(self, trn_X, trn_y, val_X, val_y, lr, w_optim, amended: bool = False):\\n # do virtual step (calc w`)\\n self.virtual_step(trn_X, trn_y, lr, w_optim)\\n\\n # calc unrolled loss\\n normal_alphas, reduce_alphas = self.v_net.alpha_weights()\\n loss = self.v_net.loss(val_X, val_y) # L_val(w`)\\n\\n # Loss += SUM[ none - mean(others) ]\\n loss += self.normal_none_penalty * sum([(alpha[:, -1] - alpha[:, :-1].mean()).sum() for alpha in normal_alphas])\\n loss += self.reduce_none_penalty * sum([(alpha[:, -1] - alpha[:, :-1].mean()).sum() for alpha in reduce_alphas])\\n\\n # compute gradient\\n v_alphas = tuple(self.v_net.alphas())\\n v_weights = tuple(self.v_net.weights())\\n v_grads = torch.autograd.grad(loss, v_alphas + v_weights)\\n dalpha = v_grads[:len(v_alphas)]\\n dw = v_grads[len(v_alphas):]\\n\\n hessian = self.amended_gradient(dw, trn_X, trn_y) if amended else self.compute_hessian(dw, trn_X, trn_y)\\n\\n # update final gradient = dalpha - lr*hessian\\n with torch.no_grad():\\n for alpha, da, h in zip(self.net.alphas(), dalpha, hessian):\\n alpha.grad = da - lr * h\",\n \"def backward(self, grad_z):\\n\\t\\t#######################################################################\\n\\t\\t# ** START OF YOUR CODE **\\n\\t\\t#######################################################################\\n\\n\\t\\tgradient = self._layers[-1].backward(grad_z)\\n\\t\\tfor i in range(len(self._layers) - 2, -1, -1):\\n\\t\\t\\tgradient = self._layers[i].backward(gradient)\\n\\t\\treturn gradient\\n\\n\\t\\t#######################################################################\\n\\t\\t# ** END OF YOUR CODE **\\n\\t\\t#######################################################################\",\n \"def backward(self, upstream_grad):\\n # couple upstream gradient with local gradient, the result will be sent back to the Linear layer\\n self.dZ = upstream_grad * self.A*(1-self.A)\",\n \"def L_model_backward(AL, Y, caches, X):\\n grads = {}\\n L = len(caches) # the number of layers\\n m = AL.shape[1]\\n Y = Y.reshape(AL.shape) # after this line, Y is the same shape as AL\\n \\n # Initializing the backpropagation \\n dZ = AL - Y # Derivative of Cross Entropy Loss with Softmax\\n \\n # Lth layer (SOFTMAX -> LINEAR) gradients. Inputs: \\\"AL, Y, caches\\\". Outputs: \\\"grads[\\\"dAL\\\"], grads[\\\"dWL\\\"], grads[\\\"dbL\\\"]\\n current_cache = caches[L-1]\\n grads[\\\"dA\\\" + str(L)], grads[\\\"dW\\\" + str(L)], grads[\\\"db\\\" + str(L)] = linear_activation_backward(dZ, AL, current_cache, activation = \\\"softmax\\\")\\n \\n for l in reversed(range(L-1)):\\n # lth layer: (RELU -> LINEAR) gradients.\\n current_cache = caches[l]\\n dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads[\\\"dA\\\" + str(l + 2)], AL, current_cache, activation = \\\"relu\\\")\\n grads[\\\"dA\\\" + str(l + 1)] = dA_prev_temp\\n grads[\\\"dW\\\" + str(l + 1)] = dW_temp\\n grads[\\\"db\\\" + str(l + 1)] = db_temp\\n\\n return grads\",\n \"def backward(self):\\n gradient = blah\\n return gradient\",\n \"def backward(self):\\n gradient = blah\\n return gradient\",\n \"def backward_step(activations, targets, layers):\\n param_grads = collections.deque() # List of parameter gradients for each layer\\n output_grad = None # The error gradient at the output of the current layer\\n # Propagate the error backwards through all the layers.\\n # Use reversed to iterate backwards over the list of layers.\\n for i, layer in enumerate(reversed(layers)):\\n cur_layer_idx = len(layers) - i - 1\\n if cur_layer_idx <= NUM_LAYERS_SKIP:\\n # implement short circuit here\\n if layer.is_fc_layer:\\n grads = [0.0 for _ in range(layer.W.shape[0]*layer.W.shape[1]+layer.W.shape[1])]\\n else:\\n # normal gradient computation \\n Y = activations.pop() # Get the activations of the last layer on the stack\\n # Compute the error at the output layer.\\n # The output layer error is calculated different then hidden layer error.\\n if output_grad is None:\\n input_grad = layer.get_input_grad(Y, targets)\\n else: # output_grad is not None (layer is not output layer)\\n input_grad = layer.get_input_grad(Y, output_grad)\\n # Get the input of this layer (activations of the previous layer)\\n X = activations[-1]\\n # Compute the layer parameter gradients used to update the parameters\\n grads = layer.get_params_grad(X, output_grad)\\n param_grads.appendleft(grads)\\n # Compute gradient at output of previous layer (input of current layer):\\n output_grad = input_grad\\n return list(param_grads) # Return the parameter gradients\",\n \"def affine_batchnorm_relu_backward(dout, cache):\\n fc_cache, norm_cache, relu_cache = cache\\n d_norm_out = relu_backward(dout, relu_cache)\\n d_affine_out, dgamma, dbeta = batchnorm_backward_alt(d_norm_out, norm_cache)\\n dx, dw, db = affine_backward(d_affine_out, fc_cache)\\n return dx, dw, db, dgamma, dbeta\",\n \"def backward(self, delta):\\n if self.activation_type == \\\"sigmoid\\\":\\n grad = self.grad_sigmoid()\\n\\n elif self.activation_type == \\\"tanh\\\":\\n grad = self.grad_tanh()\\n\\n elif self.activation_type == \\\"ReLU\\\":\\n grad = self.grad_ReLU()\\n\\n return grad * delta\",\n \"def backward_step(activations, targets, layers):\\n param_grads = collections.deque() # List of parameter gradients for each layer\\n output_grad = None # The error gradient at the output of the current layer\\n # Propagate the error backwards through all the layers.\\n # Use reversed to iterate backwards over the list of layers.\\n for layer in reversed(layers): \\n Y = activations.pop() # Get the activations of the last layer on the stack\\n # Compute the error at the output layer.\\n # The output layer error is calculated different then hidden layer error.\\n if output_grad is None:\\n input_grad = layer.get_input_grad(Y, targets)\\n else: # output_grad is not None (layer is not output layer)\\n input_grad = layer.get_input_grad(Y, output_grad)\\n # Get the input of this layer (activations of the previous layer)\\n X = activations[-1]\\n # Compute the layer parameter gradients used to update the parameters\\n grads = layer.get_params_grad(X, output_grad)\\n param_grads.appendleft(grads)\\n # Compute gradient at output of previous layer (input of current layer):\\n output_grad = input_grad\\n return list(param_grads) # Return the parameter gradients\",\n \"def update_relus(self):\\n def relu_backward_hook_function(module, grad_in, grad_out):\\n \\\"\\\"\\\"\\n If there is a negative gradient, change it to zero\\n \\\"\\\"\\\"\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\\n\\n def relu_forward_hook_function(module, ten_in, ten_out):\\n \\\"\\\"\\\"\\n Store results of forward pass\\n \\\"\\\"\\\"\\n self.forward_relu_outputs.append(ten_out)\\n\\n # Loop through layers, hook up ReLUs\\n for pos, module in self.model.named_modules():\\n if isinstance(module, ReLU):\\n module.register_backward_hook(relu_backward_hook_function)\\n module.register_forward_hook(relu_forward_hook_function)\",\n \"def update_relus(self):\\n def relu_backward_hook_function(module, grad_in, grad_out):\\n \\\"\\\"\\\"\\n If there is a negative gradient, change it to zero\\n \\\"\\\"\\\"\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\\n\\n def relu_forward_hook_function(module, ten_in, ten_out):\\n \\\"\\\"\\\"\\n Store results of forward pass\\n \\\"\\\"\\\"\\n self.forward_relu_outputs.append(ten_out)\\n\\n # Loop through layers, hook up ReLUs\\n for pos, module in self.model.named_modules():\\n if isinstance(module, nn.ReLU):\\n module.register_backward_hook(relu_backward_hook_function)\\n module.register_forward_hook(relu_forward_hook_function)\",\n \"def backward(self, out_grad, input):\\n raise NotImplementedError\",\n \"def affine_layernorm_relu_backward(dout, cache):\\n fc_cache, norm_cache, relu_cache = cache\\n d_norm_out = relu_backward(dout, relu_cache)\\n d_affine_out, dgamma, dbeta = layernorm_backward(d_norm_out, norm_cache)\\n dx, dw, db = affine_backward(d_affine_out, fc_cache)\\n return dx, dw, db, dgamma, dbeta\",\n \"def rnn_backward(dh, cache):\\n dx, dh_prev, dWx, dWh, db = None, None, None, None, None\\n ##############################################################################\\n # TODO: Implement the backward pass for a vanilla RNN running an entire #\\n # sequence of data. You should use the rnn_step_backward function that you #\\n # defined above. #\\n ##############################################################################\\n \\\"\\\"\\\"\\n x, next_h, prev_h, Wx, Wh, b = cache\\n dz = (1-next_h*next_h)*dnext_h\\n # THIS ERROR IS SPREAD AMONG THE\\n # np.dot(x, Wx) + np.dot(prev_h, Wh) + b)\\n dx = np.dot(dz,Wx.T)\\n dprev_h = np.dot(dz,Wh.T)\\n db = np.sum(dz,axis=0)\\n dWx = np.dot(x.T,dz)\\n dWh = np.dot(prev_h.T,dz)\\n #d(tanh) = 1- tanh*tanh\\n \\\"\\\"\\\"\\n #pdb.set_trace()\\n # dh is not result of forward prop\\n # but\\n N,T,H = dh.shape\\n tmp_x, tmp_next_h, tmp_prev_h, tmp_Wx, tmp_Wh, tmp_b = cache[T-1]\\n D = tmp_x.shape[1]\\n\\n\\n dx = np.zeros((N,T,D))\\n dh_prev = np.zeros((N,H))\\n dWx = np.zeros((D,H))\\n dWh = np.zeros((H,H))\\n db = np.zeros((H))\\n\\n for i in reversed(list(range(0,T))):\\n # current gradient at timestep is the upstream gradient (provided as input)\\n # this may be coming from the Y as in the min_char_rnn.py (see line 59)\\n # + downstream gradient provided by rnn_step_backward.\\n dh_curr = dh[:,i,:] + dh_prev\\n dx_, dh_prev, dWx_, dWh_, db_ = rnn_step_backward(dh_curr, cache[i])\\n dWx += dWx_\\n dWh += dWh_\\n db += db_\\n dx[:,i,:]=dx_\\n\\n\\n ##############################################################################\\n # END OF YOUR CODE #\\n ##############################################################################\\n return dx, dh_prev, dWx, dWh, db\",\n \"def backward(ctx, grad_output):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n # Retrieve saved tensors and constants\\n gamma, ivar, mean, input = ctx.saved_tensors\\n eps = ctx.saved_tensors\\n\\n # Check which inputs need gradients\\n input_needs_grad, gamma_needs_grad, beta_needs_grad = ctx.needs_input_grad\\n\\n # Get the batch size (=N)\\n N, _ = grad_output.shape\\n\\n # reconstruct the input_norm\\n input_norm = (input - mean) * ivar\\n grand_input_norm = grad_output * gamma\\n\\n ##### Gradient wrt beta #####\\n grad_beta = grad_output.sum(dim=0) if beta_needs_grad else None\\n\\n #### Gradient wrt gamma ####\\n grad_gamma = (input_norm*grad_output).sum(dim=0) if gamma_needs_grad else None\\n \\n #### Gradient wrt input ####\\n term1 = N*grand_input_norm \\n term2 = torch.sum(grand_input_norm, dim=0)\\n term3 = input_norm*torch.sum(grand_input_norm*input_norm, dim=0)\\n grad_input = (1. / N) * ivar * (term1 - term2 - term3) if input_needs_grad else None\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n # return gradients of the three tensor inputs and None for the constant eps\\n return grad_input, grad_gamma, grad_beta, None\",\n \"def affine_batchnorm_relu_backward(dout, cache):\\n af_cache, bf_cache, relu_cache = cache\\n \\n dbf_out = relu_backward(dout, relu_cache)\\n daf_out, dgamma, dbeta = batchnorm_backward(dbf_out, bf_cache)\\n dx, dw, db = affine_backward(daf_out, af_cache)\\n return dx, dw, db, dgamma, dbeta\",\n \"def backward_pass(architecture,gradient_layerwise,grad_weights,grad_bias):\\n \\n for layer in range(len(architecture)-1,-1,-1):\\n X_input,X_output,weightsi,biasi,X_input_im2col,imi,output_shapei,kernel_shapei,stridei,operationi,imxi = architecture['layer{}'.format(layer+1)]\\n# print(\\\"Operation is:{} and Layer is: {}\\\".format(operationi,layer+1))\\n if operationi == 'softmax': # Last layer -> Dont apply softmax in any layer other than the last layer!\\n # not taking gradients here because we need dz_dX(secondlastlayer) which is y_pred - y\\n continue\\n \\n if operationi == 'conv_bn_relu' or operationi == 'conv_relu' or operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n if operationi__1 == 'softmax':\\n y_pred = architecture['layer{}'.format(layer+2)][1]\\n y_pred = torch.reshape(y_pred,y.shape)\\n dz_dXi = y_pred - y\\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi:\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n \\n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # .\\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # .\\n try:\\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input_im2col)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\\n except:\\n dz_dweightsi = (dz_dXi).mm(X_input_im2col)\\n \\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0\\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi #\\n elif operationi__1 == 'maxpool': # need to do something here to fix the problem\\n None\\n\\n elif 'flatten' in operationi__1:\\n # we currently have dz_doutput of flatten -> we want dz_doutput of the conv_bn_relu before flatten\\n \\n weightsi__1 = architecture['layer{}'.format(layer+2)][2] # weights2\\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput of flatten\\n if len(dz_dXi__1.shape) == 3:\\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\\n imi__1 = architecture['layer{}'.format(layer+2)][5] # i\\n try:\\n dz_dXi = torch.t(weightsi__1).mm(dz_dXi__1)\\n except:\\n dz_dXi = weightsi__1.mm(dz_dXi__1)\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n if operationi == 'conv_sigmoid' or operationi == 'conv_bn_sigmoid':\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi:\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n\\n dz_dXi = torch.reshape(dz_dXi,(output_shapei[1]*output_shapei[2],-1))\\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\\n dz_dweightsi = X_input_im2col.mm(dz_dXi)\\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\\n dz_dbi = dz_dXi\\n \\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)# Can also set this to layer like in line ~800\\n \\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi) # Can also set this to layer like in line ~800\\n \\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi) # Can also set this to layer like in line ~800\\n \\n else:\\n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dX2 -> backpropagated from maxpool\\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\\n if len(dz_dXi__1.shape) == 3:\\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\\n imi__1 = architecture['layer{}'.format(layer+2)][5]\\n try:\\n Y = weightsi__1.mm(dz_dXi__1)\\n except:\\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\\n dz_dXi = torch.zeros(X_output.shape)\\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\\n for i in range(np.shape(X_output)[0]):\\n for j in range(np.shape(X_output)[1]):\\n for k in range(np.shape(X_output)[2]):\\n idxs = getIndexes(imi__1,(i,j,k))\\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\\n \\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n if 'sigmoid' in operationi__1: # ...\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi__1: # ...\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n \\n dz_dXi = torch.reshape(dz_dXi,(output_shape_current_layer[1]*output_shape_current_layer[2],-1))\\n dz_dbi = torch.reshape(dz_dXi,bias_current_layer.shape)\\n dz_dweightsi = X_im2col_current_layer.mm(dz_dXi)\\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0 # Gradient Clipping\\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\\n \\n if operationi == 'maxpool':\\n \\n weightsi__1 = architecture['layer{}'.format(layer+2)][2]\\n dz_dXi__1 = gradient_layerwise['layer{}'.format(layer+2)][0] # dz_dXoutput -> backpropagated from maxpool\\n output_shapei__1 = architecture['layer{}'.format(layer+2)][6]\\n operationi__1 == architecture['layer{}'.format(layer+2)][9] # ...\\n \\n if len(dz_dXi__1.shape) == 3:\\n dz_dXi__1 = torch.reshape(dz_dXi__1,(-1,output_shapei__1[0]))\\n imi__1 = architecture['layer{}'.format(layer+2)][5]\\n try:\\n Y = weightsi__1.mm(dz_dXi__1)\\n except:\\n try:\\n Y = weightsi__1.mm(torch.t(dz_dXi__1))\\n except:\\n Y = torch.t(weightsi__1).mm(dz_dXi__1) # Ensuring valid matrix multiplication here\\n \\n dz_dXi = torch.zeros(X_output.shape)\\n output_shape_current_layer = architecture['layer{}'.format(layer+1)][6]\\n bias_current_layer = architecture['layer{}'.format(layer+1)][3]\\n X_im2col_current_layer = architecture['layer{}'.format(layer+1)][4]\\n for i in range(np.shape(X_output)[0]):\\n for j in range(np.shape(X_output)[1]):\\n for k in range(np.shape(X_output)[2]):\\n idxs = getIndexes(imi__1,(i,j,k))\\n dz_dXi[i,j,k] = sum([Y[idx[0],idx[1]] for idx in idxs])\\n\\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n \\n if operationi__1 == 'conv_sigmoid' or operationi__1 == 'conv_bn_sigmoid': # ...\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n else:\\n dz_dXi[X_output <= 0] = 0\\n\\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXi)\\n \\n dz_dXinput = torch.zeros((X_input.shape))\\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+1)][0] # output = output of maxpool\\n\\n dz_dXoutput = torch.reshape(dz_dXoutput,(output_shapei[0],X_input_im2col.shape[2]))\\n \\n for i in range(output_shapei[0]):\\n for j in range(X_input_im2col.shape[2]):\\n Xi2ci = X_im2col_current_layer[i,:,:]\\n idx = torch.argmax(Xi2ci[:,j]).item()\\n value = imxi[i][(idx,j)]\\n dz_dXinput[value[0],value[1],value[2]] += float(dz_dXoutput[i,j])\\n\\n# dz_dXinput = torch.reshape(dz_dXinput,output_shapei)\\n \\n X_prev_im2col = architecture['layer{}'.format(layer)][4]\\n X_output_prev = architecture['layer{}'.format(layer)][1]\\n X_output_prev = torch.reshape(X_output_prev,dz_dXinput.shape)\\n X_input_prev = architecture['layer{}'.format(layer)][0]\\n prev_bias = architecture['layer{}'.format(layer)][3]\\n output_shape_prev = architecture['layer{}'.format(layer)][6]\\n prev_operation = architecture['layer{}'.format(layer)][9]\\n \\n if prev_operation == 'conv_sigmoid' or prev_operation == 'conv_bn_sigmoid':\\n dz_dXinput *= sigmoid(X_output_prev)*(1-sigmoid(X_output_prev)) # Taking the derivative of the sigmoid function\\n else:\\n dz_dXinput[X_output_prev <= 0] = 0\\n \\n if len(dz_dXinput.shape) == 3:\\n dz_dXinput = torch.reshape(dz_dXinput,(-1,output_shape_prev[0]))\\n \\n dz_dbi = torch.reshape(dz_dXinput,prev_bias.shape)\\n dz_dweightsi = X_prev_im2col.mm(dz_dXinput)\\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0\\n \\n gradient_layerwise['layer{}'.format(layer)][2] = torch.Tensor(dz_dbi)\\n gradient_layerwise['layer{}'.format(layer)][1] = torch.Tensor(dz_dweightsi)\\n gradient_layerwise['layer{}'.format(layer)][0] = torch.Tensor(dz_dXinput) # ...\\n \\n if 'flatten_dense' in operationi:\\n \\n operationi__1 = architecture['layer{}'.format(layer+2)][9]\\n \\n if operationi__1 == 'softmax':\\n \\n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\\n X_output = torch.reshape(X_output,(-1,1))\\n y_pred = architecture['layer{}'.format(layer+2)][1]\\n y_pred = torch.reshape(y_pred,y.shape)\\n dz_dXi = y_pred - y\\n dz_dXi[dz_dXi > clip] = 0 # Gradient Clipping\\n dz_dXi[dz_dXi < -clip] = 0 # Gradient Clipping\\n X_output = torch.reshape(X_output,dz_dXi.shape)\\n if 'sigmoid' in operationi:\\n dz_dXi *= sigmoid(X_output)*(1-sigmoid(X_output)) # Taking the derivative of the sigmoid function\\n elif 'relu' in operationi:\\n dz_dXi[X_output <= 0] = 0\\n else:\\n None\\n \\n dz_dbi = torch.reshape(dz_dXi,biasi.shape)\\n try:\\n dz_dweightsi = (dz_dXi).mm(torch.t(X_input)) # dz_dweightsi = dz_dXi * dXi_dweightsi (chain rule)\\n except:\\n dz_dweightsi = (dz_dXi).mm(X_input)\\n \\n dz_dweightsi[dz_dweightsi > clip] = 0 # Gradient Clipping\\n dz_dweightsi[dz_dweightsi < -clip] = 0\\n \\n gradient_layerwise['layer{}'.format(layer+1)][0] = dz_dXi # Can also set this to layer like in line ~800\\n gradient_layerwise['layer{}'.format(layer+1)][1] = dz_dweightsi # Can also set this to layer like in line ~800\\n gradient_layerwise['layer{}'.format(layer+1)][2] = dz_dbi # Can also set this to layer like in line ~800\\n \\n else:\\n # Have to modify and test this before implementation -> Specifically\\n # the backprop implementation is not consistent with the ones above\\n #\\n X_output = torch.reshape(X_output,(-1,1))\\n weights__i = architecture['layer{}'.format(layer+2)][2]\\n dz_dXoutput = gradient_layerwise['layer{}'.format(layer+2)][0]\\n dz_dXoutput = torch.reshape(torch.Tensor(dz_dXoutput),X_output.shape)\\n X_input = torch.reshape(torch.Tensor(X_input),(-1,1))\\n\\n if 'relu' in operationi:\\n dz_dXoutput[X_output<0] = 0\\n try:\\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\\n except:\\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\\n try:\\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\\n except:\\n dz_dweightsi = dz_dXoutput.mm(X_input)\\n dz_dbi = dz_dXoutput\\n if 'sigmoid' in operationi:\\n dz_dXoutput*= sigmoid(X_output)*(1-sigmoid(X_output))\\n try:\\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\\n except:\\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\\n try:\\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\\n except:\\n dz_dweightsi = dz_dXoutput.mm(X_input)\\n dz_dbi = dz_dXoutput\\n else:\\n try:\\n dz_dXinput = torch.t(weights__i).mm(dz_dXoutput)\\n except:\\n dz_dXinput = torch.t(dz_dXoutput).mm(weights__i)\\n try:\\n dz_dweightsi = dz_dXoutput.mm(torch.t(X_input))\\n except:\\n dz_dweightsi = dz_dXoutput.mm(X_input)\\n dz_dbi = dz_dXoutput\\n \\n unflattened_Xinput = architecture['layer{}'.format(layer+1)][0]\\n dz_dXinput = torch.reshape(dz_dXinput,unflattened_Xinput.shape)\\n gradient_layerwise['layer{}'.format(layer+1)][2] = torch.Tensor(dz_dbi)\\n gradient_layerwise['layer{}'.format(layer+1)][1] = torch.Tensor(dz_dweightsi)\\n gradient_layerwise['layer{}'.format(layer+1)][0] = torch.Tensor(dz_dXinput)\\n \\n if gradient_layerwise['layer{}'.format(layer+1)][1] is not None:\\n try:\\n grad_weights['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][1]\\n except:\\n grad_weights['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][1])\\n if gradient_layerwise['layer{}'.format(layer+1)][2] is not None:\\n try:\\n grad_bias['layer{}'.format(layer+1)] += gradient_layerwise['layer{}'.format(layer+1)][2]\\n except:\\n grad_bias['layer{}'.format(layer+1)] += torch.t(gradient_layerwise['layer{}'.format(layer+1)][2])\\n \\n gc.collect()\\n return\",\n \"def backward(self, grad_z):\\n\\t\\t#######################################################################\\n\\t\\t# ** START OF YOUR CODE **\\n\\t\\t#######################################################################\\n\\n\\t\\tself._grad_W_current = self._cache_current.T @ grad_z\\n\\t\\tself._grad_b_current = np.ones((1,self._cache_current.shape[0])) @ grad_z\\n\\n\\t\\treturn grad_z @ self._W.T\\n\\n\\t\\t#######################################################################\\n\\t\\t# ** END OF YOUR CODE **\\n\\t\\t#######################################################################\",\n \"def backward(self, gradient: Tensor) -> Tensor:\\n self.b_grad = np.sum(gradient, axis=0)\\n self.w_grad = self.inputs.T @ gradient\\n return gradient @ self.w.T\",\n \"def _AffReluDrop_Backprop(self, dscores, cache):\\n grads = {}\\n loss = None\\n #Last Softmax Layer\\n ##Add L2 Regularization loss\\n loss = 0.5 * self.reg * np.sum(self.params['W{0}'.format(self.num_layers)]**2)\\n ##Calculate grads for last Affine\\n dhid, grads['W{0}'.format(self.num_layers)], grads['b{0}'.format(self.num_layers)] =\\\\\\n affine_backward(dscores, cache[-1])\\n grads['W{0}'.format(self.num_layers)] += self.reg * self.params['W{0}'.format(self.num_layers)]\\n\\n for i in range(self.num_layers-1, 0, -1): #hidden layers\\n thiscache = cache[i]\\n ##L2 Reg. loss\\n loss += 0.5 * self.reg * np.sum(self.params['W{0}'.format(i)]**2)\\n ##Calculate grads for [{affine-relu-drop} X (L-1)]\\n dhid = dropout_backward(dhid, thiscache['drop'])\\n dhid, grads['W{0}'.format(i)], grads['b{0}'.format(i)] = \\\\\\n affine_relu_backward(dhid, thiscache['affine_relu']) \\n grads['W{0}'.format(i)] += self.reg * self.params['W{0}'.format(i)]\\n\\n return grads, loss\",\n \"def backwardpass(self, grad):\\n return (self.x>0) * grad\",\n \"def compute_backsubstitution(self, length: int, dim: int, layer_gradient_manager=None):\\n if self.args.cpu:\\n self.lb = torch.zeros(length, dim)\\n else:\\n self.lb = torch.zeros(length, dim).cuda()\\n self.ub = self.lb.clone()\\n self.final_lw = self.final_uw = None\\n self.final_lb = self.final_ub = None\\n\\n original_layers = self.layers[:] # We keep a copy, because layers might get modified during the backsubstitution with jacobian\\n for layer in self.layers[::-1]:\\n if layer.lw is not None:\\n layer.backward(layer_gradient_manager)\\n # print(\\\"Controller has grad: \\\", self.lb.requires_grad)\\n self.layers = original_layers # We restore the original layers\",\n \"def update_relus(self):\\n def relu_backward_hook_function(module, grad_in, grad_out):\\n \\\"\\\"\\\"\\n If there is a negative gradient, change it to zero\\n \\\"\\\"\\\"\\n # Get last forward output\\n corresponding_forward_output = self.forward_relu_outputs[-1]\\n corresponding_forward_output[corresponding_forward_output > 0] = 1\\n modified_grad_out = corresponding_forward_output * torch.clamp(grad_in[0], min=0.0)\\n del self.forward_relu_outputs[-1] # Remove last forward output\\n return (modified_grad_out,)\\n\\n def relu_forward_hook_function(module, ten_in, ten_out):\\n \\\"\\\"\\\"\\n Store results of forward pass\\n \\\"\\\"\\\"\\n self.forward_relu_outputs.append(ten_out)\\n\\n # Loop through layers, hook up ReLUs\\n for pos, module in self.model.encoder._modules.items():\\n if isinstance(module, ReLU):\\n module.register_backward_hook(relu_backward_hook_function)\\n module.register_forward_hook(relu_forward_hook_function)\",\n \"def relu_backward(dA, Z):\\r\\n dZ = np.array(dA, copy=True)\\r\\n dZ[Z <= 0] = 0\\r\\n return dZ\",\n \"def backward(self, residuals):\\n in_channel, out_channel, kernel_size, a = self.weights.shape\\n dw = np.zeros_like(self.weights) \\n \\n for i in range(in_channel):\\n for o in range(out_channel):\\n dw[i, o] += inv_conv2(self.in_val[:,:,i], \\n residuals[:,:,o], \\n self.stride)\\n\\n self.db += residuals.sum(axis=1).sum(axis=0)\\n self.dw += dw \\n gradient_x = np.zeros_like(self.in_val)\\n \\n for i in range(in_channel):\\n for o in range(out_channel):\\n gradient_x[:,:,i] += conv_delta(residuals[:,:,o] \\n , self.weights[i][o]\\n , self.stride\\n , self.in_val.shape[0])\\n \\n return gradient_x\",\n \"def L_model_backward(AL, Y, caches):\\n grads = {}\\n dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))\\n L = len(caches)\\n cache = caches[L-1]\\n dA, dW, db = linear_activation_backward(dAL, cache, 'sigmoid')\\n grads['dA'+str(L)] = dAL\\n grads['dW'+str(L)] = dW\\n grads['db'+str(L)] = db\\n for i in range(L-2, -1, -1):\\n grads['dA' + str(i + 1)] = dA\\n cache = caches[i]\\n dA, dW, db = linear_activation_backward(dA, cache, 'relu')\\n grads['dW' + str(i + 1)] = dW\\n grads['db' + str(i + 1)] = db\\n return grads\",\n \"def backward(self, inGradient, lr=0.001): # batchSize = 1\\n wGradient = np.dot(inGradient.T, self.data)\\n bGradient = np.sum(inGradient, axis=0)\\n outGradient = np.dot(inGradient, self.weights)\\n\\n self.weights = self.weights - lr * wGradient\\n self.bias = self.bias - lr * bGradient\\n self.wGradient = wGradient\\n self.bGradient = bGradient\\n\\n #print \\\"weight gradient \\\", wGradient\\n #print \\\"bias gradient \\\", bGradient\\n\\n return outGradient\",\n \"def relu_backward(dA, cache):\\n\\n Z = cache\\n dZ = np.array(dA, copy=True) # just converting dz to a correct object.\\n\\n # When z <= 0, you should set dz to 0 as well.\\n dZ[Z <= 0] = 0\\n\\n assert (dZ.shape == Z.shape)\\n\\n return dZ\",\n \"def backward(self, accum_grad):\\n\\n W = self.W\\n\\n grad_w = self.layer_input.T.dot(accum_grad)\\n grad_b = np.sum(accum_grad, axis=0, keepdims=True)\\n\\n # Update the layer weights\\n self.W = self.W_optimizer.update(self.W, grad_w)\\n self.b = self.b_optimizer.update(self.b, grad_b)\\n\\n accum_grad = accum_grad.dot(W.T)\\n return accum_grad\",\n \"def backward_linear(Data):\\n\\n # data\\n graph = tf.Graph()\\n X = Data[0]\\n Y_ = Data[1]\\n\\n if X.shape[0] != Y_.shape[0]:\\n raise Exception(\\\"The quantity of Input X and Compare Y_ are not same!\\\")\\n\\n Loss = []\\n with graph.as_default():\\n print(\\\"This is the process of all the Dose!\\\")\\n print(\\\"There are %d data in this process.\\\" % X.shape[0])\\n print(\\\"Features of X: %d\\\" % X.shape[1])\\n print(\\\"Learning rate is: %f\\\" % learning_rate)\\n # Init all the parameters\\n global_step = tf.Variable(0, trainable=False)\\n\\n STEPS = int(Epoch * X.shape[0] / BATCH_SIZE) + 1\\n epoch = 0\\n\\n with tf.name_scope('inputs'):\\n x = tf.placeholder(tf.float32, [None, Forward.INPUT_NODE], name='x_Input')\\n y_ = tf.placeholder(tf.float32, [None, Forward.OUTPUT_NODE], name='y_Exact')\\n y = Forward.forward_linear(x, regularizer=None)\\n\\n # lost function\\n with tf.name_scope('loss'):\\n loss_mse = tf.reduce_mean(tf.square(y - y_))\\n loss = loss_mse + tf.add_n(tf.get_collection(\\\"losses\\\"))\\n tf.summary.scalar('loss', loss)\\n\\n # Todo\\n # LM algorithm\\n\\n # learning_rate = tf.train.exponential_decay(\\n # LEARNING_RATE_BASE,\\n # global_step,\\n # X.shape[0] / BATCH_SIZE,\\n # LEARNING_RATE_DECAY,\\n # staircase=True\\n # )\\n\\n with tf.name_scope('train'):\\n # train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step)\\n # train_step = tf.train.MomentumOptimizer(learning_rate, momentum=0.9).minimize(loss, global_step)\\n train_step = tf.train.AdamOptimizer(learning_rate, beta1=0.9, beta2=0.99).minimize(loss, global_step)\\n\\n # EMA algorithm\\n ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)\\n ema_op = ema.apply(tf.trainable_variables())\\n with tf.control_dependencies([train_step, ema_op]):\\n train_op = tf.no_op(name='train')\\n\\n # ready for storing the model\\n saver = tf.train.Saver()\\n\\n with tf.Session() as sess:\\n init_op = tf.global_variables_initializer()\\n sess.run(init_op)\\n\\n # Get the check point\\n ckpt = tf.train.get_checkpoint_state(MODEL_SAVE_PATH_LINEAR)\\n if ckpt and ckpt.model_checkpoint_path:\\n saver.restore(sess, ckpt.model_checkpoint_path)\\n\\n # begin multi threads\\n coord = tf.train.Coordinator()\\n threads = tf.train.start_queue_runners(sess, coord)\\n print(\\\"Begin the multi threads!\\\")\\n\\n # Graph\\n merged = tf.summary.merge_all()\\n writer = tf.summary.FileWriter(\\\"./logs_linear/\\\", sess.graph)\\n\\n # Training\\n for i in range(STEPS):\\n start = (i * BATCH_SIZE) % int(X.shape[0])\\n end = start + BATCH_SIZE\\n # if finish all the data\\n if end >= X.shape[0]:\\n end = X.shape[0]\\n\\n _, loss_value, step = sess.run([train_op, loss, global_step],\\n feed_dict={x: X[start:end], y_: Y_[start:end]})\\n\\n if i % 4000 == 0:\\n print(\\\"Steps are: %d , loss is: %g.\\\" % (step, loss_value))\\n rs = sess.run(merged, feed_dict={x: X[start:end], y_: Y_[start:end]})\\n writer.add_summary(rs, i)\\n saver.save(sess, os.path.join(MODEL_SAVE_PATH_LINEAR, MODEL_NAME), global_step)\\n\\n # a round\\n if end == X.shape[0]:\\n # get the results\\n epoch += 1\\n loss_total = sess.run(loss, feed_dict={x: X, y_: Y_})\\n\\n Loss.append(loss_total)\\n # Loss.append(loss_total*10000)\\n print(\\\"After %d epoch(s), steps are: %d, loss total is: %g.\\\\n\\\" % (epoch, step, loss_total))\\n saver.save(sess, os.path.join(MODEL_SAVE_PATH_LINEAR, MODEL_NAME), global_step)\\n\\n # close the multi threads\\n coord.request_stop()\\n coord.join(threads)\\n print(\\\"Close the multi threads!\\\")\\n\\n return Loss\",\n \"def _backward(self):\\n if self.units[0].value > 0:\\n self.units[0].gradient += 1 * self.utop.gradient\\n else:\\n self.units[0].gradient += 0 * self.utop.gradient\",\n \"def backward(last_layer: str) -> Callable:\\n\\n def closure() -> Tuple[Optional[torch.Tensor], torch.Tensor]:\\n optimizer.zero_grad()\\n output = model(data)\\n if last_layer == \\\"output\\\":\\n output.backward(torch.ones_like(target))\\n return None, output\\n elif last_layer == 'loss':\\n loss = compute_loss(output - target)\\n loss.backward()\\n return loss, output\\n else:\\n assert False, 'last layer must be \\\"output\\\" or \\\"loss\\\"'\\n\\n return closure\",\n \"def backward(last_layer: str) -> Callable:\\n\\n def closure() -> Tuple[Optional[torch.Tensor], torch.Tensor]:\\n optimizer.zero_grad()\\n output = model(data)\\n if last_layer == \\\"output\\\":\\n output.backward(torch.ones_like(target))\\n return None, output\\n elif last_layer == 'loss':\\n loss = compute_loss(output - target)\\n loss.backward()\\n return loss, output\\n else:\\n assert False, 'last layer must be \\\"output\\\" or \\\"loss\\\"'\\n\\n return closure\",\n \"def _backward(self, w=None):\\n grad = self.w # Should be I * self.w . We keep a vector for simplicity\\n\\n # Left multiply input `w` with normalizer gradient\\n return w * grad if w is not None else grad\",\n \"def lstm_backward(dh, cache):\\n dx, dh_prev, dWx, dWh, db = None, None, None, None, None\\n #############################################################################\\n # TODO: Implement the backward pass for an LSTM over an entire timeseries. #\\n # You should use the lstm_step_backward function that you just defined. #\\n #############################################################################\\n\\n N,T,H = dh.shape\\n tmp_x = cache[T-1][0]\\n D = tmp_x.shape[1]\\n # cache is a list of these values -- so cache[0] is\\n # x, i, f, o, g, prev_h, next_h, prev_c, next_c, Wx, Wh, b = cache\\n dnext_h = dh\\n\\n dx = np.zeros((N,T,D))\\n dh_prev = np.zeros((N,H))\\n dc_prev = np.zeros((N,H))\\n dWx = np.zeros((D,4*H))\\n dWh = np.zeros((H,4*H))\\n db = np.zeros((4*H))\\n\\n for t in reversed(range(0,T)):\\n # current gradient at timestep is the upstream gradient (provided as input)\\n # this may be coming from the Y as in the min_char_rnn.py (see line 59)\\n # + downstream gradient provided by rnn_step_backward.\\n dh_curr = dh[:,t,:] + dh_prev\\n dx_, dh_prev, dc_prev, dWx_, dWh_, db_ = lstm_step_backward(dh_curr, dc_prev, cache[t])\\n dWx += dWx_\\n dWh += dWh_\\n db += db_\\n dx[:,t,:]=dx_\\n\\n ##############################################################################\\n # END OF YOUR CODE #\\n ##############################################################################\\n\\n return dx, dh_prev, dWx, dWh, db\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6948249","0.6898323","0.6847992","0.6847992","0.68477255","0.68407637","0.68200904","0.6768128","0.67572653","0.67565167","0.67562467","0.6743265","0.67394495","0.6715497","0.67090523","0.67006433","0.669643","0.669643","0.66886026","0.6666757","0.6666757","0.6666757","0.6666757","0.6666757","0.6662765","0.6661605","0.66594064","0.66544884","0.6627915","0.66035134","0.659995","0.6598169","0.65858305","0.6579303","0.6578206","0.65727735","0.6553163","0.6548633","0.6527966","0.65267825","0.65242994","0.6520133","0.65135705","0.6510914","0.6510184","0.6510184","0.6510184","0.6510184","0.6505292","0.6505292","0.649698","0.64963186","0.64658123","0.6465052","0.64634526","0.6462556","0.64556193","0.6453911","0.64517903","0.64391357","0.6437774","0.64301956","0.6421929","0.64212763","0.64177644","0.64176023","0.64143","0.6399138","0.63959676","0.63959676","0.63911927","0.6368659","0.6368102","0.635871","0.6355901","0.63477826","0.63476133","0.634615","0.6344851","0.6343722","0.63311386","0.63297766","0.6312501","0.6310541","0.63068324","0.6301286","0.62973666","0.62858474","0.6280484","0.6277901","0.62773144","0.62753487","0.626755","0.62623227","0.6256771","0.62451947","0.62434393","0.62434393","0.62379026","0.62287706"],"string":"[\n \"0.6948249\",\n \"0.6898323\",\n \"0.6847992\",\n \"0.6847992\",\n \"0.68477255\",\n \"0.68407637\",\n \"0.68200904\",\n \"0.6768128\",\n \"0.67572653\",\n \"0.67565167\",\n \"0.67562467\",\n \"0.6743265\",\n \"0.67394495\",\n \"0.6715497\",\n \"0.67090523\",\n \"0.67006433\",\n \"0.669643\",\n \"0.669643\",\n \"0.66886026\",\n \"0.6666757\",\n \"0.6666757\",\n \"0.6666757\",\n \"0.6666757\",\n \"0.6666757\",\n \"0.6662765\",\n \"0.6661605\",\n \"0.66594064\",\n \"0.66544884\",\n \"0.6627915\",\n \"0.66035134\",\n \"0.659995\",\n \"0.6598169\",\n \"0.65858305\",\n \"0.6579303\",\n \"0.6578206\",\n \"0.65727735\",\n \"0.6553163\",\n \"0.6548633\",\n \"0.6527966\",\n \"0.65267825\",\n \"0.65242994\",\n \"0.6520133\",\n \"0.65135705\",\n \"0.6510914\",\n \"0.6510184\",\n \"0.6510184\",\n \"0.6510184\",\n \"0.6510184\",\n \"0.6505292\",\n \"0.6505292\",\n \"0.649698\",\n \"0.64963186\",\n \"0.64658123\",\n \"0.6465052\",\n \"0.64634526\",\n \"0.6462556\",\n \"0.64556193\",\n \"0.6453911\",\n \"0.64517903\",\n \"0.64391357\",\n \"0.6437774\",\n \"0.64301956\",\n \"0.6421929\",\n \"0.64212763\",\n \"0.64177644\",\n \"0.64176023\",\n \"0.64143\",\n \"0.6399138\",\n \"0.63959676\",\n \"0.63959676\",\n \"0.63911927\",\n \"0.6368659\",\n \"0.6368102\",\n \"0.635871\",\n \"0.6355901\",\n \"0.63477826\",\n \"0.63476133\",\n \"0.634615\",\n \"0.6344851\",\n \"0.6343722\",\n \"0.63311386\",\n \"0.63297766\",\n \"0.6312501\",\n \"0.6310541\",\n \"0.63068324\",\n \"0.6301286\",\n \"0.62973666\",\n \"0.62858474\",\n \"0.6280484\",\n \"0.6277901\",\n \"0.62773144\",\n \"0.62753487\",\n \"0.626755\",\n \"0.62623227\",\n \"0.6256771\",\n \"0.62451947\",\n \"0.62434393\",\n \"0.62434393\",\n \"0.62379026\",\n \"0.62287706\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70406467"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":12196,"cells":{"query":{"kind":"string","value":"Train Linear Regression using stochastic gradient descent."},"document":{"kind":"string","value":"def train(self, X, y, learning_rate=1e-3, lambda_reg=0.0, num_iters=100, std_dev=1e-2,\n batch_size=200, verbose=False, one_step=False):\n num_train, dim = X.shape\n self.initialize_weights(dim, std_dev)\n\n loss_history = []\n for it in range(num_iters):\n\n loss, grads = self.train_step(X, y, learning_rate, lambda_reg, batch_size)\n\n if it % 100 == 0:\n loss_history.append(np.squeeze(loss))\n\n if verbose and it % 100 == 0:\n print('iteration %d / %d: loss %f' % (it, num_iters, loss))\n\n return loss_history"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def train(self, loss_function='logistic',\n lr=0.1, decay=0.5, max_iters=3000, batch_size=128, **kwargs):\n return super(LogisticRegression, self).train('sgd', loss_function,\n lr=lr,\n decay=decay, max_iters=max_iters,\n batch_size=batch_size, **kwargs)","def train(self,features,y):\r\n \r\n if self.learn_type == \"nn\":\r\n #generate supervised dataset\r\n return(self.learner.train_on_batch(features,y))\r\n elif self.learn_type == \"linear\":\r\n grad = 0\r\n n = len(features)\r\n for i in range(n):\r\n #sum over the instances to get an estimate of the gradient\r\n print((y[i] - self.learner.activate(features[i])))\r\n grad -= (y[i] - self.learner.activate(features[i])) * \\\r\n self.learner.grad(features[i])\r\n grad /= n\r\n #update paramter\r\n param = np.copy(self.learner.param)\r\n self.learner.param = param - self.alpha * grad\r\n #print(self.learner.param)\r","def train_model(X_train, y_train):\n rgs = linear_model.Lasso(alpha=0.1)\n rgs.fit(X_train, y_train)\n return rgs","def run_linear_regression(data_x, data_y):\n iteration_s = 100\n alpha = 0.0001550\n\n no_features = data_x.shape[1]\n len_data = data_x.shape[0]\n print(\"no_feature :, len_data: \", no_features , len_data)\n #intinilize the the\n theta = np.zeros(no_features)\n #iterations how many time do\n for i in range(0,iteration_s):\n theta = run_steep_gradient_descent(data_x, data_y, len_data, alpha, theta)\n error = sum_of_square_error(data_x, data_y, len_data, theta)\n print(\"at iteration %d - Error is %.5f \" % (i+1, error))\n print(\"theta shape\", theta.shape)\n return theta","def train_gradient_descent(self, X, y, learning_rate=0.01, n_iters=100):\r\n # Step 0: Initialize the parameters\r\n n_samples, n_features = X.shape\r\n self.weights = np.zeros(shape=(n_features,1))\r\n self.bias = 0\r\n costs = []\r\n\r\n for i in range(n_iters):\r\n # Step 1: Compute a linear combination of the input features and weights\r\n y_predict = np.dot(X, self.weights) + self.bias\r\n\r\n # Step 2: Compute cost over training set\r\n cost = (1 / n_samples) * np.sum((y_predict - y)**2)\r\n costs.append(cost)\r\n\r\n if i % 100 == 0:\r\n print(f\"Cost at iteration {i}: {cost}\")\r\n\r\n # Step 3: Compute the gradients\r\n dJ_dw = (2 / n_samples) * np.dot(X.T, (y_predict - y))\r\n dJ_db = (2 / n_samples) * np.sum((y_predict - y)) \r\n \r\n # Step 4: Update the parameters\r\n self.weights = self.weights - learning_rate * dJ_dw\r\n self.bias = self.bias - learning_rate * dJ_db\r\n\r\n return self.weights, self.bias, costs","def LSTM_train(X_train, Y_train, X_dev, Y_dev, R_train, R_dev, hyperparams):","def train(self, X, y, learning_rate=1e-3, reg=1e-5, num_iters=100,\n batch_size=200, verbose=False):\n num_train, dim = X.shape\n num_classes = np.max(y) + 1 # assume y takes values 0...K-1 where K is number of classes\n if self.W is None:\n self.W = np.random.randn(dim, num_classes) * 0.001\n\n # Run stochastic gradient descent to optimize W\n loss_history = []\n for it in xrange(num_iters):\n batch_ind = np.random.choice(X.shape[0],batch_size, replace=True)\n X_batch = X[batch_ind]\n y_batch = y[batch_ind]\n\n # Step One: Implement Stochastic\n #########################################################################\n # Sample batch_size elements from the training data and their #\n # corresponding labels to use in this round of gradient descent. #\n # Store the data in X_batch and their corresponding labels in #\n # y_batch; after sampling X_batch should have shape (batch_size, dim) #\n # and y_batch should have shape (batch_size,) #\n # #\n # Hint: Use np.random.choice to generate indices. Sampling with #\n # replacement is faster than sampling without replacement. #\n #########################################################################\n\n # Step Two: Implement Gradient\n # Simply call self.loss (which calls svm_loss_vectorized) to evaluate loss and gradient\n loss, dW = self.loss(X_batch,y_batch,reg)\n loss_history.append(loss)\n\n # Step Three: Implement Descent\n # Simply update the weights using the gradient and the learning rate. #\n self.W -= dW*learning_rate\n\n if verbose and it % 100 == 0:\n print('iteration %d / %d: loss %f' % (it, num_iters, loss))\n\n return loss_history","def train(self, X_, y, reg=1e-4, lr=0.1, epochs=5, batch_size=16):\n\n X = np.c_[np.ones(X_.shape[0]), X_] # Add one for bias to the first columns\n ### YOUR CODE HERE\n self.w = log_reg.mini_batch_grad_descent(X, y, reg=reg, lr=lr, batch_size=batch_size, epochs= epochs)\n assert self.w.shape[0] == X.shape[1]\n ### END CODE","def LinReg_fit(X, y, X_test=None, y_test=None, lr=1e-7, batch=1, lamb=0,\n epoch=10000, print_every=100, lamb1=0, momentum=0):\n # initialize\n W = np.random.randn(X.shape[1]) / X.shape[1] / X.shape[0]\n\n train_loss = []\n train_RMSE = []\n test_loss = []\n test_RMSE = []\n\n # batch size indicator\n b = 0\n # cache for adagrad\n G = np.zeros(W.shape)\n\n for i in range(epoch):\n inds = []\n last_step = 0\n\n for j in np.random.permutation(X.shape[0]):\n inds.append(j)\n b += 1\n\n # do the adagrad to update the parameter\n if b >= batch:\n diff = X[inds].dot(W) - y[inds]\n\n # calculate gradients\n w = np.array(W)\n w[w > 0] = 1\n w[w < 0] = -1\n grad_X = X[inds].T.dot(diff)\n grad_regulariz = lamb * W * batch / X.shape[0]\n grad_first_order_reg = lamb1 * w * batch / X.shape[0]\n grad = grad_X + grad_regulariz + grad_first_order_reg\n\n # calculate update step\n G += grad**2\n delta_W = (grad + momentum * last_step) / np.sqrt(G)\n W -= lr * delta_W\n\n # reset variables\n last_step = delta_W\n b = 0\n inds = []\n\n objective = (((X.dot(W) - y)**2).sum() + lamb * (W**2).sum()) / 2.0\n RMSE = cal_RMSE(X, W, y)\n\n if X_test is not None and y_test is not None:\n # losses\n loss_X = ((X_test.dot(W) - y_test)**2).sum() / 2.0\n loss_reg = lamb * (W**2).sum() / 2.0\n loss_first_reg = lamb1 * (abs(W).sum())\n\n obj_t = loss_X + loss_reg + loss_first_reg\n RMSE_t = cal_RMSE(X_test, W, y_test)\n\n test_loss.append(obj_t)\n test_RMSE.append(RMSE_t)\n\n # print out the progress\n if i % print_every == 0:\n if X_test is not None and y_test is not None:\n print('\\tepoch: %d; obj: %.4f; RMSE: %.4f; RMSE_test: %.4f' %\n (i, objective, RMSE, RMSE_t))\n else:\n print('\\tepoch: %d; obj: %.4f; RMSE: %.4f' %\n (i, objective, RMSE))\n\n train_loss.append(objective)\n train_RMSE.append(RMSE)\n\n print('final obj: %.4f' % train_loss[-1])\n\n return W, train_loss, train_RMSE, test_loss, test_RMSE","def train_lr(x, y, lamb):\n \n # TODO: implement the function.\n # initialize parameters w and b\n w = tf.Variable([0.0])\n b = tf.Variable(0.0)\n\n # set an optimizer\n # please check the documentation of tf.keras.optimizers.SGD\n optim = tf.keras.optimizers.SGD(learning_rate = 0.001)\n\n # loop to optimize w and b \n for i in range(1000):\n\n with tf.GradientTape() as gt:\n gt.watch([w, b])\n y_hat = regression_func(x, w, b)\n loss = loss_func(y, y_hat)\n\n dw, db = gt.gradient(loss, [w,b])\n\n del gt\n\n optim.apply_gradients(zip([dw,db],[w,b]))\n\n\n return w, b","def _stochastic_gradient_descent(self, X, y, lr, epochs, sample_rate):\n\n # Initialize the bias and weights.\n m, n = X.shape\n self.bias = 0\n self.weights = np.random.normal(size=n)\n\n n_sample = int(m * sample_rate)\n for i in range(epochs):\n for idx in choice(range(m), n_sample, replace=False):\n # Calculate the gradient delta of each sample\n grad_bias, grad_weights = self._get_gradient(X[idx], y[idx])\n\n # Update the bias and weight by gradient of current sample\n self.bias += lr * grad_bias\n self.weights += lr * grad_weights\n\n # Show the gradient of each epoch.\n grad_bias, grad_weights = self._get_gradient(X, y)\n grad = (grad_bias + grad_weights.mean()) / 2\n print(\"Epochs %d gradient %.3f\" % (i + 1, grad), flush=True)","def train(self, X, y, learning_rate=1e-3, reg=1e-5, num_iters=100,\n batch_size=200, verbose=False):\n num_train, dim = X.shape\n num_classes = np.max(y) + 1 # assume y takes values 0...K-1 where K is number of classes\n if self.W is None:\n # lazily initialize W\n self.W = 0.001 * np.random.randn(dim, num_classes)\n\n # Run stochastic gradient descent to optimize W\n loss_history = []\n for it in range(num_iters):\n X_batch = None\n y_batch = None\n\n #########################################################################\n # TODO: #\n # Sample batch_size elements from the training data and their #\n # corresponding labels to use in this round of gradient descent. #\n # Store the data in X_batch and their corresponding labels in #\n # y_batch; after sampling X_batch should have shape (batch_size, dim) #\n # and y_batch should have shape (batch_size,) #\n # #\n # Hint: Use np.random.choice to generate indices. Sampling with #\n # replacement is faster than sampling without replacement. #\n #########################################################################\n choices = np.random.choice(num_train, batch_size)\n X_batch = X[choices]\n y_batch = y[choices]\n #########################################################################\n # END OF YOUR CODE #\n #########################################################################\n\n # evaluate loss and gradient\n loss, grad = self.loss(X_batch, y_batch, reg)\n loss_history.append(loss)\n\n # perform parameter update\n #########################################################################\n # TODO: #\n # Update the weights using the gradient and the learning rate. #\n #########################################################################\n self.W -= learning_rate * grad\n #########################################################################\n # END OF YOUR CODE #\n #########################################################################\n\n if verbose and it % 100 == 0:\n print('iteration %d / %d: loss %f' % (it, num_iters, loss))\n\n return loss_history","def train(self, x, y, lr):\n self.forward(x)\n self.backward(y)\n self.update(lr)\n return","def fit(self, X, y, max_iter=MAX_ITER):\n X = self.normalize_data(X)\n X = self.add_bias(X)\n n_tasks = len(X)\n n_feats = X[0].shape[1]\n W = np.random.randn(n_feats, n_tasks)\n start = time.time()\n cost_function = 0\n for t in range(n_tasks):\n #print('Training {} task with lasso regression'.format(t))\n lasso = Lasso(alpha=self.lambda_1, positive=self.positive, max_iter=max_iter)\n lasso.fit(X[t], y[t])\n W[:, t] = lasso.coef_\n cost_function += np.linalg.norm(np.dot(X[t], W[:, t]) - y[t]) \\\n + sum(abs(W[:, t]))\n stop = time.time() - start\n self.W = W\n return W, np.array([cost_function]), stop","def train(self):\n df = self.df\n self.scaler = MinMaxScaler()\n self.scaler.fit(df)\n df[df.columns] = self.scaler.transform(df)\n\n\n X_train, y_train = get_X_y(df, self.n_days, self.length , self.style)\n\n self.model = lstm_model(self.length, self.n_days, self.features, self.style)\n\n #es = EarlyStopping(monitor = 'accuracy',mode = 'min' , verbose = 1, patience = 100, restore_best_weights = True)\n\n self.history = self.model.fit(np.array(X_train), np.array(y_train),\n #validation_split = 0.3,\n #callbacks = [es],\n epochs = 200,\n batch_size = 64,\n shuffle = True,\n verbose = True)","def fit(self, X, y, alpha, n_epochs):\n y = self.__one_hot(y)\n \n # perform training epochs\n for i in range(n_epochs):\n print(\"Epoch\", i)\n # stochastic gradient descent\n for j in range(len(X)):\n self.__backpropagation(X[j], y[j], alpha)","def train(self):\n df = self.df\n self.scaler = MinMaxScaler()\n self.scaler.fit(df)\n df[df.columns] = self.scaler.transform(df)\n\n\n X_train, y_train = get_X_y(df, self.n_days, self.length , self.style)\n X_train = np.array(X_train)\n X_train.shape = (X_train.shape[0], X_train.shape[2])\n\n self.clf = LogisticRegression().fit(X_train, y_train)\n\n #es = EarlyStopping(monitor = 'accuracy',mode = 'min' , verbose = 1, patience = 100, restore_best_weights = True)","def fit(self, X, y, max_iter=MAX_ITER):\n X = self.normalize_data(X)\n X = self.add_bias(X)\n n_tasks = len(X)\n n_feats = X[0].shape[1]\n W = np.random.randn(n_feats, n_tasks)\n start = time.time()\n cost_function = 0\n for t in range(n_tasks):\n #print('Training {} task with lasso regression'.format(t))\n lasso = LogisticRegression(C=self.lambda_1,\n penalty='l1',\n max_iter=max_iter)\n lasso.fit(X[t], y[t])\n W[:, t] = lasso.coef_\n stop = time.time() - start\n self.W = W\n return W, np.array([cost_function]), stop","def trainLogRegres(train_x, train_y, opts):\n startTime = time.time() # calculate training time\n\n numSamples, numFeatures = np.shape(train_x)\n alpha = opts['alpha']\n maxIter = opts['maxIter']\n weights = np.ones((numFeatures, 1))\n\n for k in range(maxIter):\n if opts['optimizeType'] == 'stocGradDescent': # stochastic gradient descent\n for i in range(numSamples):\n output = sigmoid(train_x[i, :] * weights)\n loss = train_y[i, 0] - output\n weights = weights + alpha * train_x[i, :].transpose() * loss\n elif opts[\n 'optimizeType'] == 'smoothStocGradDescent': # smooth stochastic gradient descent. randomly select samples to optimize for reducing cycle fluctuations.\n dataIndex = list(range(numSamples))\n for i in range(numSamples):\n alpha = 4.0 / (1.0 + k + i) + 0.01\n randIndex = int(np.random.uniform(0, len(dataIndex)))\n output = sigmoid(train_x[randIndex, :] * weights)\n loss = train_y[randIndex, 0] - output\n weights = weights + alpha * train_x[randIndex, :].transpose() * loss\n del (dataIndex[randIndex])\n print('Congratulations, training complete! Took %fs!' % (time.time() - startTime))\n return weights","def train(self, X, y):\n m,d = X.shape\n D = np.array([1/m] * m)\n for t in range(self.T):\n self.h[t] = self.WL(D,X,y)\n h_t = self.h[t].predict(X)\n epsilon_t = np.sum(np.logical_not(y==h_t) * D)\n self.w[t] = 0.5 * np.log((1/epsilon_t) - 1)\n n = np.sum([D * np.exp(-1 * self.w[t] * y * h_t)])\n D = (D * np.exp(-1 * self.w[t] * y * h_t)) / n","def train_step(x, y):\n with tf.GradientTape() as tape:\n predictions = self.model(x)\n loss = self.loss_object(y, predictions)\n gradients = tape.gradient(loss, self.model.trainable_variables)\n self.optimizer.apply_gradients(zip(gradients, self.model.trainable_variables))\n\n self.train_loss(loss)\n self.train_acc(y, predictions)","def fit(self, X, y):\n # Make sure inputs are numpy arrays.\n X = np.array(X)\n y = np.array(y)\n # Add x_0 = 1 to each instance for the bias term.\n X = np.c_[np.ones((X.shape[0], 1)), X]\n # Store number of samples and features in variables.\n n_samples, n_features = np.shape(X)\n self.training_errors = []\n # Initialize weights randomly from normal distribution.\n self.coef_ = np.random.randn(n_features, 1)\n # Batch gradient descent for number iterations = n_iter.\n for _ in range(self.n_iter):\n y_preds = X.dot(self.coef_)\n # Penalty term if regularized (don't include bias term).\n regularization = self.regularization(self.coef_[1:])\n # Calculate mse + penalty term if regularized.\n cost_function = mean_squared_error(y, y_preds) + regularization\n if cost_function > self.threshold:\n break\n self.training_errors.append(cost_function) \n # Regularization term of gradients (don't include bias term).\n gradient_reg = self.regularization.grad(self.coef_[1:])\n # Gradients of loss function.\n gradients = (2/n_samples) * X.T.dot(y_preds - y)\n gradients += gradient_reg\n # Update the weights.\n self.coef_ -= (self.lr * gradients.sum(axis=1)).reshape(-1, 1)\n\n return self","def fit(self, x, y):\n def initiate_theta(dim):\n self.theta = np.zeros(dim)\n # print('self.theta initiated is {}'.format(self.theta))\n \n def implement_sigmoid(x):\n if self.theta is None:\n initiate_theta(x.shape[1])\n z = np.matmul(np.transpose(self.theta), np.transpose(x))\n return 1/(np.ones(x.shape[0]) + np.exp(-z))\n \n def implement_partial_loss(x, y):\n return -np.matmul(np.transpose(y - implement_sigmoid(x)), x)/x.shape[0]\n \n def implement_transposed_hess(x):\n sigmoid_hadamard = implement_sigmoid(x) * (np.ones(x.shape[0]) - implement_sigmoid(x))\n hess2 = np.diag(sigmoid_hadamard)\n hess = np.matmul(hess2,x)\n hess = np.matmul(np.transpose(x),hess)/x.shape[0]\n hess_inverse = np.linalg.inv(hess)\n return hess_inverse\n \n def train(x, y):\n count = 0\n if self.theta is None:\n initiate_theta(x.shape[1])\n while count < self.max_iter:\n if self.verbose:\n loss_y1 = np.matmul(np.transpose(y), np.log(implement_sigmoid(x)))\n loss_y0 = np.matmul(np.transpose(np.ones(x.shape[0]) - y), np.log(np.ones(x.shape[0]) - implement_sigmoid(x)))\n loss = -(loss_y1 + loss_y0 )/x.shape[0]\n print('Average empirical loss for step {} is {}'.format(count, loss))\n delta = np.matmul(implement_transposed_hess(x), implement_partial_loss(x, y))\n new_theta = self.theta - delta * self.step_size\n delta_theta = np.linalg.norm(new_theta - self.theta)\n # print('delta is {}'.format(delta_theta))\n if delta_theta < self.eps:\n return new_theta\n else:\n self.theta = new_theta\n count += 1\n return self.theta\n \n return train(x, y)","def train_LR(self, X, y, eta=1e-3, batch_size=1, num_iters=1000) :\n loss_history = []\n N,d = X.shape\n for t in np.arange(num_iters):\n X_batch = None\n y_batch = None\n # ================================================================ #\n # YOUR CODE HERE:\n # Sample batch_size elements from the training data for use in gradient descent. \n # After sampling, X_batch should have shape: (batch_size,1), y_batch should have shape: (batch_size,)\n # The indices should be randomly generated to reduce correlations in the dataset. \n # Use np.random.choice. It is better to user WITHOUT replacement.\n # ================================================================ #\n \n # sample indices without replacement\n batch_idx = np.random.choice(N, batch_size, replace = False)\n X_batch = X[batch_idx]\n y_batch = y[batch_idx]\n \n \n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n loss = 0.0\n grad = np.zeros_like(self.w)\n # ================================================================ #\n # YOUR CODE HERE: \n # evaluate loss and gradient for batch data\n # save loss as loss and gradient as grad\n # update the weights self.w\n # ================================================================ #\n \n # compute the loss and gradient\n # loss_and_grad will take responsible for these\n \n loss, grad = self.loss_and_grad(X_batch, y_batch)\n \n self.w = self.w - eta * grad\n \n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n loss_history.append(loss)\n return loss_history, self.w","def train(self, X_, y, reg=1e-4, lr=0.1, epochs=5, batch_size=16):\n # set up classes and make y into a matrix 1 in k encoded\n self.classes = np.sort(np.unique(y))\n num_classes = self.classes.size\n y_as_matrix = np.zeros((y.size, num_classes))\n y_as_matrix[np.arange(y.shape[0]), y] = 1\n X = np.c_[np.ones(X_.shape[0]), X_] # add bias variable 1\n ### YOUR CODE HERE\n self.w = soft_reg.mini_batch_grad_descent(X, y_as_matrix, reg=reg, lr=lr, epochs=epochs, batch_size=batch_size)\n ### END CODE","def _gradient_descent(self, X, y, epochs, learning_rate, batch_size):\n num_feats = X.shape[1]\n num_samples = X.shape[0]\n\n y = y.reshape(num_samples, 1)\n W = np.random.rand(num_feats, 1)\n training_loss_epochs = []\n\n for ix in range(epochs):\n shuffled_ix = (np.arange(0, len(X)))\n np.random.shuffle(shuffled_ix)\n X = X[shuffled_ix, :]\n y = y[shuffled_ix, :]\n\n for batch_ix in np.arange(0, X.shape[0], batch_size):\n dW = self._compute_gradient(W, X[batch_ix:batch_ix + batch_size], y[batch_ix:batch_ix + batch_size])\n W -= learning_rate * dW\n\n if ix % 10 == 0:\n y_pred = np.dot(X, W)\n training_loss = self.mse(y, y_pred)\n print('epoch {0} : training loss {1}'.format(ix, training_loss))\n training_loss_epochs.append(training_loss[0])\n\n self.weights = W\n self.training_loss = training_loss_epochs\n return None","def linearRegression(self, xtr, ytr, xte, yte):\n LEARNING_RATE = 0.5\n with self.graph.as_default() as graph:\n with tf.name_scope('training'):\n with tf.name_scope('loss'):\n train_loss = tf.reduce_mean(\n tf.square(self.y_train - self.y_placeholder))\n with tf.name_scope('optimizer'):\n optimizer = tf.train.GradientDescentOptimizer(LEARNING_RATE)\n train = optimizer.minimize(train_loss) \n # test loss may be different\n with tf.name_scope('test'):\n with tf.name_scope('loss'):\n test_loss = tf.reduce_mean(\n tf.square(self.y_test - self.y_placeholder))\n with tf.Session() as sess:\n # Save the variables to disk.\n model_dir = \"./ckpt/\"\n builder = tf.saved_model.builder.SavedModelBuilder(model_dir)\n\n # Initialize variables\n sess.run(tf.global_variables_initializer())\n TRAIN_STEPS = 201\n\n for step in range(TRAIN_STEPS):\n sess.run([train], \n feed_dict={self.x_placeholder: xtr, \n self.y_placeholder: ytr})\n if step % 20 == 0:\n test_loss_val = sess.run([test_loss],\n feed_dict={self.x_placeholder: xte, \n self.y_placeholder: yte})\n print('step {}, test loss is {}'.format(\n step, test_loss_val))\n\n # Final training results\n a = sess.run(self.a)\n b = sess.run(self.b)\n # Draw result\n minx=np.min(np.concatenate((xtr,xte)))\n maxx=np.max(np.concatenate((xtr,xte)))\n xref=np.linspace(minx,maxx,100)\n plt.figure(0)\n plt.plot(xref, a*xref+b, 'r.')\n plt.plot(xtr, ytr, 'b.')\n plt.plot(xte, yte, 'g.')\n plt.show()","def gradient_descent(self, x, y):\n # Initialize weights vector\n self.weights = np.zeros(len(x[0]))\n\n # Storing number of training example in a variable \n n = len(x)\n\n # Initiate variables to keep track of the current and smallest loss recorded\n lowest_loss = sys.float_info.max\n current_loss = sys.float_info.max\n\n # Initiate variables to keep track of step sizes\n norm = sys.float_info.max\n smallest_norm = sys.float_info.max\n\n # Initiate list variable that stores all previous weights\n prev_weights = []\n\n # Initiate list that stores all the errors. \n errors = []\n \n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\n k_loss_iteration = 1\n\n # Learning loop\n for i in range(self.max_iter):\n\n # Append current weights\n prev_weights.append(np.array(self.weights))\n \n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\n\n # Compute the error of the Cost Function and store it in a list\n current_loss = self.cost(x,y)\n\n if len(errors) > 1 and current_loss > errors[-1]:\n k_loss_iteration += 1\n else: \n k_loss_iteration = 1\n\n errors.append(current_loss)\n \n # Track smallest loss\n if current_loss < lowest_loss:\n lowest_loss = current_loss\n\n # Compute the L2 Norm of the difference between current weights and previous weights\n norm = np.linalg.norm(self.weights - prev_weights[-1])\n\n # Track smallest step size and set it as error threshold\n if norm < smallest_norm:\n smallest_norm = norm\n\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\n if self.error_threshold != None and norm < self.error_threshold:\n print(\"Converged after {} iterations!\".format(i))\n break\n\n # stop if error hasn't gone down in k iterations\n if k_loss_iteration >= 10:\n print(k_loss_iteration + \" iterations of loss not decreasing on {}th itertion.\".format(i))\n break\n\n # Log final weights\n print(\"Final norm: \" + str(norm) + \"\\nSmallest step size recorded: \" + str(smallest_norm) + \"\\nFinal error: \" + str(current_loss) + \"\\nLowest error recorded: \" + str(lowest_loss) + \"\\nNumber of epochs: \" + str(len(errors)) + \"\\nFinal weights: \" + str(self.weights))","def train(self, X, y, learning_rate=1e-3, num_iters=100,\n batch_size=200, verbose=False):\n num_train, dim = X.shape\n num_classes = np.max(y) + 1 # assume y takes values 0...K-1 where K is number of classes\n\n self.init_weights(dims=[np.max(y) + 1, X.shape[1]])\t# initializes the weights of self.W\n\n # Run stochastic gradient descent to optimize W\n loss_history = []\n\n for it in np.arange(num_iters):\n X_batch = None\n y_batch = None\n\n # ================================================================ #\n # YOUR CODE HERE:\n # Sample batch_size elements from the training data for use in \n # gradient descent. After sampling,\n # - X_batch should have shape: (dim, batch_size)\n # - y_batch should have shape: (batch_size,)\n # The indices should be randomly generated to reduce correlations\n # in the dataset. Use np.random.choice. It's okay to sample with\n # replacement.\n # ================================================================ #\n mask = np.random.choice(num_train, batch_size, replace=True)\n \n X_batch = X[mask] # (dim, batch_size)\n y_batch = y[mask] # (batch_size,)\n \n pass\n \n \n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n\n # evaluate loss and gradient\n loss, grad = self.fast_loss_and_grad(X_batch, y_batch)\n loss_history.append(loss)\n\n # ================================================================ #\n # YOUR CODE HERE:\n # Update the parameters, self.W, with a gradient step \n # ================================================================ #\n pass\n \n self.W = self.W - learning_rate*grad\n \n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n\n if verbose and it % 100 == 0:\n print('iteration {} / {}: loss {}'.format(it, num_iters, loss))\n\n return loss_history","def fit(self, X, y):\n\t\t# TODO insert stack of 1 for bias\n\t\tX = np.insert(X, 0, 1, axis=1)\n\t\tself.errors = []\n\t\tself.initialize_weights(n_features=X.shape[1])\n\t\t\n\t\t# TODO gradient descent for n_iter\n\t\tfor _ in range(self.n_iter):\n\t\t\ty_pred = X.dot(self.weights)\n\t\t\t# calculate l2 loss\n\t\t\tmse = np.mean(0.5 * (y - y_pred)**2 + self.regularization(self.weights))\n\t\t\tself.errors.append(mse)\n\t\t\t# calucalte gradiant of loss function w.r.t weights\n\t\t\tgrad_weights = -(y - y_pred).dot(X) + self.regularization.grad(self.weights)\n\t\t\t# weight updation\n\t\t\tself.weights -= self.lr * grad_weights","def learn(self, Xtrain, ytrain):\n self.cost_data = []\n self.weights = np.zeros((len(self.params['features']), 1))\n numsamples = Xtrain.shape[0]\n Xless = Xtrain[:,self.params['features']]\n y = ytrain[:, np.newaxis]\n\n cur_cost = float(\"inf\")\n tolerance = 10 ** -6\n new_cost = self.cost(self.weights, Xless, y, self.params['regwgt'], numsamples)\n while abs(new_cost - cur_cost) > tolerance:\n cur_cost = new_cost\n gradient = np.dot(np.transpose(Xless), np.subtract(np.dot(Xless, self.weights), y)) / numsamples #+ (2 * self.params['regwgt'] * self.weights)\n step_size = self.line_search(self.weights, new_cost, gradient, Xless, y, self.params['regwgt'], numsamples)\n self.weights = self.weights - (step_size * gradient)\n new_cost = self.cost(self.weights, Xless, y, self.params['regwgt'], numsamples)\n\n #Format properly for the error function\n self.weights = np.ndarray.flatten(self.weights)","def learn(self, Xtrain, ytrain):\n self.cost_data = []\n self.weights = np.zeros((len(self.params['features']), 1))\n numsamples = Xtrain.shape[0]\n Xless = Xtrain[:,self.params['features']]\n y = ytrain[:, np.newaxis]\n epochs = 1000\n\n for epoch in range(epochs):\n #Shuffle the data, making sure to maintain the proper correspondence between the features and targets\n data_set = np.append(Xless, y, axis=1)\n np.random.shuffle(data_set)\n Xless = data_set[:, 0:data_set.shape[1] - 1]\n y = data_set[:, -1, np.newaxis]\n for t in range(numsamples):\n gradient = np.dot(np.transpose(Xless[t, :][np.newaxis, :]), np.subtract(np.dot(Xless[t, :], self.weights), y[t, np.newaxis]))\n step_size = 0.01 / (epoch + 1)\n self.weights = self.weights - (step_size * gradient)\n cur_cost = self.cost(self.weights, Xless[t, :], y[t])\n #Format the array properly for the error function\n self.weights = np.ndarray.flatten(self.weights)","def train(self, iterations = 100):\n arguments = ()\n print(\"training...\")\n results = optimize.minimize(self.CostFunction,x0 = self.Thetas, args = arguments, options = {'disp':True, 'maxiter': iterations}, method = \"L-BFGS-B\", jac = True)\n self.Thetas = results['x']\n FinalCost, _ = self.CostFunction(self.Thetas)\n print(\"successfully trained the model\") \n print(\"Final Cost for this model is:\", FinalCost)","def train(self, X, y):\n m = X.shape[0]\n D = np.empty(m)\n D.fill(1/(m*1.0))\n\n hs = 0\n for t in range(self.T):\n self.h[t] = self.WL(D,X,y)\n eps = 0\n\n for j in range(m): \n if (y[j]*(1.0) != self.h[t].predict(X)[j]):\n eps+=D[j]\n\n self.w[t] =0.5*math.log((1/eps)-1)\n\n Dtmp = []\n for j in range(m):\n Dtmp.append(D[j]*math.exp(-1*self.w[t]*y[j]*(self.h[t].predict(X)[j])))\n\n Dtmp = np.array(Dtmp) \n s = np.sum(Dtmp)\n\n for i in range(m):\n D[i] = (D[i]*math.exp(-1*self.w[t]*y[i]*self.h[t].predict(X)[i]))/s","def train(self, x, y):\n try:\n t_start = time.time()\n self.managerlogger.logger.info(\"start lr..\")\n self._model.fit(x, y)\n self.managerlogger.logger.info(\"finished lr!\")\n t_end = time.time()\n self.managerlogger.logger.info(\"lr train time: %s\" % (t_end - t_start))\n return runstatus.RunStatus.SUCC\n except Exception as err:\n self.managerlogger.logger.error(\"lr train error: %s \" % err)\n self.errorlogger.logger.error(\"lr train error:\\n %s \" % traceback.format_exc())\n return runstatus.RunStatus.FAILED","def train_model(self):\r\n alpha, accuracy_rate = self.select_model()\r\n # Initialize logistic regression with alpha(learning rate)\r\n lg = logisticregression(C=alpha)\r\n # Train the model.\r\n lg.fit(self.training_data, self.target_data)\r\n # Save the trained model as .pkl file.\r\n joblib.dump(value=lg, filename=self.intention_id+'.pkl', compress=1)\r\n print \"Estimated Parameters of Logistic Regression\"\r\n # Estimated parameters of logistic regression.\r\n print lg.get_params()","def fit(self, x, y):\n # Note Logistic Regression Runtime\n start_time = time.time()\n\n # Converting Pandas DataFrame to Numpy arrays\n if not type(x).__module__ == np.__name__:\n x = x.to_numpy()\n if not type(y).__module__ == np.__name__:\n y = y.to_numpy()\n\n # Insert a column of 1 in the feature vector X for the bias term in the weights\n x = np.insert(x,0,1,axis=1)\n \n # Verify dimension of input\n if len(x) != len(y):\n print(\"The number of input features vector must be to be the same as the number of target variables\")\n else:\n losses = self.gradient_descent(x,y)\n\n # Note end time\n end_time = time.time()\n\n # Log runtime\n print(\"Logistic Regression training time: {0:.2f}s\".format(end_time - start_time))\n \n return losses","def fit(self, X, y):\n\n n, m = X.shape[0], X.shape[1]\n\n # theta is (nx1) (one theta per dimension)\n self.theta = np.random.uniform(-10, 10, (n, 1))\n\n for i in range(self.epochs):\n # Get predictions\n y_pred = self.predict(X)\n\n # calculate cost\n # cost = ...\n cost = self._cost_function(y_pred, y, m)\n \n\n # gradient is an (n) x 1 array, it refers to the derivate per theta\n gradient = self._cost_function_derivative(y_pred, y, X, m)\n\n # delta/update rule\n self.theta = gradient\n\n self.costs.append(cost)\n pass\n\n print(\"Final theta is {} (cost: {})\".format(self.theta.T, cost))","def train(train_ds):\n rng = random.PRNGKey(0)\n\n # initialise the model\n py, params = GPModel.init(rng, train_ds['index_points'])\n model = nn.Model(GPModel, params)\n\n # utility functions for packing and unpacking param dicts\n par_from_array, array_from_par = build_par_pack_and_unpack(model)\n\n @jax.jit\n def loss_fun(model: GPModel, params: dict) -> float:\n \"\"\" This is clumsier than the usual FLAX loss_fn. \"\"\"\n py = model.module.call(params, train_ds['index_points'])\n return -py.log_prob(train_ds['y'])\n\n # wrap loss fun for scipy.optimize\n def wrapped_loss_fun(arr):\n params = par_from_array(arr)\n return loss_fun(model, params)\n\n @jax.jit\n def loss_and_grads(x):\n return jax.value_and_grad(wrapped_loss_fun)(x)\n\n res = oscipy.optimize.minimize(\n loss_and_grads,\n x0=array_from_par(params),\n jac=True,\n method='BFGS')\n\n logging.info('Optimisation message: {}'.format(res.message))\n\n trained_model = model.replace(params=par_from_array(res.x))\n return trained_model","def fit(self,X, y, lr=0.1, iters=100, recompute=True):\r\n # INSERT YOUR CODE HERE\r\n # Appending a column of 1's to the train set X\r\n X = np.append(X, np.array([[1]]*X.shape[0]), axis=1)\r\n self.w =self.initialize_weights(X.shape[1])\r\n\r\n if(recompute):\r\n #Reinitialize the model weights\r\n self.w = self.initialize_weights(X.shape[1])\r\n\r\n for _ in range(iters): \r\n # Calculate gradient ascent and Update weights\r\n # w = w + lr * g / size of X\r\n self.w += lr*(1 / X.shape[0])*self.gradient_ascent(self.w,X,y,lr)","def fit(\n self,\n X: np.ndarray,\n y: np.ndarray,\n lr: float = 0.1,\n epochs: int = 20000,\n progress_bar: bool = True,\n ) -> np.ndarray:\n X = np.append(X, np.ones((len(X), 1)), axis=1)\n y = y.reshape(-1, 1)\n lr = lr / len(X)\n losses = np.zeros(epochs)\n for i in tqdm(range(epochs), disable=not progress_bar):\n a = X @ self.v.T\n z = self.activation_function(a)\n y_hat = self.activation_function(z @ self.w)\n\n # Backprop\n grad_b = y_hat - y\n grad_w = z.T @ grad_b + 2 * self.reg / self.num_parameters * self.w\n grad_z = self.w.T * grad_b\n grad_a = grad_z * z * (1 - z)\n reg_grad_v = 2 * self.reg / self.num_parameters * self.v\n reg_grad_v[:, -1] = 0 # Don't regularize weights.\n grad_v = grad_a.T @ X + reg_grad_v\n # Update weights\n self.w -= lr * grad_w\n self.v -= lr * grad_v\n\n loss = self.loss(y, y_hat)\n losses[i] = loss\n return losses","def train(self, X, y, learning_rate = 1e-3, reg = 1e-5, num_iter = 100, \r\n batch_size = 100, verbose = False):\r\n num_train, dim = X.shape\r\n num_classes = np.max(y) + 1 # assum y take values 0..K-1\r\n # initialize weight\r\n if self.W is None:\r\n self.W = 0.001 * np.random.randn(dim, num_classes)\r\n \r\n # SGD\r\n loss_history = []\r\n for iter in range(num_iter):\r\n batch_ix = np.random.choice(num_train, batch_size)\r\n X_batch = X[batch_ix]\r\n y_batch = y[batch_ix]\r\n \r\n loss, grad = self.loss(X_batch, y_batch, reg)\r\n loss_history.append(loss)\r\n self.W -= grad * learning_rate\r\n \r\n if verbose and iter % 100 == 0:\r\n print('iteration: %d / %d: loss: %f' %(iter, num_iter, loss))\r\n \r\n return loss_history","def train(self, X, y):\n self.model.fit(X, y)","def fit(self, X, y):\n self.x_values = X\n self.y_values = y\n self.gradient_descent(self.coefficients, X, y)","def train(self, X, y, learning_rate=1e-3, num_iters=100,\n batch_size=200, verbose=True):\n num_train, dim = X.shape\n\n if self.w is None:\n self.w = 0.001 * np.random.randn(dim)\n\n loss_history = []\n\n # 将feature与label连起来，方便后面batch的划分\n all_data = list(zip(X, y))\n\n for it in xrange(num_iters):\n X_batch = None\n y_batch = None\n\n #########################################################################\n # TODO: #\n # Sample batch_size elements from the training data and their #\n # corresponding labels to use in this round of gradient descent. #\n # Store the data in X_batch and their corresponding labels in #\n # y_batch; after sampling X_batch should have shape (batch_size, dim) #\n # and y_batch should have shape (batch_size,) #\n # #\n # Hint: Use np.random.choice to generate indices. Sampling with #\n # replacement is faster than sampling without replacement. #\n #########################################################################\n\n # batch_data = np.random.choice(all_data, batch_size, False) \n # error: ValueError: a must be 1-dimensional \n # 查询相关api貌似该方法不能用于数组中元素为元组情况下的选取\n batch_data = random.sample(all_data, batch_size)\n X_batch, y_batch = zip(*batch_data)\n X_batch = np.array(X_batch)\n y_batch = np.array(y_batch)\n #########################################################################\n # END OF YOUR CODE #\n #########################################################################\n\n # evaluate loss and gradient\n\n loss, grad = self.loss(X_batch, y_batch)\n loss_history.append(loss)\n\n # perform parameter update\n #########################################################################\n # TODO: #\n # Update the weights using the gradient and the learning rate. #\n #########################################################################\n self.w += float(learning_rate) * np.array(grad)\n #########################################################################\n # END OF YOUR CODE #\n #########################################################################\n\n if verbose and (it % 1000 == 0 or it == num_iters - 1):\n print('iteration %d / %d: loss %f' % (it, num_iters, loss))\n\n return loss_history","def run_steep_gradient_descent(data_x, data_y, len_data, alpha, theta):\n n = len_data\n # WE NEED TO transpose data_x into (p+1) *n ,theta is 1*(p+1)\n prod = np.dot(theta, data_x.transpose())\n\n prod -= data_y\n print(\"pro: data_x\", prod.shape, data_x.shape)\n #prod represent the loss of the hypothesis and true label\n sum_grad = np.dot(prod, data_x)\n print(\"总梯度的值：\",sum_grad.shape)\n\n # batch-gradient descent\n theta = theta -(alpha / n) * sum_grad\n return theta","def train(self, train_x, train_y, optimzer='adam'):\n self.history = self.model.fit(train_x, train_y, epochs=self.epochs, batch_size=self.batch_size,\n verbose=self.verbose, shuffle=False)","def get_sgd_solution(TRAINING_PHI, TEST_PHI, VAL_PHI, W_Now, TrainingData,\n TrainingTarget, TestData, ValData):\n # Gradient Descent Solution for Linear Regression\n La = 2\n # learningRate = 0.01\n L_Erms_Val, L_Erms_TR, L_Erms_Test, L_Accuracy_Test, W_Mat = [], [], [], [], []\n\n for i in range(0, 400):\n\n # print (f'---------Iteration: {i} M{M} LR {learningRate} L :{C_Lambda}--------------')\n Delta_E_D = -np.dot(\n (TrainingTarget[i] - np.dot(np.transpose(W_Now), TRAINING_PHI[i])),\n TRAINING_PHI[i])\n La_Delta_E_W = np.dot(La, W_Now)\n Delta_E = np.add(Delta_E_D, La_Delta_E_W)\n Delta_W = -np.dot(learningRate, Delta_E)\n W_T_Next = W_Now + Delta_W\n W_Now = W_T_Next\n\n #-----------------TrainingData Accuracy---------------------#\n TR_TEST_OUT = GetValTest(TRAINING_PHI, W_T_Next)\n Erms_TR = GetErms(TR_TEST_OUT, TrainingTarget)\n L_Erms_TR.append(float(Erms_TR.split(',')[1]))\n\n #-----------------ValidationData Accuracy---------------------#\n VAL_TEST_OUT = GetValTest(VAL_PHI, W_T_Next)\n Erms_Val = GetErms(VAL_TEST_OUT, ValDataAct)\n L_Erms_Val.append(float(Erms_Val.split(',')[1]))\n\n #-----------------TestingData Accuracy---------------------#\n TEST_OUT = GetValTest(TEST_PHI, W_T_Next)\n Erms_Test = GetErms(TEST_OUT, TestDataAct)\n L_Erms_Test.append(float(Erms_Test.split(',')[1]))\n L_Accuracy_Test.append(float(Erms_Test.split(',')[0]))\n\n return ([L_Erms_TR, L_Erms_Val, L_Erms_Test, L_Accuracy_Test])","def train_lbfgs(self, x, y, epochs=2000, x_test=None, y_test=None, learning_rate=1.0, val_freq=1000, log_freq=1000,\n verbose=1):\n\n # train the model with L-BFGS solver\n if verbose:\n logging.info(f'Start L-BFGS optimization')\n\n optimizer = LBFGS()\n optimizer.minimize(\n self.model, self.loss_object, x, y, self.epoch_callback, epochs, x_test=x_test, y_test=y_test,\n val_freq=val_freq, log_freq=log_freq, verbose=verbose, learning_rate=learning_rate)","def fit(self, X, y, max_iter=MAX_ITER):\n n_tasks = len(X)\n n_feats = X[0].shape[1]\n W = np.random.randn(n_feats, n_tasks)\n start = time.time()\n cost_function = 0\n X = self.normalize_data(X)\n X = self.add_bias(X)\n for t in range(n_tasks):\n #print('Training {} task with lasso regression'.format(t))\n lasso = Fista(self, self.lambda_1)\n w = lasso.fit(xk=W[:, t], A=X[t], b=y[t], ind=self.groups,\n max_iter=max_iter)\n W[:, t] = w\n stop = time.time() - start\n self.W = W\n return W, np.array([cost_function]), stop","def nnRegression(data):","def train_logisticRegression(data: np.array, labels: np.array)->None:\n\n n_examples = np.size(data, 0)\n n_features = np.size(data, 1)\n n_categories = np.size(labels, 1)\n\n data = np.hstack((np.ones((n_examples, 1)), data))\n\n print(data[0:5, :])\n\n X_train, X_test, y_train, y_test, idx_test = split_data(data, labels, 0.7)\n\n convergence_goal = 1e-3\n learning_rate = 0.01\n\n theta = np.random.uniform(size=((n_features+1, n_categories)))\n\n for i in range(n_categories):\n\n cost_var = 1\n\n previous_cost = 1e6\n iterations = 0\n cost_to_plot = []\n\n while cost_var > convergence_goal:\n iterations += 1\n cost, grad = costFunction(X_train, y_train[:, i], theta[:, i])\n theta[:, i] = update_theta(theta[:, i], grad, learning_rate)\n cost_var = previous_cost - cost\n previous_cost = cost\n if iterations == 1: cost_var = 1\n cost_to_plot.append(cost)\n # print(cost)\n\n plt.plot(range(iterations), cost_to_plot, 'g-', label = 'cost')\n plt.xlabel('iterations')\n plt.ylabel('cost')\n # plt.show()\n\n predictions = lrPredict(theta, X_test)\n\n print(predictions[0:5, :])\n print(y_test[0:5, :])\n\n accuracy = np.mean([p == l for p, l in zip(predictions, y_test)])\n print(\"Accuracy = {}\".format(accuracy))\n\n pass","def train_step(model, x, optimizer):\n with tf.GradientTape() as tape:\n loss = compute_loss(model, x)\n gradients = tape.gradient(loss, model.trainable_variables)\n optimizer.apply_gradients(zip(gradients, model.trainable_variables))","def fit(self, X_train, y_train):\n if X_train.shape[0] != y_train.shape[0]:\n raise AssertionError\n\n X_train = np.hstack((np.ones((X_train.shape[0], 1)), X_train))\n rows = X_train.shape[0]\n cols = X_train.shape[1]\n self._weight = np.random.normal(size=cols)\n for epoch in range(self._max_iter):\n data = np.hstack((X_train, y_train.reshape((-1, 1))))\n np.random.shuffle(data)\n X_train = data[:, : -1]\n y_train = data[:, -1].flatten()\n for i in np.arange(0, rows, self._batch_size):\n batch = X_train[i:i + self._batch_size]\n y = y_train[i:i + self._batch_size]\n pred = batch @ self._weight.T\n f_error = pred - y\n gradient = 2 * f_error.dot(batch) + self._alpha * self._l1_ratio * np.sign(\n self._weight) + self._alpha * (1 - self._l1_ratio) * self._weight\n self._weight -= self._lc * gradient / batch.shape[0]\n self._loss.append(self.mse(X_train @ self._weight.T, y_train))","def fit(self, X, y, X_validate, y_validate):\n \n iterate = 800\n \n self.SGD_theta_list = [0]*len(X[0])\n self.SGD_bias = 0\n\n SGD_cost_history = []\n SGD_validate_cost_history = []\n\n for i in range(iterate):\n if(i%100==0):\n print(i,\" iterations\")\n selection = random.randint(0, len(X)-1) #selecting one random row for SGD\n temp_X = []\n temp_X.append(X[selection])\n temp_y = []\n temp_y.append(y[selection])\n self.SGD_bias, self.SGD_theta_list = self.update_thetas(np.array(temp_X), np.array(temp_y), self.SGD_theta_list, self.SGD_bias,self.training_rate)\n SGD_cost = self.cost_function(X, y, self.SGD_theta_list, self.SGD_bias)\n SGD_cost_history.append(SGD_cost)\n SGD_validate_cost = self.cost_function(X_validate, y_validate,self.SGD_theta_list, self.SGD_bias)\n SGD_validate_cost_history.append(SGD_validate_cost)\n\n self.FINAL_SGD_TRAIN_LOSS.append(SGD_cost_history[-1])\n self.FINAL_SGD_VALIDATE_LOSS.append(SGD_validate_cost_history[-1])\n\n plt.plot(list(range(iterate)), SGD_cost_history)\n plt.plot(list(range(iterate)), SGD_validate_cost_history)\n plt.xlabel(\"Iterations\")\n plt.ylabel(\"Loss SGD\")\n plt.show()\n \n \n self.BGD_theta_list = [0]*len(X[0])\n self.BGD_bias = 0\n\n BGD_cost_history = []\n BGD_validate_cost_history = []\n\n for i in range(iterate):\n if(i%100==0):\n print(i,\" iterations\")\n selection = random.randint(0, len(X)-1)\n \n self.BGD_bias, self.BGD_theta_list = self.update_thetas(X, y, self.BGD_theta_list, self.BGD_bias,self.training_rate)\n\n BGD_cost = self.cost_function(X, y, self.BGD_theta_list, self.BGD_bias)\n BGD_cost_history.append(BGD_cost)\n BGD_validate_cost = self.cost_function(X_validate, y_validate,self.BGD_theta_list, self.BGD_bias)\n BGD_validate_cost_history.append(BGD_validate_cost)\n\n self.FINAL_BGD_TRAIN_LOSS.append(BGD_cost_history[-1])\n self.FINAL_BGD_VALIDATE_LOSS.append(BGD_validate_cost_history[-1])\n\n plt.plot(list(range(iterate)), BGD_cost_history)\n plt.plot(list(range(iterate)), BGD_validate_cost_history)\n plt.xlabel(\"Iterations\")\n plt.ylabel(\"Loss BGD\")\n plt.show()\n\n print(\"FINAL_SGD_TRAIN_LOSS\\n\",self.FINAL_SGD_TRAIN_LOSS)\n print(\"FINAL_SGD_VALIDATE_LOSS\\n\",self.FINAL_SGD_VALIDATE_LOSS)\n print(\"FINAL_BGD_TRAIN_LOSS\\n\",self.FINAL_BGD_TRAIN_LOSS)\n print(\"FINAL_BGD_VALIDATE_LOSS\\n\",self.FINAL_BGD_VALIDATE_LOSS)\n\n \n return self","def _batch_gradient_descent(self, X, y, lr, epochs):\n\n # Initialize the bias and weights.\n _, n = X.shape\n self.bias = 0\n self.weights = np.random.normal(size=n)\n\n for i in range(epochs):\n # Calculate and sum the gradient delta of each sample\n grad_bias, grad_weights = self._get_gradient(X, y)\n\n # Show the gradient of each epoch.\n grad = (grad_bias + grad_weights.mean()) / 2\n print(\"Epochs %d gradient %.3f\" % (i + 1, grad), flush=True)\n\n # Update the bias and weight by gradient of current epoch\n self.bias += lr * grad_bias\n self.weights += lr * grad_weights","def train_nn_regression_model(\n optimizer,\n steps,\n batch_size,\n hidden_units,\n training_examples,\n training_targets,\n validation_examples,\n validation_targets):\n\n periods = 10\n steps_per_period = steps / periods\n\n # Create the input functions.\n feature_columns = set([tf.contrib.layers.real_valued_column(my_feature) for my_feature in training_examples])\n\n training_input_fn = learn_io.pandas_input_fn(\n x=training_examples, y=training_targets,\n num_epochs=None, batch_size=batch_size)\n\n predict_training_input_fn = learn_io.pandas_input_fn(\n x=training_examples, y=training_targets,\n num_epochs=1, shuffle=False)\n\n predict_validation_input_fn = learn_io.pandas_input_fn(\n x=validation_examples, y=validation_targets,\n num_epochs=1, shuffle=False)\n\n\n # Create a linear regressor object.\n\n dnn_regressor = tf.contrib.learn.DNNRegressor(\n feature_columns=feature_columns,\n hidden_units=hidden_units,\n optimizer=optimizer,\n gradient_clip_norm=5.0\n )\n\n # Train the model, but do so inside a loop so that we can periodically assess\n # loss metrics.\n print \"Training model...\"\n print \"RMSE (on training data):\"\n training_rmse = []\n validation_rmse = []\n for period in range (0, periods):\n # Train the model, starting from the prior state.\n dnn_regressor.fit(\n input_fn=training_input_fn,\n steps=steps_per_period\n )\n # Take a break and compute predictions.\n training_predictions = list(dnn_regressor.predict(input_fn=predict_training_input_fn))\n validation_predictions = list(dnn_regressor.predict(input_fn=predict_validation_input_fn))\n # Compute training and validation loss.\n training_root_mean_squared_error = math.sqrt(\n metrics.mean_squared_error(training_predictions, training_targets))\n validation_root_mean_squared_error = math.sqrt(\n metrics.mean_squared_error(validation_predictions, validation_targets))\n # Occasionally print the current loss.\n print \" period %02d : %0.2f\" % (period, training_root_mean_squared_error)\n # Add the loss metrics from this period to our list.\n training_rmse.append(training_root_mean_squared_error)\n validation_rmse.append(validation_root_mean_squared_error)\n print \"Model training finished.\"\n\n # Output a graph of loss metrics over periods.\n plt.ylabel(\"RMSE\")\n plt.xlabel(\"Periods\")\n plt.title(\"Root Mean Squared Error vs. Periods\")\n plt.tight_layout()\n plt.plot(training_rmse, label=\"training\")\n plt.plot(validation_rmse, label=\"validation\")\n plt.legend()\n\n print \"Final RMSE (on training data): %0.2f\" % training_root_mean_squared_error\n print \"Final RMSE (on validation data): %0.2f\" % validation_root_mean_squared_error\n\n return dnn_regressor, training_rmse, validation_rmse","def train_regressor(self, data, opt='adam', val=None, batch_size=64,\n start=0, **hooks):\n metrics = 'mean_squared_error',\n return self.train(data, metrics, opt, val, batch_size, start, **hooks)","def train(self, x, y):\n len_dim_0 = x.shape[0]\n x = np.reshape(x, (len_dim_0, 784))\n with tf.GradientTape() as tape:\n tape.watch(self.layers)\n y_out = self.forward(x)\n loss = self.mean_squared_error(y_out, y)\n grads = tape.gradient(loss, self.layers)\n temp_layers = []\n for layer, grad in zip(self.layers, grads):\n new_w = layer.weights - (self.learning_rate * grad.weights)\n new_b = layer.biases - (self.learning_rate * grad.biases)\n temp_layers.append(self.Layer(new_w, new_b))\n self.layers = temp_layers\n\n return loss","def train_step(model,x,optimizer):\r\n\twith tf.GradientTape() as tape:\r\n\t\tloss = compute_loss(model, x)\r\n\t\tgradients = tape.gradient(loss, model.trainable_variables)\r\n\t\toptimizer.apply_gradients(zip(gradients, model.trainable_variables))\r\n\treturn loss","def fit(self, X, y):\n y = np.array(y)\n rows, columns = X.shape\n num_batches = int(np.ceil(rows / self.batch_size))\n batches = np.arange(num_batches + 1) * self.batch_size\n indxs = np.arange(rows)\n\n self.W = np.zeros(columns)\n self.b = rng.random(1)\n\n # stochastic gradient descent logic\n for _ in range(self.num_epochs):\n rng.shuffle(indxs)\n\n for i, j in zip(batches[0:-1], batches[1:]):\n batch_indxs = indxs[i:j]\n x_batch = X[batch_indxs]\n y_batch = y[batch_indxs]\n self.update(x_batch, y_batch)\n\n # track loss history during training\n self.loss_history.append(self.loss(self.predict_proba(X), y))\n self.accuracies.append(self.accuracy(X, y))","def experiment_linear_tradeoff_linf(_):\n adv_norm_type = 'linf'\n dual_norm_type = 'l1'\n # Min l1-norm solution found (norm=0.6876)\n attack_eps = 1/0.6876\n attack_step_dir = 'sign_grad'\n module_name = 'train'\n log_dir = 'runs_linear_tradeoff_%s' % adv_norm_type\n exclude = '*'\n\n d_over_n = [32]\n dim = 100\n num_train = [int(dim / p) for p in d_over_n]\n\n # Config params\n shared_params = []\n shared_params += [\n ('config', './config.py'),\n ('seed', list(range(3))),\n ]\n\n # Data hyper-parameters\n shared_params += [\n ('temperature', 0.0001),\n ('num_test', 500),\n ('dim', dim),\n ('num_train', num_train),\n ]\n\n # Adversarial configuration: test\n shared_params += nameit('adv', [\n ('norm_type', adv_norm_type),\n ('lr', 0.1),\n ('niters', 10),\n # ('eps_iter', attack_eps), # Overwritten by cvxpy\n # ('eps_tot', attack_eps), # Overwritten by cvxpy\n ('pre_normalize', True), # multi attacks\n ('post_normalize', True),\n ('eps_from_cvxpy', True),\n ('step_dir', attack_step_dir),\n ])\n\n # Logging to standard output\n shared_params += [\n ('log_interval', 10000), # 1000),\n ('log_keys', '\\'(\"%s\")\\'' % ('\",\"'.join([\n 'risk/train/zero_one',\n 'risk/train/adv/%s' % adv_norm_type,\n 'weight/linear/norm/%s' % dual_norm_type,\n 'margin/%s' % dual_norm_type,\n ]))),\n # Compare with cvxpy\n ('enable_cvxpy', True),\n ]\n params = []\n\n # reg_coeff = [1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1]\n reg_coeff = [1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1, 10]\n # Between 1e-3 and 1e-1 for d/n=10 the adv robustness drops\n reg_coeff += [3e-3, 5e-3, 3e-2, 5e-2, 3e-1, 5e-1]\n\n # Model hyper-parameters\n linear_noreg_model_params = nameit('model', [\n ('arch', 'linear'),\n ('regularizer', 'none'),\n ])\n linear_reg_model_params = nameit('model', [\n ('arch', 'linear'),\n ('regularizer', ['w_%s' % dual_norm_type]),\n ('reg_coeff', reg_coeff),\n ])\n\n # Explicit regularization with line search\n # njobs=3*6*20*4*2=2880\n explicit_reg = nameit('optim', [\n ('name', 'fista'),\n ('niters', 10000),\n ('bound_step', True),\n ('step_size', [1, 10, 100, 1000]),\n ])\n params += [OrderedDict(shared_params+linear_reg_model_params+explicit_reg)]\n\n # Adversarial training with line search\n for i in [1] + list(np.arange(0.1, 2, 0.2)): # [0.1, 0.3, 0.5, 0.7, 1, 1.3]:\n adv_train_params = nameit('optim', [\n ('name', 'gd_ls'),\n ('niters', 10000),\n ('bound_step', True),\n ])\n adv_train_params += nameit('optim', nameit('adv_train', [\n ('enable', True),\n ('norm_type', adv_norm_type),\n ('lr', 0.1),\n ('niters', 10), # niters, 1000\n ('pre_normalize', True),\n ('post_normalize', True),\n ('step_dir', attack_step_dir),\n ('eps_iter', float(attack_eps) * i),\n ('eps_tot', float(attack_eps) * i),\n ]))\n params += [OrderedDict(\n shared_params+linear_noreg_model_params+adv_train_params)]\n\n return params, log_dir, module_name, exclude","def train():\n model.train()\n for batch_index, (xb, yb) in enumerate(train_dl):\n loss = loss_func(model(xb), yb)\n\n loss.backward()\n opt.step()\n opt.zero_grad()","def train_logistic_regression(x_train, y_train, learning_rate, fit_intercept=False, max_iter=500):\r\n if fit_intercept:\r\n intercept = np.ones(x_train.shape[0], 1)\r\n x_train = np.hstack((intercept, x_train)) # hstacks merges 2 arrays column wise\r\n weights = np.zeros(x_train.shape[1])\r\n for iteration in range(max_iter):\r\n weights = update_weights(x_train, y_train, weights, learning_rate)\r\n # printing cost for every 100 iterations\r\n if iteration % 100 == 0:\r\n print(calculate_cost(x_train, y_train, weights))\r\n return weights","def fit(self, x_train, y_train):\n\n optimizers_functions = {'gd': self.__update_weights_grad_desc, 'sgd': self.__update_weights_stoc_gd}\n\n if self.__fit_intercept:\n intercept = np.ones((x_train.shape[0], 1))\n x_train = np.hstack((intercept, x_train))\n\n self.__weights = np.zeros(x_train.shape[1])\n\n for iteration in range(self.__max_iter):\n optimizers_functions[self.__optimizer](x_train, y_train)\n\n if self.__verbose == 1 and iteration % 100 == 0:\n print(\"Iteration: {}, training loss: {}\".format(iteration, self.__compute_cost(x_train, y_train)))","def fit(self, x: np.array, y: np.array, epochs: int = 2) -> 'LinearRegressor':\n self.rows, self.columns = x.shape\n self.rows_target, self.columns_target = y.shape\n\n self.w0 = 1.0\n self.w1 = np.random.randn(1, self.columns)\n \n print(f'Initials >> \"w0\": {self.w0}, \"w1\": {self.w1}')\n \n for _ in range(epochs):\n preds = self.predict(x)\n preds = np.reshape(preds, (-1,1))\n \n self.loss.append(np.sum(np.square(y - preds) / self.rows))\n\n dw0 = -(2 / self.rows) * np.sum(y - preds)\n dw1 = -(2 / self.rows) * x.T.dot(y - preds)\n\n self.w0 -= self.learning_rate * dw0\n self.w1 -= self.learning_rate * dw1\n #print(f'dw0: {dw0}, dw1: {dw1}')\n #print(f'\"w0\": {self.w0}, \"w1\": {self.w1}')\n \n return self","def train(self, X, Y, iterations=5000, alpha=0.05, verbose=True,\n graph=True, step=100):\n if not isinstance(iterations, int):\n raise TypeError('iterations must be an integer')\n if iterations < 0:\n raise ValueError('iterations must be a positive integer')\n if not isinstance(alpha, float):\n raise TypeError('alpha must be a float')\n if alpha < 0:\n raise ValueError('alpha must be positive')\n if verbose or graph:\n if not isinstance(step, int):\n raise TypeError('step must be an integer')\n if step <= 0 or step > iterations:\n raise ValueError('step must be positive and <= iterations')\n\n costs = []\n iteration = np.arange(0, iterations)\n for i in range(iterations):\n A, self.__cache = self.forward_prop(X)\n key = \"A{}\".format(self.__L)\n cost = self.cost(Y, A)\n costs.append(cost)\n if i % step == 0 or i == iterations:\n if verbose:\n print(\"Cost after {} iterations: {}\".format(i, cost))\n self.gradient_descent(Y, self.__cache, alpha)\n if graph:\n plt.plot(iteration, costs, 'b-')\n plt.xlabel('iteration')\n plt.ylabel('cost')\n plt.title('Training Cost')\n plt.show()\n\n return self.evaluate(X, Y)","def train_single_feature_linear_regressor(learning_rate, steps, batch_size, input_feature=\"nsmiles\"):\n \n print(\"TRAINING SINGLE FEATURE LINEAR REGRESSOR\")\n\n periods = 10\n steps_per_period = steps / periods\n\n my_feature = input_feature\n my_feature_data = airfare_report_dataframe[[my_feature]]\n my_label = \"fare\"\n targets = airfare_report_dataframe[my_label]\n\n # Create feature columns.\n feature_columns = [tf.feature_column.numeric_column(my_feature)]\n \n # Create input functions.\n training_input_fn = lambda: single_feature_input_fn(my_feature_data, targets, batch_size=batch_size)\n prediction_input_fn = lambda: single_feature_input_fn(my_feature_data, targets, num_epochs=1, shuffle=False)\n \n # Create a linear regressor object.\n my_optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)\n my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)\n linear_regressor = tf.estimator.LinearRegressor(\n feature_columns=feature_columns,\n optimizer=my_optimizer\n )\n\n # Set up to plot the state of our model's line each period.\n plt.figure(figsize=(15, 6))\n plt.subplot(1, 2, 1)\n plt.title(\"Learned Line by Period\")\n plt.ylabel(my_label)\n plt.xlabel(my_feature)\n sample = airfare_report_dataframe.sample(n=300)\n plt.scatter(sample[my_feature], sample[my_label])\n colors = [cm.coolwarm(x) for x in np.linspace(-1, 1, periods)]\n\n plt.show()\n\n # Train the model, but do so inside a loop so that we can periodically assess\n # loss metrics.\n print(\"Training model...\")\n print(\"RMSE (on training data):\")\n root_mean_squared_errors = []\n for period in range (0, periods):\n # Train the model, starting from the prior state.\n linear_regressor.train(\n input_fn=training_input_fn,\n steps=steps_per_period\n )\n # Take a break and compute predictions.\n predictions = linear_regressor.predict(input_fn=prediction_input_fn)\n predictions = np.array([item['predictions'][0] for item in predictions])\n \n # Compute loss.\n root_mean_squared_error = math.sqrt(\n metrics.mean_squared_error(predictions, targets))\n # Occasionally print the current loss.\n print(\" period %02d : %0.2f\" % (period, root_mean_squared_error))\n # Add the loss metrics from this period to our list.\n root_mean_squared_errors.append(root_mean_squared_error)\n \n # Finally, track the weights and biases over time.\n # Apply some math to ensure that the data and line are plotted neatly.\n y_extents = np.array([0, sample[my_label].max()])\n\n print(\"Model training finished.\")\n\n # Output a graph of loss metrics over periods.\n plt.subplot(1, 2, 2)\n plt.ylabel('RMSE')\n plt.xlabel('Periods')\n plt.title(\"Root Mean Squared Error vs. Periods\")\n plt.tight_layout()\n plt.plot(root_mean_squared_errors)\n\n plt.show()\n\n #I left out the calibration data graph\n\n print(\"Final RMSE (on training data): %0.2f\" % root_mean_squared_error)","def linearReg(x,y):\n X=np.array(x).reshape(-1,1)\n Y=np.array(y).reshape(-1,1)\n x_shape = X.shape\n num_var = x_shape[1] \n yintercept = 0\n slope = 0\n progress = []\n #intialize the parameter\n weight_matrix = np.random.normal(-1,1,(num_var,1))\n yintercept = np.random.rand(1)\n #cost minmization\n for i in range(200):\n dcostdm = np.sum(np.multiply(((np.matmul(X,weight_matrix)+ yintercept)-Y),X))*2/x_shape[0] #w.r.t to the weight\n dcostdc = np.sum(((np.matmul(X,weight_matrix)+yintercept)-Y))*2/x_shape[0] #partial derivative of cost w.r.t the intercept\n weight_matrix -= 0.1*dcostdm \n #updating the weights with the calculated gradients\n yintercept -= 0.1*dcostdc #updating the weights with the calculated gradients\n progress.append(np.array((weight_matrix,yintercept)))\n slope = weight_matrix\n return (slope[-1],yintercept)","def main():\n ###################\n ## Dataset ##\n ###################\n # (X, y) m = 100, n = 1\n _data_x, data_y = make_regression(n_samples=100, n_features=1, noise=10)\n\n # show the dataset\n plt.subplot(2, 2, 1)\n plt.title(\"dataset\")\n plt.scatter(_data_x, data_y)\n\n # Transform the dataset into matrices.\n # That is used for writing the equations in the matrix form.\n data_x = np.hstack((_data_x, np.ones(_data_x.shape)))\n data_y = data_y.reshape(data_y.shape[0], 1)\n\n #################\n ## Model ##\n #################\n # initial parameters\n init_params = np.random.randn(2, 1)\n\n # initial model\n init_model = model(data_x, init_params)\n\n # plot initial model\n plt.subplot(2, 2, 2)\n plt.title(\"initial model\")\n plt.scatter(_data_x, data_y)\n plt.plot(_data_x, init_model, c='g')\n\n #########################\n ## cost function ##\n #########################\n # show cost function for initial parameters\n print(cost_function(data_x, data_y, init_params))\n\n ####################\n ## training ##\n ####################\n # learning rate\n learn_rate = 0.005\n # number of iterations\n number_iterations = 1_000\n\n # final parameters for our model\n final_params, cost_tracking = gradient_descent(\n data_x, data_y, init_params, learn_rate, number_iterations)\n\n # final model\n final_model = model(data_x, final_params)\n\n # show cost function for final parameters\n print(cost_function(data_x, data_y, final_params))\n\n # plot final model\n plt.subplot(2, 2, 3)\n plt.title(\"final model\")\n plt.scatter(_data_x, data_y)\n plt.plot(_data_x, final_model, c='r')\n\n ##########################\n ## learning curve ##\n ##########################\n # plot Cost history\n plt.subplot(2, 2, 4)\n plt.title(\"cost tracking\")\n plt.plot(range(number_iterations), cost_tracking)\n\n ########################################\n ## Coefficient of determination ##\n ########################################\n print(coefficient_determination(data_y, final_model))\n\n plt.show()","def train_logistic_regression(train_x, train_y):\n\n logistic_regression_model = LogisticRegression(penalty='l2', C=1.0)\n logistic_regression_model.fit(train_x, train_y)\n return logistic_regression_model","def train(self, X_train, y_train):\n self.model.fit(X_train, y_train)","def train_step(self, x):\n with tf.GradientTape() as tape:\n loss = self.compute_loss(x)\n gradients = tape.gradient(loss, self.model.trainable_variables)\n self.optimizer.apply_gradients(zip(gradients, self.model.trainable_variables))","def linear_regression(features, values):\n clf = SGDRegressor(n_iter=100)\n clf.fit(features,values)\n print(clf.score(features,values))\n intercept = clf.intercept_ \n params = clf.coef_\n \n return intercept, params","def train_step(self, x, y):\n\n with tf.GradientTape() as tape:\n y_pred = self.model(x)\n loss = self.loss_object(y, y_pred)\n gradients = tape.gradient(loss, self.model.trainable_variables)\n self.optimizer.apply_gradients(zip(gradients, self.model.trainable_variables))\n\n return loss","def train(epochs, batch_size, lr, verbose):\n # autograd globally off\n torch.set_grad_enabled(False)\n # generate training and testing datasets\n train_data, train_label = generate_data()\n test_data, test_label = generate_data()\n # normalize data be centered at 0\n train_data, test_data = normalize(train_data, test_data)\n\n if verbose:\n print(\"--- Dataset ---\")\n print(\"Train X: \", train_data.size(), \" | Train y: \", train_label.size())\n print(\" Test X: \", test_data.size(), \" | Test y: \", test_label.size())\n\n layers =[]\n # input layer (2 input units)\n linear1 = Linear(2, 25, bias= True, weight_init=xavier_uniform)\n\n # 3 hidden layers (each 25 units)\n linear2 = Linear(25, 25, bias= True, weight_init=xavier_uniform)\n linear3 = Linear(25, 25, bias= True, weight_init=xavier_uniform)\n linear4 = Linear(25, 25, bias= True, weight_init=xavier_uniform)\n\n # output layer (2 output units)\n linear5 = Linear(25, 2, bias= True, weight_init=xavier_uniform)\n\n\n layers.append(linear1)\n layers.append(Relu())\n layers.append(linear2)\n layers.append(Relu())\n layers.append(linear3)\n layers.append(Relu())\n layers.append(linear4)\n layers.append(Tanh())\n layers.append(linear5)\n\n model = Sequential(layers)\n if verbose: print(\"Number of model parameters: {}\".format(sum([len(p) for p in model.param()])))\n\n criterion = MSE()\n optimizer = SGD(model, lr=lr)\n\n train_losses, test_losses = [], []\n train_accuracies, test_accuracies = [], []\n train_errors, test_errors = [], []\n\n if verbose: print(\"--- Training ---\")\n for epoch in range(1, epochs+1):\n if verbose:print(\"Epoch: {}\".format(epoch))\n\n # TRAINING\n for batch_idx in range(0, train_data.size(0), batch_size):\n # axis 0, start from batch_idx until batch_idx+batch_size\n output = model.forward(train_data.narrow(0, batch_idx, batch_size))\n\n # Calculate loss\n loss = criterion.forward(output, train_label.narrow(0, batch_idx, batch_size))\n train_losses.append(loss)\n if verbose: print(\"Train Loss: {:.2f}\".format(loss.item()))\n\n # put to zero weights and bias\n optimizer.zero_grad()\n\n ## Backpropagation\n # Calculate grad of loss\n loss_grad = criterion.backward()\n\n # Grad of the model\n model.backward(loss_grad)\n\n # Update parameters\n optimizer.step()\n\n train_prediction = model.forward(train_data)\n acc = accuracy(train_prediction, train_label)\n train_accuracies.append(acc)\n train_errors.append(1-acc)\n if verbose: print(\"Train Accuracy: {:.2f}\".format(acc.item()))\n\n # EVALUATION\n for batch_idx in range(0, test_data.size(0), batch_size):\n # axis 0, start from batch_idx until batch_idx+batch_size\n output = model.forward(test_data.narrow(0, batch_idx, batch_size))\n\n # Calculate loss\n loss = criterion.forward(output, test_label.narrow(0, batch_idx, batch_size))\n test_losses.append(loss)\n if verbose: print(\"Test Loss: {:.2f}\".format(loss.item()))\n\n test_prediction = model.forward(test_data)\n acc = accuracy(test_prediction, test_label)\n test_accuracies.append(acc) \n test_errors.append(1-acc)\n if verbose: print(\"Test Accuracy: {:.2f}\".format(acc.item()))\n\n return train_losses, test_losses, train_accuracies, test_accuracies, train_errors, test_errors","def backward_linear(Data):\n\n # data\n graph = tf.Graph()\n X = Data[0]\n Y_ = Data[1]\n\n if X.shape[0] != Y_.shape[0]:\n raise Exception(\"The quantity of Input X and Compare Y_ are not same!\")\n\n Loss = []\n with graph.as_default():\n print(\"This is the process of all the Dose!\")\n print(\"There are %d data in this process.\" % X.shape[0])\n print(\"Features of X: %d\" % X.shape[1])\n print(\"Learning rate is: %f\" % learning_rate)\n # Init all the parameters\n global_step = tf.Variable(0, trainable=False)\n\n STEPS = int(Epoch * X.shape[0] / BATCH_SIZE) + 1\n epoch = 0\n\n with tf.name_scope('inputs'):\n x = tf.placeholder(tf.float32, [None, Forward.INPUT_NODE], name='x_Input')\n y_ = tf.placeholder(tf.float32, [None, Forward.OUTPUT_NODE], name='y_Exact')\n y = Forward.forward_linear(x, regularizer=None)\n\n # lost function\n with tf.name_scope('loss'):\n loss_mse = tf.reduce_mean(tf.square(y - y_))\n loss = loss_mse + tf.add_n(tf.get_collection(\"losses\"))\n tf.summary.scalar('loss', loss)\n\n # Todo\n # LM algorithm\n\n # learning_rate = tf.train.exponential_decay(\n # LEARNING_RATE_BASE,\n # global_step,\n # X.shape[0] / BATCH_SIZE,\n # LEARNING_RATE_DECAY,\n # staircase=True\n # )\n\n with tf.name_scope('train'):\n # train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step)\n # train_step = tf.train.MomentumOptimizer(learning_rate, momentum=0.9).minimize(loss, global_step)\n train_step = tf.train.AdamOptimizer(learning_rate, beta1=0.9, beta2=0.99).minimize(loss, global_step)\n\n # EMA algorithm\n ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)\n ema_op = ema.apply(tf.trainable_variables())\n with tf.control_dependencies([train_step, ema_op]):\n train_op = tf.no_op(name='train')\n\n # ready for storing the model\n saver = tf.train.Saver()\n\n with tf.Session() as sess:\n init_op = tf.global_variables_initializer()\n sess.run(init_op)\n\n # Get the check point\n ckpt = tf.train.get_checkpoint_state(MODEL_SAVE_PATH_LINEAR)\n if ckpt and ckpt.model_checkpoint_path:\n saver.restore(sess, ckpt.model_checkpoint_path)\n\n # begin multi threads\n coord = tf.train.Coordinator()\n threads = tf.train.start_queue_runners(sess, coord)\n print(\"Begin the multi threads!\")\n\n # Graph\n merged = tf.summary.merge_all()\n writer = tf.summary.FileWriter(\"./logs_linear/\", sess.graph)\n\n # Training\n for i in range(STEPS):\n start = (i * BATCH_SIZE) % int(X.shape[0])\n end = start + BATCH_SIZE\n # if finish all the data\n if end >= X.shape[0]:\n end = X.shape[0]\n\n _, loss_value, step = sess.run([train_op, loss, global_step],\n feed_dict={x: X[start:end], y_: Y_[start:end]})\n\n if i % 4000 == 0:\n print(\"Steps are: %d , loss is: %g.\" % (step, loss_value))\n rs = sess.run(merged, feed_dict={x: X[start:end], y_: Y_[start:end]})\n writer.add_summary(rs, i)\n saver.save(sess, os.path.join(MODEL_SAVE_PATH_LINEAR, MODEL_NAME), global_step)\n\n # a round\n if end == X.shape[0]:\n # get the results\n epoch += 1\n loss_total = sess.run(loss, feed_dict={x: X, y_: Y_})\n\n Loss.append(loss_total)\n # Loss.append(loss_total*10000)\n print(\"After %d epoch(s), steps are: %d, loss total is: %g.\\n\" % (epoch, step, loss_total))\n saver.save(sess, os.path.join(MODEL_SAVE_PATH_LINEAR, MODEL_NAME), global_step)\n\n # close the multi threads\n coord.request_stop()\n coord.join(threads)\n print(\"Close the multi threads!\")\n\n return Loss","def fit(self, X, y):\n X = self.normalize_data(X)\n X = self.add_bias(X)\n n_tasks = len(X)\n n_feats = X[0].shape[1]\n W = np.random.randn(n_feats, n_tasks)\n cost_function = 0\n start = time.time()\n for t in range(n_tasks):\n #print('Training task {} with group lasso'.format(t))\n fista = Fista(self, self.lambda_1)\n w_opt = fista.fit(W[:, t], X[t], y[t], self.groups,\n max_iter=self.max_iter)\n W[:, t] = w_opt\n cost_function += self.cost(X[t], y[t], W[:, t])\n stop = time.time() - start\n self.W = W\n return W, np.array([cost_function]), stop","def fit(self, X, Y, lrate=0.01, training_steps=100, coeff_reg=0.1):#, batch_size=1):\n num_instances = len(X)\n num_features = len(X[0])\n\n x = T.matrix(\"x\")\n y = T.vector(\"y\")\n w = theano.shared(np.random.random((num_features,)), name=\"w\")\n b = theano.shared(0., name=\"b\")\n\n #p = 1 / (1 + T.exp(-(T.dot(x, w) + b)))\n p = (1 + T.tanh(-(T.dot(x, w) + b))) / 2\n cost = ((p - y) ** 2).sum() + coeff_reg * (w ** 2).sum()\n gw, gb = T.grad(cost, [w, b])\n\n train = theano.function(\n inputs=[x,y],\n outputs=[cost],\n updates=((w, w - lrate * gw), (b, b - lrate * gb)),\n allow_input_downcast=True)\n\n cst = [0] * training_steps\n #num_batches = num_instances // batch_size\n for i in xrange(training_steps):\n \"\"\"\n for j in xrange(num_batches):\n #lidx = j*batch_size\n #uidx = min(num_instances, lidx+batch_size)\n #err = train(X[lidx:uidx], Y[lidx:uidx])\n err = train(X[j:(j+1)], Y[j:(j+1)])\n \"\"\"\n err = train(X, Y)\n cst[i] = sum(err)\n print \"%d\\t%f\" % (i, cst[i])\n\n plt.plot(cst)\n #plt.show()\n plt.savefig('bgd.png')\n\n self.w = w.get_value()\n self.b = b.get_value()","def train_predict(self, xTrain, yTrain, xTest, yTest):\n trainStats = {}\n # TODO: DO SGD\n #beta = np.linalg.inv(xTrain.transpose().dot(xTrain)).dot(xTrain.transpose()).dot(yTrain)\n LinearRegression.beta = [[0],[0]]\n intercept = 0\n n = len(xTrain)\n startall = time.time()\n list = [x for x in range(0,len(xTrain))]\n for i in range(self.mEpoch):\n random.shuffle(list)\n Dbetalist = []\n Dinterceptlist = []\n start = time.time()\n for j in range(self.bs):\n # Dbetalist = []\n # Dinterceptlist = []\n indexstart = len(list)/self.bs * j\n indexend = len(list)/self.bs * j + len(list)/self.bs\n subset = xTrain[int(indexstart):int(indexend)]\n #print(subset)\n ypredict = np.dot(subset,LinearRegression.beta) + intercept\n subyTrain = yTrain[int(indexstart):int(indexend)]\n Dbeta = (-2/n)*sum(np.dot(subset.transpose(),(subyTrain-ypredict)))\n Dbetalist.append(Dbeta)\n Dintercept = (-2/n)*sum(subyTrain-ypredict)\n Dinterceptlist.append(Dintercept)\n\n end = time.time()\n timeElapse = end - start\n\n avgDbeta = sum(Dbetalist) / len(Dbetalist)\n avgDintercept = sum(Dinterceptlist) / len(Dinterceptlist)\n #print(avgDbeta)\n # print(avgDintercept)\n LinearRegression.beta = LinearRegression.beta - self.lr * avgDbeta\n #print(LinearRegression.beta)\n # print(beta)\n intercept = intercept - self.lr * avgDintercept\n\n value = {}\n value['time'] = timeElapse\n value['train-mse'] = LinearRegression.mse(LinearRegression, xTrain, yTrain)\n value['test-mse'] = LinearRegression.mse(LinearRegression, xTest, yTest)\n trainStats[i*self.bs] = value\n\n endall = time.time()\n totaltime = endall - startall\n\n\n return trainStats","def train(self, X, y):","def fit(self,X,y):\n \n rand_num = np.random.RandomState(self.random_state)\n self.w_ = rand_num.normal(loc = 0.0, scale = 0.01,size = 1 + X.shape[1])\n self.cost_ = []\n \n for i in range(self.n_iter):\n net_input = self.net_input(X)\n output = self.activation(net_input)\n errors = (y - output)\n self.w_[1:] += self.eta * X.T.dot(errors)\n self.w_[0] += self.eta * errors.sum()\n cost = (errors**2).sum()/2.0\n self.cost_.append(cost)\n return self","def train_logistic_regression(train_exs: List[SentimentExample], feat_extractor: FeatureExtractor) -> LogisticRegressionClassifier:\n lr = LogisticRegressionClassifier(feat_extractor.corpus_length, feat_extractor)\n alpha = 1e0\n # beta = 1e-4\n for epoch in range(8):\n loss = 0.\n acc = 0\n indices = np.arange(len(train_exs))\n np.random.shuffle(indices)\n for i in indices:\n feat = feat_extractor.feats[i]\n sentimentExample = train_exs[i]\n y = sentimentExample.label\n z = 1 / (1 + np.exp(-feat.dot(np.expand_dims(lr.w, axis=1))))[0, 0]\n loss += -y * np.log(z) - (1 - y) * np.log(1 - z) \\\n # + beta * np.expand_dims(lr.w, axis=0).dot(np.expand_dims(lr.w, axis=1))[0, 0]\n predict = int(feat.dot(np.expand_dims(lr.w, axis=1))[0, 0] > 0)\n acc += (predict == y)\n grad = (z - y) * feat.toarray()[0] # + 2 * beta * lr.w\n lr.w = lr.w - alpha * grad\n print(\"epoch {:d}, loss: {:f}, accuracy: {:f}\".format(epoch, loss / len(train_exs), acc / len(train_exs)))\n\n for i in indices:\n feat = feat_extractor.feats[i]\n sentimentExample = train_exs[i]\n y = sentimentExample.label\n z = 1 / (1 + np.exp(-feat.dot(np.expand_dims(lr.w, axis=1))))[0, 0]\n loss += -y * np.log(z) - (1 - y) * np.log(1 - z)\n print(\"training loss: {:f}\".format(loss / len(train_exs)))\n\n return lr","def train(self, obs, fcst):\n D = obs.shape[0]\n LT = obs.shape[1]\n L = obs.shape[2]\n w1 = np.zeros(LT)\n w2 = np.zeros(LT)\n l = 0\n o = obs[:, :, :]\n f = fcst[:, :, :]\n bias = o - f\n\n model = sklearn.linear_model.LinearRegression()\n\n for lt in range(LT):\n day = int(np.floor(lt / 24.0)) + 1\n p = np.zeros([(D-day)*L, 2])\n a = np.zeros([(D-day)*L])\n for l in range(L):\n I = range(l*(D-day), (l+1)*(D-day))\n p[I, 0] = bias[day:, 0, l]\n p[I, 1] = bias[0:-day, lt, l]\n a[I] = bias[day:, lt, l]\n I = np.where(np.isnan(np.min(p, axis=1) + a)==0)[0]\n model.fit(p[I, :], a[I])\n w1[lt] = model.coef_[0]\n w2[lt] = model.coef_[1]\n\n self.weight_recent = w1\n self.weight_yesterday = w2\n return w1, w2","def train_step(model, optimizer, x):\n\n with tf.GradientTape() as tape:\n loss, RE, KL = model.loss(x, average=True)\n\n gradients = tape.gradient(loss, model.trainable_variables)\n optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n\n return loss, RE, KL","def train(self, X_train, y_train, batch_size, num_epochs, alpha=0.8):\r\n batch_split = tf.data.Dataset.from_tensor_slices((X_train, y_train))\r\n batch_split = batch_split.batch(batch_size)\r\n for epoch in range(num_epochs):\r\n for step, (i,j) in enumerate(batch_split):\r\n with tf.GradientTape() as tape:\r\n predictions = self.predict(i)\r\n loss = self.calculate_loss(j, predictions)\r\n dloss_dw, dloss_db = tape.gradient(loss, [self.weights, self.biases])\r\n for k in range(len(self.weights)):\r\n self.weights[k].assign_sub(alpha * dloss_dw[k])\r\n self.biases[k].assign_sub(alpha * dloss_db[k])","def train(self, X, Y, num_iterations = 1000, learning_rate = 0.01, print_cost = False, plot_cost = False):\n costs = []\n \n for i in range(num_iterations + 1):\n grads, cost = self.propagate(X,Y)\n \n # Retrieve derivatives from grads\n dw = grads[\"dw\"]\n db = grads[\"db\"]\n \n # Update rule\n self.weight = self.weight - learning_rate * dw\n self.bias = self.bias - learning_rate * db\n \n # Record the costs\n if i % 100 == 0:\n costs.append(cost)\n \n # Print the cost every 100 training examples\n if print_cost and i % 100 == 0:\n print(f\"cost after iteration: {i} is {np.round(cost, 4)}\")\n \n grads = {\"dw\": dw,\n \"db\": db}\n\n if plot_cost:\n plt.plot(np.arange(len(costs)) * 100, costs)\n plt.xlabel(\"epoch\")\n plt.ylabel(\"cost\")\n plt.title(f\"Logistic curve fitting loss function (learning rate={learning_rate})\")\n plt.show()\n \n return grads, costs","def train(self, x, t):\n self.model.fit(x, t)","def train(self, x, t):\n self.model.fit(x, t)","def train(self, x, t):\n self.model.fit(x, t)","def train(self, x, t):\n self.model.fit(x, t)","def train(self, x, t):\n self.model.fit(x, t)","def train(self):\n learning_rate = tf.train.exponential_decay(self.learning_rate, self.global_step, self.decay_steps,self.decay_rate, staircase=True)\n self.learning_rate_=learning_rate\n #noise_std_dev = tf.constant(0.3) / (tf.sqrt(tf.cast(tf.constant(1) + self.global_step, tf.float32))) #gradient_noise_scale=noise_std_dev\n train_op = tf_contrib.layers.optimize_loss(self.loss_val, global_step=self.global_step,\n learning_rate=learning_rate, optimizer=\"Adam\",clip_gradients=self.clip_gradients)\n return train_op","def fit(self, X, y, **kwargs):\n\n start_time = time.time()\n self.X = X\n self.y = y\n\n # Normalize inputs and outputs if the respective flags were set\n self.normalize_data()\n\n self.y = self.y[:, None]\n\n # Create the neural network\n # self._init_nn()\n\n optimizer = optim.Adam(self.model.parameters(),\n lr=self.mlp_params[\"learning_rate\"])\n\n if self.tb_logging:\n self.tb_writer.add_graph(self.model, torch.rand(size=[self.batch_size, self.mlp_params[\"input_dims\"]],\n dtype=torch.float, requires_grad=False))\n\n # Start training\n self.model.train()\n lc = np.zeros([self.mlp_params[\"num_epochs\"]])\n for epoch in range(self.mlp_params[\"num_epochs\"]):\n\n epoch_start_time = time.time()\n\n train_err = 0\n train_batches = 0\n\n for inputs, targets in self.iterate_minibatches(self.X, self.y, shuffle=True, as_tensor=True):\n optimizer.zero_grad()\n output = self.model(inputs)\n\n loss = torch.nn.functional.mse_loss(output, targets)\n loss.backward()\n optimizer.step()\n\n train_err += loss\n train_batches += 1\n\n lc[epoch] = train_err / train_batches\n curtime = time.time()\n epoch_time = curtime - epoch_start_time\n total_time = curtime - start_time\n\n if self.tb_logging:\n # self.log_train_loss(scalar_value=lc[-1], global_step=(epoch + 1) * self.batch_size)\n self.log_train_loss(scalar_value=lc[epoch], global_step=epoch + 1)\n\n if epoch % 100 == 99:\n logger.debug(\"Epoch {} of {}\".format(epoch + 1, self.mlp_params[\"num_epochs\"]))\n logger.debug(\"Epoch time {:.3f}s, total time {:.3f}s\".format(epoch_time, total_time))\n logger.debug(\"Training loss:\\t\\t{:.5g}\".format(train_err / train_batches))\n if self.log_plots:\n try:\n plotter = kwargs[\"plotter\"]\n self.tb_writer.add_figure(tag=TAG_TRAIN_FIG, figure=plotter(self.predict), global_step=epoch + 1)\n except KeyError:\n logger.debug(\"No plotter specified. Not saving plotting logs.\")\n self.log_plots = False\n\n return","def _fit(self, _X, _y):\n\n self.model = linear_model.LogisticRegression(penalty=self.penalty, random_state=self.seed,\n solver='saga', n_jobs=self.n_jobs)\n self.model.fit(_X, _y)","def linreg_stochastic_grad(X, y, alpha=.01):\n m = X.shape[0]\n n = X.shape[1]\n theta = np.zeros(n)\n for i in range(m):\n delta = alpha * (np.dot(theta.transpose(), X[i,:]) -y[i]) * X[i,:]\n theta = theta - delta\n return theta","def train_step(model, x, optimizer):\n with tf.GradientTape() as tape:\n loss = compute_loss(model, x)\n gradients = tape.gradient(loss, model.trainable_variables)\n optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n return loss","def trainData(self, X, y, NeuralNet, epochs):","def train(self, X, y, lr, epoch, method='adam', quit=1e-4):\n if len(y.shape) == 1:\n y = y.reshape((-1, 1))\n if not (0 < lr < 1):\n raise self.ANNException('learning rate cannot be negative or exceeds 1')\n if epoch <= 0:\n raise self.ANNException('epoch must be postitive integer')\n if method == 'gd':\n for _ in range(epoch):\n nodes = self._forward(X)\n self._backpropagate(y, nodes, lr)\n elif method == 'adam':\n alpha = 0.1\n beta1 = 0.5\n beta2 = 0.999\n epsilon = 1e-8\n mt = np.zeros(shape=self.weight.shape)\n vt = np.zeros(shape=self.weight.shape)\n before_err = self._energy(X, y)\n for t in range(1, epoch+1):\n nodes = self._forward(X)\n gt = self._backpropagate(y, nodes, alpha, ret=True)\n mt = beta1*mt + (1-beta1)*gt\n vt = beta2*vt + (1-beta2)*gt**2\n mthat = mt / (1-np.power(beta1, t))\n vthat = vt / (1-np.power(beta2, t))\n self.weight -= alpha * mthat/(np.sqrt(vthat)+epsilon)\n after_err = self._energy(X, y)\n if 0 < after_err-before_err < quit:\n return\n else:\n before_err = after_err\n else:\n raise self.ANNException('only gd and adam optimizer are supported')","def fit(self, w):\n w_former = w\n w_next = w\n w_t = w\n w_t_100 = w\n w_diff = 10000\n i = 0\n #tim_beg = t.time()\n # use two part to calculate the a(w,w0):calculate the gradient using regular or SDG, batch = 10\n # calculate the gradient and update the w,w0\n while i < 10000 and np.abs(w_diff) > 0.00001:\n loss_func = self.lost\n grads = self.gradient(loss_func)\n # calculate the y_pred(eta)\n w_next = w_former - grads(w_former) / (10000)\n k =self.lost(w_next) - self.lost(w_former)\n m = np.dot(w_next-w_former, grads(w_former).T)\n if i != 0 and i % 100 == 0:\n w_t = w_t_100\n w_t_100 = w_next\n w_diff = 1 / len(w) * (np.sum(np.abs(w_t_100 - w_t)))\n i_loss = self.lost(w_next)\n print(\"Iteration < %d > with loss < %f >\" % (i, i_loss))\n #self.los_plt.append(i_loss)\n #tim = t.time() - tim_beg\n #self.tim.append(tim)\n i += 1\n w_former = w_next\n #plt.plot(self.tim, self.los_plt)\n #plt.xlabel(\"time\")\n #plt.ylabel('loss')\n #plt.show()\n if i >= 10000:\n print(\"~Optimization stops because finishing iteration~\")\n if np.abs(w_diff) <= 0.00001:\n print(\"~Optimization stops because of difference between weights are less than 0.00001~\")\n self.w_result = w_next"],"string":"[\n \"def train(self, loss_function='logistic',\\n lr=0.1, decay=0.5, max_iters=3000, batch_size=128, **kwargs):\\n return super(LogisticRegression, self).train('sgd', loss_function,\\n lr=lr,\\n decay=decay, max_iters=max_iters,\\n batch_size=batch_size, **kwargs)\",\n \"def train(self,features,y):\\r\\n \\r\\n if self.learn_type == \\\"nn\\\":\\r\\n #generate supervised dataset\\r\\n return(self.learner.train_on_batch(features,y))\\r\\n elif self.learn_type == \\\"linear\\\":\\r\\n grad = 0\\r\\n n = len(features)\\r\\n for i in range(n):\\r\\n #sum over the instances to get an estimate of the gradient\\r\\n print((y[i] - self.learner.activate(features[i])))\\r\\n grad -= (y[i] - self.learner.activate(features[i])) * \\\\\\r\\n self.learner.grad(features[i])\\r\\n grad /= n\\r\\n #update paramter\\r\\n param = np.copy(self.learner.param)\\r\\n self.learner.param = param - self.alpha * grad\\r\\n #print(self.learner.param)\\r\",\n \"def train_model(X_train, y_train):\\n rgs = linear_model.Lasso(alpha=0.1)\\n rgs.fit(X_train, y_train)\\n return rgs\",\n \"def run_linear_regression(data_x, data_y):\\n iteration_s = 100\\n alpha = 0.0001550\\n\\n no_features = data_x.shape[1]\\n len_data = data_x.shape[0]\\n print(\\\"no_feature :, len_data: \\\", no_features , len_data)\\n #intinilize the the\\n theta = np.zeros(no_features)\\n #iterations how many time do\\n for i in range(0,iteration_s):\\n theta = run_steep_gradient_descent(data_x, data_y, len_data, alpha, theta)\\n error = sum_of_square_error(data_x, data_y, len_data, theta)\\n print(\\\"at iteration %d - Error is %.5f \\\" % (i+1, error))\\n print(\\\"theta shape\\\", theta.shape)\\n return theta\",\n \"def train_gradient_descent(self, X, y, learning_rate=0.01, n_iters=100):\\r\\n # Step 0: Initialize the parameters\\r\\n n_samples, n_features = X.shape\\r\\n self.weights = np.zeros(shape=(n_features,1))\\r\\n self.bias = 0\\r\\n costs = []\\r\\n\\r\\n for i in range(n_iters):\\r\\n # Step 1: Compute a linear combination of the input features and weights\\r\\n y_predict = np.dot(X, self.weights) + self.bias\\r\\n\\r\\n # Step 2: Compute cost over training set\\r\\n cost = (1 / n_samples) * np.sum((y_predict - y)**2)\\r\\n costs.append(cost)\\r\\n\\r\\n if i % 100 == 0:\\r\\n print(f\\\"Cost at iteration {i}: {cost}\\\")\\r\\n\\r\\n # Step 3: Compute the gradients\\r\\n dJ_dw = (2 / n_samples) * np.dot(X.T, (y_predict - y))\\r\\n dJ_db = (2 / n_samples) * np.sum((y_predict - y)) \\r\\n \\r\\n # Step 4: Update the parameters\\r\\n self.weights = self.weights - learning_rate * dJ_dw\\r\\n self.bias = self.bias - learning_rate * dJ_db\\r\\n\\r\\n return self.weights, self.bias, costs\",\n \"def LSTM_train(X_train, Y_train, X_dev, Y_dev, R_train, R_dev, hyperparams):\",\n \"def train(self, X, y, learning_rate=1e-3, reg=1e-5, num_iters=100,\\n batch_size=200, verbose=False):\\n num_train, dim = X.shape\\n num_classes = np.max(y) + 1 # assume y takes values 0...K-1 where K is number of classes\\n if self.W is None:\\n self.W = np.random.randn(dim, num_classes) * 0.001\\n\\n # Run stochastic gradient descent to optimize W\\n loss_history = []\\n for it in xrange(num_iters):\\n batch_ind = np.random.choice(X.shape[0],batch_size, replace=True)\\n X_batch = X[batch_ind]\\n y_batch = y[batch_ind]\\n\\n # Step One: Implement Stochastic\\n #########################################################################\\n # Sample batch_size elements from the training data and their #\\n # corresponding labels to use in this round of gradient descent. #\\n # Store the data in X_batch and their corresponding labels in #\\n # y_batch; after sampling X_batch should have shape (batch_size, dim) #\\n # and y_batch should have shape (batch_size,) #\\n # #\\n # Hint: Use np.random.choice to generate indices. Sampling with #\\n # replacement is faster than sampling without replacement. #\\n #########################################################################\\n\\n # Step Two: Implement Gradient\\n # Simply call self.loss (which calls svm_loss_vectorized) to evaluate loss and gradient\\n loss, dW = self.loss(X_batch,y_batch,reg)\\n loss_history.append(loss)\\n\\n # Step Three: Implement Descent\\n # Simply update the weights using the gradient and the learning rate. #\\n self.W -= dW*learning_rate\\n\\n if verbose and it % 100 == 0:\\n print('iteration %d / %d: loss %f' % (it, num_iters, loss))\\n\\n return loss_history\",\n \"def train(self, X_, y, reg=1e-4, lr=0.1, epochs=5, batch_size=16):\\n\\n X = np.c_[np.ones(X_.shape[0]), X_] # Add one for bias to the first columns\\n ### YOUR CODE HERE\\n self.w = log_reg.mini_batch_grad_descent(X, y, reg=reg, lr=lr, batch_size=batch_size, epochs= epochs)\\n assert self.w.shape[0] == X.shape[1]\\n ### END CODE\",\n \"def LinReg_fit(X, y, X_test=None, y_test=None, lr=1e-7, batch=1, lamb=0,\\n epoch=10000, print_every=100, lamb1=0, momentum=0):\\n # initialize\\n W = np.random.randn(X.shape[1]) / X.shape[1] / X.shape[0]\\n\\n train_loss = []\\n train_RMSE = []\\n test_loss = []\\n test_RMSE = []\\n\\n # batch size indicator\\n b = 0\\n # cache for adagrad\\n G = np.zeros(W.shape)\\n\\n for i in range(epoch):\\n inds = []\\n last_step = 0\\n\\n for j in np.random.permutation(X.shape[0]):\\n inds.append(j)\\n b += 1\\n\\n # do the adagrad to update the parameter\\n if b >= batch:\\n diff = X[inds].dot(W) - y[inds]\\n\\n # calculate gradients\\n w = np.array(W)\\n w[w > 0] = 1\\n w[w < 0] = -1\\n grad_X = X[inds].T.dot(diff)\\n grad_regulariz = lamb * W * batch / X.shape[0]\\n grad_first_order_reg = lamb1 * w * batch / X.shape[0]\\n grad = grad_X + grad_regulariz + grad_first_order_reg\\n\\n # calculate update step\\n G += grad**2\\n delta_W = (grad + momentum * last_step) / np.sqrt(G)\\n W -= lr * delta_W\\n\\n # reset variables\\n last_step = delta_W\\n b = 0\\n inds = []\\n\\n objective = (((X.dot(W) - y)**2).sum() + lamb * (W**2).sum()) / 2.0\\n RMSE = cal_RMSE(X, W, y)\\n\\n if X_test is not None and y_test is not None:\\n # losses\\n loss_X = ((X_test.dot(W) - y_test)**2).sum() / 2.0\\n loss_reg = lamb * (W**2).sum() / 2.0\\n loss_first_reg = lamb1 * (abs(W).sum())\\n\\n obj_t = loss_X + loss_reg + loss_first_reg\\n RMSE_t = cal_RMSE(X_test, W, y_test)\\n\\n test_loss.append(obj_t)\\n test_RMSE.append(RMSE_t)\\n\\n # print out the progress\\n if i % print_every == 0:\\n if X_test is not None and y_test is not None:\\n print('\\\\tepoch: %d; obj: %.4f; RMSE: %.4f; RMSE_test: %.4f' %\\n (i, objective, RMSE, RMSE_t))\\n else:\\n print('\\\\tepoch: %d; obj: %.4f; RMSE: %.4f' %\\n (i, objective, RMSE))\\n\\n train_loss.append(objective)\\n train_RMSE.append(RMSE)\\n\\n print('final obj: %.4f' % train_loss[-1])\\n\\n return W, train_loss, train_RMSE, test_loss, test_RMSE\",\n \"def train_lr(x, y, lamb):\\n \\n # TODO: implement the function.\\n # initialize parameters w and b\\n w = tf.Variable([0.0])\\n b = tf.Variable(0.0)\\n\\n # set an optimizer\\n # please check the documentation of tf.keras.optimizers.SGD\\n optim = tf.keras.optimizers.SGD(learning_rate = 0.001)\\n\\n # loop to optimize w and b \\n for i in range(1000):\\n\\n with tf.GradientTape() as gt:\\n gt.watch([w, b])\\n y_hat = regression_func(x, w, b)\\n loss = loss_func(y, y_hat)\\n\\n dw, db = gt.gradient(loss, [w,b])\\n\\n del gt\\n\\n optim.apply_gradients(zip([dw,db],[w,b]))\\n\\n\\n return w, b\",\n \"def _stochastic_gradient_descent(self, X, y, lr, epochs, sample_rate):\\n\\n # Initialize the bias and weights.\\n m, n = X.shape\\n self.bias = 0\\n self.weights = np.random.normal(size=n)\\n\\n n_sample = int(m * sample_rate)\\n for i in range(epochs):\\n for idx in choice(range(m), n_sample, replace=False):\\n # Calculate the gradient delta of each sample\\n grad_bias, grad_weights = self._get_gradient(X[idx], y[idx])\\n\\n # Update the bias and weight by gradient of current sample\\n self.bias += lr * grad_bias\\n self.weights += lr * grad_weights\\n\\n # Show the gradient of each epoch.\\n grad_bias, grad_weights = self._get_gradient(X, y)\\n grad = (grad_bias + grad_weights.mean()) / 2\\n print(\\\"Epochs %d gradient %.3f\\\" % (i + 1, grad), flush=True)\",\n \"def train(self, X, y, learning_rate=1e-3, reg=1e-5, num_iters=100,\\n batch_size=200, verbose=False):\\n num_train, dim = X.shape\\n num_classes = np.max(y) + 1 # assume y takes values 0...K-1 where K is number of classes\\n if self.W is None:\\n # lazily initialize W\\n self.W = 0.001 * np.random.randn(dim, num_classes)\\n\\n # Run stochastic gradient descent to optimize W\\n loss_history = []\\n for it in range(num_iters):\\n X_batch = None\\n y_batch = None\\n\\n #########################################################################\\n # TODO: #\\n # Sample batch_size elements from the training data and their #\\n # corresponding labels to use in this round of gradient descent. #\\n # Store the data in X_batch and their corresponding labels in #\\n # y_batch; after sampling X_batch should have shape (batch_size, dim) #\\n # and y_batch should have shape (batch_size,) #\\n # #\\n # Hint: Use np.random.choice to generate indices. Sampling with #\\n # replacement is faster than sampling without replacement. #\\n #########################################################################\\n choices = np.random.choice(num_train, batch_size)\\n X_batch = X[choices]\\n y_batch = y[choices]\\n #########################################################################\\n # END OF YOUR CODE #\\n #########################################################################\\n\\n # evaluate loss and gradient\\n loss, grad = self.loss(X_batch, y_batch, reg)\\n loss_history.append(loss)\\n\\n # perform parameter update\\n #########################################################################\\n # TODO: #\\n # Update the weights using the gradient and the learning rate. #\\n #########################################################################\\n self.W -= learning_rate * grad\\n #########################################################################\\n # END OF YOUR CODE #\\n #########################################################################\\n\\n if verbose and it % 100 == 0:\\n print('iteration %d / %d: loss %f' % (it, num_iters, loss))\\n\\n return loss_history\",\n \"def train(self, x, y, lr):\\n self.forward(x)\\n self.backward(y)\\n self.update(lr)\\n return\",\n \"def fit(self, X, y, max_iter=MAX_ITER):\\n X = self.normalize_data(X)\\n X = self.add_bias(X)\\n n_tasks = len(X)\\n n_feats = X[0].shape[1]\\n W = np.random.randn(n_feats, n_tasks)\\n start = time.time()\\n cost_function = 0\\n for t in range(n_tasks):\\n #print('Training {} task with lasso regression'.format(t))\\n lasso = Lasso(alpha=self.lambda_1, positive=self.positive, max_iter=max_iter)\\n lasso.fit(X[t], y[t])\\n W[:, t] = lasso.coef_\\n cost_function += np.linalg.norm(np.dot(X[t], W[:, t]) - y[t]) \\\\\\n + sum(abs(W[:, t]))\\n stop = time.time() - start\\n self.W = W\\n return W, np.array([cost_function]), stop\",\n \"def train(self):\\n df = self.df\\n self.scaler = MinMaxScaler()\\n self.scaler.fit(df)\\n df[df.columns] = self.scaler.transform(df)\\n\\n\\n X_train, y_train = get_X_y(df, self.n_days, self.length , self.style)\\n\\n self.model = lstm_model(self.length, self.n_days, self.features, self.style)\\n\\n #es = EarlyStopping(monitor = 'accuracy',mode = 'min' , verbose = 1, patience = 100, restore_best_weights = True)\\n\\n self.history = self.model.fit(np.array(X_train), np.array(y_train),\\n #validation_split = 0.3,\\n #callbacks = [es],\\n epochs = 200,\\n batch_size = 64,\\n shuffle = True,\\n verbose = True)\",\n \"def fit(self, X, y, alpha, n_epochs):\\n y = self.__one_hot(y)\\n \\n # perform training epochs\\n for i in range(n_epochs):\\n print(\\\"Epoch\\\", i)\\n # stochastic gradient descent\\n for j in range(len(X)):\\n self.__backpropagation(X[j], y[j], alpha)\",\n \"def train(self):\\n df = self.df\\n self.scaler = MinMaxScaler()\\n self.scaler.fit(df)\\n df[df.columns] = self.scaler.transform(df)\\n\\n\\n X_train, y_train = get_X_y(df, self.n_days, self.length , self.style)\\n X_train = np.array(X_train)\\n X_train.shape = (X_train.shape[0], X_train.shape[2])\\n\\n self.clf = LogisticRegression().fit(X_train, y_train)\\n\\n #es = EarlyStopping(monitor = 'accuracy',mode = 'min' , verbose = 1, patience = 100, restore_best_weights = True)\",\n \"def fit(self, X, y, max_iter=MAX_ITER):\\n X = self.normalize_data(X)\\n X = self.add_bias(X)\\n n_tasks = len(X)\\n n_feats = X[0].shape[1]\\n W = np.random.randn(n_feats, n_tasks)\\n start = time.time()\\n cost_function = 0\\n for t in range(n_tasks):\\n #print('Training {} task with lasso regression'.format(t))\\n lasso = LogisticRegression(C=self.lambda_1,\\n penalty='l1',\\n max_iter=max_iter)\\n lasso.fit(X[t], y[t])\\n W[:, t] = lasso.coef_\\n stop = time.time() - start\\n self.W = W\\n return W, np.array([cost_function]), stop\",\n \"def trainLogRegres(train_x, train_y, opts):\\n startTime = time.time() # calculate training time\\n\\n numSamples, numFeatures = np.shape(train_x)\\n alpha = opts['alpha']\\n maxIter = opts['maxIter']\\n weights = np.ones((numFeatures, 1))\\n\\n for k in range(maxIter):\\n if opts['optimizeType'] == 'stocGradDescent': # stochastic gradient descent\\n for i in range(numSamples):\\n output = sigmoid(train_x[i, :] * weights)\\n loss = train_y[i, 0] - output\\n weights = weights + alpha * train_x[i, :].transpose() * loss\\n elif opts[\\n 'optimizeType'] == 'smoothStocGradDescent': # smooth stochastic gradient descent. randomly select samples to optimize for reducing cycle fluctuations.\\n dataIndex = list(range(numSamples))\\n for i in range(numSamples):\\n alpha = 4.0 / (1.0 + k + i) + 0.01\\n randIndex = int(np.random.uniform(0, len(dataIndex)))\\n output = sigmoid(train_x[randIndex, :] * weights)\\n loss = train_y[randIndex, 0] - output\\n weights = weights + alpha * train_x[randIndex, :].transpose() * loss\\n del (dataIndex[randIndex])\\n print('Congratulations, training complete! Took %fs!' % (time.time() - startTime))\\n return weights\",\n \"def train(self, X, y):\\n m,d = X.shape\\n D = np.array([1/m] * m)\\n for t in range(self.T):\\n self.h[t] = self.WL(D,X,y)\\n h_t = self.h[t].predict(X)\\n epsilon_t = np.sum(np.logical_not(y==h_t) * D)\\n self.w[t] = 0.5 * np.log((1/epsilon_t) - 1)\\n n = np.sum([D * np.exp(-1 * self.w[t] * y * h_t)])\\n D = (D * np.exp(-1 * self.w[t] * y * h_t)) / n\",\n \"def train_step(x, y):\\n with tf.GradientTape() as tape:\\n predictions = self.model(x)\\n loss = self.loss_object(y, predictions)\\n gradients = tape.gradient(loss, self.model.trainable_variables)\\n self.optimizer.apply_gradients(zip(gradients, self.model.trainable_variables))\\n\\n self.train_loss(loss)\\n self.train_acc(y, predictions)\",\n \"def fit(self, X, y):\\n # Make sure inputs are numpy arrays.\\n X = np.array(X)\\n y = np.array(y)\\n # Add x_0 = 1 to each instance for the bias term.\\n X = np.c_[np.ones((X.shape[0], 1)), X]\\n # Store number of samples and features in variables.\\n n_samples, n_features = np.shape(X)\\n self.training_errors = []\\n # Initialize weights randomly from normal distribution.\\n self.coef_ = np.random.randn(n_features, 1)\\n # Batch gradient descent for number iterations = n_iter.\\n for _ in range(self.n_iter):\\n y_preds = X.dot(self.coef_)\\n # Penalty term if regularized (don't include bias term).\\n regularization = self.regularization(self.coef_[1:])\\n # Calculate mse + penalty term if regularized.\\n cost_function = mean_squared_error(y, y_preds) + regularization\\n if cost_function > self.threshold:\\n break\\n self.training_errors.append(cost_function) \\n # Regularization term of gradients (don't include bias term).\\n gradient_reg = self.regularization.grad(self.coef_[1:])\\n # Gradients of loss function.\\n gradients = (2/n_samples) * X.T.dot(y_preds - y)\\n gradients += gradient_reg\\n # Update the weights.\\n self.coef_ -= (self.lr * gradients.sum(axis=1)).reshape(-1, 1)\\n\\n return self\",\n \"def fit(self, x, y):\\n def initiate_theta(dim):\\n self.theta = np.zeros(dim)\\n # print('self.theta initiated is {}'.format(self.theta))\\n \\n def implement_sigmoid(x):\\n if self.theta is None:\\n initiate_theta(x.shape[1])\\n z = np.matmul(np.transpose(self.theta), np.transpose(x))\\n return 1/(np.ones(x.shape[0]) + np.exp(-z))\\n \\n def implement_partial_loss(x, y):\\n return -np.matmul(np.transpose(y - implement_sigmoid(x)), x)/x.shape[0]\\n \\n def implement_transposed_hess(x):\\n sigmoid_hadamard = implement_sigmoid(x) * (np.ones(x.shape[0]) - implement_sigmoid(x))\\n hess2 = np.diag(sigmoid_hadamard)\\n hess = np.matmul(hess2,x)\\n hess = np.matmul(np.transpose(x),hess)/x.shape[0]\\n hess_inverse = np.linalg.inv(hess)\\n return hess_inverse\\n \\n def train(x, y):\\n count = 0\\n if self.theta is None:\\n initiate_theta(x.shape[1])\\n while count < self.max_iter:\\n if self.verbose:\\n loss_y1 = np.matmul(np.transpose(y), np.log(implement_sigmoid(x)))\\n loss_y0 = np.matmul(np.transpose(np.ones(x.shape[0]) - y), np.log(np.ones(x.shape[0]) - implement_sigmoid(x)))\\n loss = -(loss_y1 + loss_y0 )/x.shape[0]\\n print('Average empirical loss for step {} is {}'.format(count, loss))\\n delta = np.matmul(implement_transposed_hess(x), implement_partial_loss(x, y))\\n new_theta = self.theta - delta * self.step_size\\n delta_theta = np.linalg.norm(new_theta - self.theta)\\n # print('delta is {}'.format(delta_theta))\\n if delta_theta < self.eps:\\n return new_theta\\n else:\\n self.theta = new_theta\\n count += 1\\n return self.theta\\n \\n return train(x, y)\",\n \"def train_LR(self, X, y, eta=1e-3, batch_size=1, num_iters=1000) :\\n loss_history = []\\n N,d = X.shape\\n for t in np.arange(num_iters):\\n X_batch = None\\n y_batch = None\\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Sample batch_size elements from the training data for use in gradient descent. \\n # After sampling, X_batch should have shape: (batch_size,1), y_batch should have shape: (batch_size,)\\n # The indices should be randomly generated to reduce correlations in the dataset. \\n # Use np.random.choice. It is better to user WITHOUT replacement.\\n # ================================================================ #\\n \\n # sample indices without replacement\\n batch_idx = np.random.choice(N, batch_size, replace = False)\\n X_batch = X[batch_idx]\\n y_batch = y[batch_idx]\\n \\n \\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n loss = 0.0\\n grad = np.zeros_like(self.w)\\n # ================================================================ #\\n # YOUR CODE HERE: \\n # evaluate loss and gradient for batch data\\n # save loss as loss and gradient as grad\\n # update the weights self.w\\n # ================================================================ #\\n \\n # compute the loss and gradient\\n # loss_and_grad will take responsible for these\\n \\n loss, grad = self.loss_and_grad(X_batch, y_batch)\\n \\n self.w = self.w - eta * grad\\n \\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n loss_history.append(loss)\\n return loss_history, self.w\",\n \"def train(self, X_, y, reg=1e-4, lr=0.1, epochs=5, batch_size=16):\\n # set up classes and make y into a matrix 1 in k encoded\\n self.classes = np.sort(np.unique(y))\\n num_classes = self.classes.size\\n y_as_matrix = np.zeros((y.size, num_classes))\\n y_as_matrix[np.arange(y.shape[0]), y] = 1\\n X = np.c_[np.ones(X_.shape[0]), X_] # add bias variable 1\\n ### YOUR CODE HERE\\n self.w = soft_reg.mini_batch_grad_descent(X, y_as_matrix, reg=reg, lr=lr, epochs=epochs, batch_size=batch_size)\\n ### END CODE\",\n \"def _gradient_descent(self, X, y, epochs, learning_rate, batch_size):\\n num_feats = X.shape[1]\\n num_samples = X.shape[0]\\n\\n y = y.reshape(num_samples, 1)\\n W = np.random.rand(num_feats, 1)\\n training_loss_epochs = []\\n\\n for ix in range(epochs):\\n shuffled_ix = (np.arange(0, len(X)))\\n np.random.shuffle(shuffled_ix)\\n X = X[shuffled_ix, :]\\n y = y[shuffled_ix, :]\\n\\n for batch_ix in np.arange(0, X.shape[0], batch_size):\\n dW = self._compute_gradient(W, X[batch_ix:batch_ix + batch_size], y[batch_ix:batch_ix + batch_size])\\n W -= learning_rate * dW\\n\\n if ix % 10 == 0:\\n y_pred = np.dot(X, W)\\n training_loss = self.mse(y, y_pred)\\n print('epoch {0} : training loss {1}'.format(ix, training_loss))\\n training_loss_epochs.append(training_loss[0])\\n\\n self.weights = W\\n self.training_loss = training_loss_epochs\\n return None\",\n \"def linearRegression(self, xtr, ytr, xte, yte):\\n LEARNING_RATE = 0.5\\n with self.graph.as_default() as graph:\\n with tf.name_scope('training'):\\n with tf.name_scope('loss'):\\n train_loss = tf.reduce_mean(\\n tf.square(self.y_train - self.y_placeholder))\\n with tf.name_scope('optimizer'):\\n optimizer = tf.train.GradientDescentOptimizer(LEARNING_RATE)\\n train = optimizer.minimize(train_loss) \\n # test loss may be different\\n with tf.name_scope('test'):\\n with tf.name_scope('loss'):\\n test_loss = tf.reduce_mean(\\n tf.square(self.y_test - self.y_placeholder))\\n with tf.Session() as sess:\\n # Save the variables to disk.\\n model_dir = \\\"./ckpt/\\\"\\n builder = tf.saved_model.builder.SavedModelBuilder(model_dir)\\n\\n # Initialize variables\\n sess.run(tf.global_variables_initializer())\\n TRAIN_STEPS = 201\\n\\n for step in range(TRAIN_STEPS):\\n sess.run([train], \\n feed_dict={self.x_placeholder: xtr, \\n self.y_placeholder: ytr})\\n if step % 20 == 0:\\n test_loss_val = sess.run([test_loss],\\n feed_dict={self.x_placeholder: xte, \\n self.y_placeholder: yte})\\n print('step {}, test loss is {}'.format(\\n step, test_loss_val))\\n\\n # Final training results\\n a = sess.run(self.a)\\n b = sess.run(self.b)\\n # Draw result\\n minx=np.min(np.concatenate((xtr,xte)))\\n maxx=np.max(np.concatenate((xtr,xte)))\\n xref=np.linspace(minx,maxx,100)\\n plt.figure(0)\\n plt.plot(xref, a*xref+b, 'r.')\\n plt.plot(xtr, ytr, 'b.')\\n plt.plot(xte, yte, 'g.')\\n plt.show()\",\n \"def gradient_descent(self, x, y):\\n # Initialize weights vector\\n self.weights = np.zeros(len(x[0]))\\n\\n # Storing number of training example in a variable \\n n = len(x)\\n\\n # Initiate variables to keep track of the current and smallest loss recorded\\n lowest_loss = sys.float_info.max\\n current_loss = sys.float_info.max\\n\\n # Initiate variables to keep track of step sizes\\n norm = sys.float_info.max\\n smallest_norm = sys.float_info.max\\n\\n # Initiate list variable that stores all previous weights\\n prev_weights = []\\n\\n # Initiate list that stores all the errors. \\n errors = []\\n \\n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\\n k_loss_iteration = 1\\n\\n # Learning loop\\n for i in range(self.max_iter):\\n\\n # Append current weights\\n prev_weights.append(np.array(self.weights))\\n \\n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\\n\\n # Compute the error of the Cost Function and store it in a list\\n current_loss = self.cost(x,y)\\n\\n if len(errors) > 1 and current_loss > errors[-1]:\\n k_loss_iteration += 1\\n else: \\n k_loss_iteration = 1\\n\\n errors.append(current_loss)\\n \\n # Track smallest loss\\n if current_loss < lowest_loss:\\n lowest_loss = current_loss\\n\\n # Compute the L2 Norm of the difference between current weights and previous weights\\n norm = np.linalg.norm(self.weights - prev_weights[-1])\\n\\n # Track smallest step size and set it as error threshold\\n if norm < smallest_norm:\\n smallest_norm = norm\\n\\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\\n if self.error_threshold != None and norm < self.error_threshold:\\n print(\\\"Converged after {} iterations!\\\".format(i))\\n break\\n\\n # stop if error hasn't gone down in k iterations\\n if k_loss_iteration >= 10:\\n print(k_loss_iteration + \\\" iterations of loss not decreasing on {}th itertion.\\\".format(i))\\n break\\n\\n # Log final weights\\n print(\\\"Final norm: \\\" + str(norm) + \\\"\\\\nSmallest step size recorded: \\\" + str(smallest_norm) + \\\"\\\\nFinal error: \\\" + str(current_loss) + \\\"\\\\nLowest error recorded: \\\" + str(lowest_loss) + \\\"\\\\nNumber of epochs: \\\" + str(len(errors)) + \\\"\\\\nFinal weights: \\\" + str(self.weights))\",\n \"def train(self, X, y, learning_rate=1e-3, num_iters=100,\\n batch_size=200, verbose=False):\\n num_train, dim = X.shape\\n num_classes = np.max(y) + 1 # assume y takes values 0...K-1 where K is number of classes\\n\\n self.init_weights(dims=[np.max(y) + 1, X.shape[1]])\\t# initializes the weights of self.W\\n\\n # Run stochastic gradient descent to optimize W\\n loss_history = []\\n\\n for it in np.arange(num_iters):\\n X_batch = None\\n y_batch = None\\n\\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Sample batch_size elements from the training data for use in \\n # gradient descent. After sampling,\\n # - X_batch should have shape: (dim, batch_size)\\n # - y_batch should have shape: (batch_size,)\\n # The indices should be randomly generated to reduce correlations\\n # in the dataset. Use np.random.choice. It's okay to sample with\\n # replacement.\\n # ================================================================ #\\n mask = np.random.choice(num_train, batch_size, replace=True)\\n \\n X_batch = X[mask] # (dim, batch_size)\\n y_batch = y[mask] # (batch_size,)\\n \\n pass\\n \\n \\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n\\n # evaluate loss and gradient\\n loss, grad = self.fast_loss_and_grad(X_batch, y_batch)\\n loss_history.append(loss)\\n\\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Update the parameters, self.W, with a gradient step \\n # ================================================================ #\\n pass\\n \\n self.W = self.W - learning_rate*grad\\n \\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n\\n if verbose and it % 100 == 0:\\n print('iteration {} / {}: loss {}'.format(it, num_iters, loss))\\n\\n return loss_history\",\n \"def fit(self, X, y):\\n\\t\\t# TODO insert stack of 1 for bias\\n\\t\\tX = np.insert(X, 0, 1, axis=1)\\n\\t\\tself.errors = []\\n\\t\\tself.initialize_weights(n_features=X.shape[1])\\n\\t\\t\\n\\t\\t# TODO gradient descent for n_iter\\n\\t\\tfor _ in range(self.n_iter):\\n\\t\\t\\ty_pred = X.dot(self.weights)\\n\\t\\t\\t# calculate l2 loss\\n\\t\\t\\tmse = np.mean(0.5 * (y - y_pred)**2 + self.regularization(self.weights))\\n\\t\\t\\tself.errors.append(mse)\\n\\t\\t\\t# calucalte gradiant of loss function w.r.t weights\\n\\t\\t\\tgrad_weights = -(y - y_pred).dot(X) + self.regularization.grad(self.weights)\\n\\t\\t\\t# weight updation\\n\\t\\t\\tself.weights -= self.lr * grad_weights\",\n \"def learn(self, Xtrain, ytrain):\\n self.cost_data = []\\n self.weights = np.zeros((len(self.params['features']), 1))\\n numsamples = Xtrain.shape[0]\\n Xless = Xtrain[:,self.params['features']]\\n y = ytrain[:, np.newaxis]\\n\\n cur_cost = float(\\\"inf\\\")\\n tolerance = 10 ** -6\\n new_cost = self.cost(self.weights, Xless, y, self.params['regwgt'], numsamples)\\n while abs(new_cost - cur_cost) > tolerance:\\n cur_cost = new_cost\\n gradient = np.dot(np.transpose(Xless), np.subtract(np.dot(Xless, self.weights), y)) / numsamples #+ (2 * self.params['regwgt'] * self.weights)\\n step_size = self.line_search(self.weights, new_cost, gradient, Xless, y, self.params['regwgt'], numsamples)\\n self.weights = self.weights - (step_size * gradient)\\n new_cost = self.cost(self.weights, Xless, y, self.params['regwgt'], numsamples)\\n\\n #Format properly for the error function\\n self.weights = np.ndarray.flatten(self.weights)\",\n \"def learn(self, Xtrain, ytrain):\\n self.cost_data = []\\n self.weights = np.zeros((len(self.params['features']), 1))\\n numsamples = Xtrain.shape[0]\\n Xless = Xtrain[:,self.params['features']]\\n y = ytrain[:, np.newaxis]\\n epochs = 1000\\n\\n for epoch in range(epochs):\\n #Shuffle the data, making sure to maintain the proper correspondence between the features and targets\\n data_set = np.append(Xless, y, axis=1)\\n np.random.shuffle(data_set)\\n Xless = data_set[:, 0:data_set.shape[1] - 1]\\n y = data_set[:, -1, np.newaxis]\\n for t in range(numsamples):\\n gradient = np.dot(np.transpose(Xless[t, :][np.newaxis, :]), np.subtract(np.dot(Xless[t, :], self.weights), y[t, np.newaxis]))\\n step_size = 0.01 / (epoch + 1)\\n self.weights = self.weights - (step_size * gradient)\\n cur_cost = self.cost(self.weights, Xless[t, :], y[t])\\n #Format the array properly for the error function\\n self.weights = np.ndarray.flatten(self.weights)\",\n \"def train(self, iterations = 100):\\n arguments = ()\\n print(\\\"training...\\\")\\n results = optimize.minimize(self.CostFunction,x0 = self.Thetas, args = arguments, options = {'disp':True, 'maxiter': iterations}, method = \\\"L-BFGS-B\\\", jac = True)\\n self.Thetas = results['x']\\n FinalCost, _ = self.CostFunction(self.Thetas)\\n print(\\\"successfully trained the model\\\") \\n print(\\\"Final Cost for this model is:\\\", FinalCost)\",\n \"def train(self, X, y):\\n m = X.shape[0]\\n D = np.empty(m)\\n D.fill(1/(m*1.0))\\n\\n hs = 0\\n for t in range(self.T):\\n self.h[t] = self.WL(D,X,y)\\n eps = 0\\n\\n for j in range(m): \\n if (y[j]*(1.0) != self.h[t].predict(X)[j]):\\n eps+=D[j]\\n\\n self.w[t] =0.5*math.log((1/eps)-1)\\n\\n Dtmp = []\\n for j in range(m):\\n Dtmp.append(D[j]*math.exp(-1*self.w[t]*y[j]*(self.h[t].predict(X)[j])))\\n\\n Dtmp = np.array(Dtmp) \\n s = np.sum(Dtmp)\\n\\n for i in range(m):\\n D[i] = (D[i]*math.exp(-1*self.w[t]*y[i]*self.h[t].predict(X)[i]))/s\",\n \"def train(self, x, y):\\n try:\\n t_start = time.time()\\n self.managerlogger.logger.info(\\\"start lr..\\\")\\n self._model.fit(x, y)\\n self.managerlogger.logger.info(\\\"finished lr!\\\")\\n t_end = time.time()\\n self.managerlogger.logger.info(\\\"lr train time: %s\\\" % (t_end - t_start))\\n return runstatus.RunStatus.SUCC\\n except Exception as err:\\n self.managerlogger.logger.error(\\\"lr train error: %s \\\" % err)\\n self.errorlogger.logger.error(\\\"lr train error:\\\\n %s \\\" % traceback.format_exc())\\n return runstatus.RunStatus.FAILED\",\n \"def train_model(self):\\r\\n alpha, accuracy_rate = self.select_model()\\r\\n # Initialize logistic regression with alpha(learning rate)\\r\\n lg = logisticregression(C=alpha)\\r\\n # Train the model.\\r\\n lg.fit(self.training_data, self.target_data)\\r\\n # Save the trained model as .pkl file.\\r\\n joblib.dump(value=lg, filename=self.intention_id+'.pkl', compress=1)\\r\\n print \\\"Estimated Parameters of Logistic Regression\\\"\\r\\n # Estimated parameters of logistic regression.\\r\\n print lg.get_params()\",\n \"def fit(self, x, y):\\n # Note Logistic Regression Runtime\\n start_time = time.time()\\n\\n # Converting Pandas DataFrame to Numpy arrays\\n if not type(x).__module__ == np.__name__:\\n x = x.to_numpy()\\n if not type(y).__module__ == np.__name__:\\n y = y.to_numpy()\\n\\n # Insert a column of 1 in the feature vector X for the bias term in the weights\\n x = np.insert(x,0,1,axis=1)\\n \\n # Verify dimension of input\\n if len(x) != len(y):\\n print(\\\"The number of input features vector must be to be the same as the number of target variables\\\")\\n else:\\n losses = self.gradient_descent(x,y)\\n\\n # Note end time\\n end_time = time.time()\\n\\n # Log runtime\\n print(\\\"Logistic Regression training time: {0:.2f}s\\\".format(end_time - start_time))\\n \\n return losses\",\n \"def fit(self, X, y):\\n\\n n, m = X.shape[0], X.shape[1]\\n\\n # theta is (nx1) (one theta per dimension)\\n self.theta = np.random.uniform(-10, 10, (n, 1))\\n\\n for i in range(self.epochs):\\n # Get predictions\\n y_pred = self.predict(X)\\n\\n # calculate cost\\n # cost = ...\\n cost = self._cost_function(y_pred, y, m)\\n \\n\\n # gradient is an (n) x 1 array, it refers to the derivate per theta\\n gradient = self._cost_function_derivative(y_pred, y, X, m)\\n\\n # delta/update rule\\n self.theta = gradient\\n\\n self.costs.append(cost)\\n pass\\n\\n print(\\\"Final theta is {} (cost: {})\\\".format(self.theta.T, cost))\",\n \"def train(train_ds):\\n rng = random.PRNGKey(0)\\n\\n # initialise the model\\n py, params = GPModel.init(rng, train_ds['index_points'])\\n model = nn.Model(GPModel, params)\\n\\n # utility functions for packing and unpacking param dicts\\n par_from_array, array_from_par = build_par_pack_and_unpack(model)\\n\\n @jax.jit\\n def loss_fun(model: GPModel, params: dict) -> float:\\n \\\"\\\"\\\" This is clumsier than the usual FLAX loss_fn. \\\"\\\"\\\"\\n py = model.module.call(params, train_ds['index_points'])\\n return -py.log_prob(train_ds['y'])\\n\\n # wrap loss fun for scipy.optimize\\n def wrapped_loss_fun(arr):\\n params = par_from_array(arr)\\n return loss_fun(model, params)\\n\\n @jax.jit\\n def loss_and_grads(x):\\n return jax.value_and_grad(wrapped_loss_fun)(x)\\n\\n res = oscipy.optimize.minimize(\\n loss_and_grads,\\n x0=array_from_par(params),\\n jac=True,\\n method='BFGS')\\n\\n logging.info('Optimisation message: {}'.format(res.message))\\n\\n trained_model = model.replace(params=par_from_array(res.x))\\n return trained_model\",\n \"def fit(self,X, y, lr=0.1, iters=100, recompute=True):\\r\\n # INSERT YOUR CODE HERE\\r\\n # Appending a column of 1's to the train set X\\r\\n X = np.append(X, np.array([[1]]*X.shape[0]), axis=1)\\r\\n self.w =self.initialize_weights(X.shape[1])\\r\\n\\r\\n if(recompute):\\r\\n #Reinitialize the model weights\\r\\n self.w = self.initialize_weights(X.shape[1])\\r\\n\\r\\n for _ in range(iters): \\r\\n # Calculate gradient ascent and Update weights\\r\\n # w = w + lr * g / size of X\\r\\n self.w += lr*(1 / X.shape[0])*self.gradient_ascent(self.w,X,y,lr)\",\n \"def fit(\\n self,\\n X: np.ndarray,\\n y: np.ndarray,\\n lr: float = 0.1,\\n epochs: int = 20000,\\n progress_bar: bool = True,\\n ) -> np.ndarray:\\n X = np.append(X, np.ones((len(X), 1)), axis=1)\\n y = y.reshape(-1, 1)\\n lr = lr / len(X)\\n losses = np.zeros(epochs)\\n for i in tqdm(range(epochs), disable=not progress_bar):\\n a = X @ self.v.T\\n z = self.activation_function(a)\\n y_hat = self.activation_function(z @ self.w)\\n\\n # Backprop\\n grad_b = y_hat - y\\n grad_w = z.T @ grad_b + 2 * self.reg / self.num_parameters * self.w\\n grad_z = self.w.T * grad_b\\n grad_a = grad_z * z * (1 - z)\\n reg_grad_v = 2 * self.reg / self.num_parameters * self.v\\n reg_grad_v[:, -1] = 0 # Don't regularize weights.\\n grad_v = grad_a.T @ X + reg_grad_v\\n # Update weights\\n self.w -= lr * grad_w\\n self.v -= lr * grad_v\\n\\n loss = self.loss(y, y_hat)\\n losses[i] = loss\\n return losses\",\n \"def train(self, X, y, learning_rate = 1e-3, reg = 1e-5, num_iter = 100, \\r\\n batch_size = 100, verbose = False):\\r\\n num_train, dim = X.shape\\r\\n num_classes = np.max(y) + 1 # assum y take values 0..K-1\\r\\n # initialize weight\\r\\n if self.W is None:\\r\\n self.W = 0.001 * np.random.randn(dim, num_classes)\\r\\n \\r\\n # SGD\\r\\n loss_history = []\\r\\n for iter in range(num_iter):\\r\\n batch_ix = np.random.choice(num_train, batch_size)\\r\\n X_batch = X[batch_ix]\\r\\n y_batch = y[batch_ix]\\r\\n \\r\\n loss, grad = self.loss(X_batch, y_batch, reg)\\r\\n loss_history.append(loss)\\r\\n self.W -= grad * learning_rate\\r\\n \\r\\n if verbose and iter % 100 == 0:\\r\\n print('iteration: %d / %d: loss: %f' %(iter, num_iter, loss))\\r\\n \\r\\n return loss_history\",\n \"def train(self, X, y):\\n self.model.fit(X, y)\",\n \"def fit(self, X, y):\\n self.x_values = X\\n self.y_values = y\\n self.gradient_descent(self.coefficients, X, y)\",\n \"def train(self, X, y, learning_rate=1e-3, num_iters=100,\\n batch_size=200, verbose=True):\\n num_train, dim = X.shape\\n\\n if self.w is None:\\n self.w = 0.001 * np.random.randn(dim)\\n\\n loss_history = []\\n\\n # 将feature与label连起来，方便后面batch的划分\\n all_data = list(zip(X, y))\\n\\n for it in xrange(num_iters):\\n X_batch = None\\n y_batch = None\\n\\n #########################################################################\\n # TODO: #\\n # Sample batch_size elements from the training data and their #\\n # corresponding labels to use in this round of gradient descent. #\\n # Store the data in X_batch and their corresponding labels in #\\n # y_batch; after sampling X_batch should have shape (batch_size, dim) #\\n # and y_batch should have shape (batch_size,) #\\n # #\\n # Hint: Use np.random.choice to generate indices. Sampling with #\\n # replacement is faster than sampling without replacement. #\\n #########################################################################\\n\\n # batch_data = np.random.choice(all_data, batch_size, False) \\n # error: ValueError: a must be 1-dimensional \\n # 查询相关api貌似该方法不能用于数组中元素为元组情况下的选取\\n batch_data = random.sample(all_data, batch_size)\\n X_batch, y_batch = zip(*batch_data)\\n X_batch = np.array(X_batch)\\n y_batch = np.array(y_batch)\\n #########################################################################\\n # END OF YOUR CODE #\\n #########################################################################\\n\\n # evaluate loss and gradient\\n\\n loss, grad = self.loss(X_batch, y_batch)\\n loss_history.append(loss)\\n\\n # perform parameter update\\n #########################################################################\\n # TODO: #\\n # Update the weights using the gradient and the learning rate. #\\n #########################################################################\\n self.w += float(learning_rate) * np.array(grad)\\n #########################################################################\\n # END OF YOUR CODE #\\n #########################################################################\\n\\n if verbose and (it % 1000 == 0 or it == num_iters - 1):\\n print('iteration %d / %d: loss %f' % (it, num_iters, loss))\\n\\n return loss_history\",\n \"def run_steep_gradient_descent(data_x, data_y, len_data, alpha, theta):\\n n = len_data\\n # WE NEED TO transpose data_x into (p+1) *n ,theta is 1*(p+1)\\n prod = np.dot(theta, data_x.transpose())\\n\\n prod -= data_y\\n print(\\\"pro: data_x\\\", prod.shape, data_x.shape)\\n #prod represent the loss of the hypothesis and true label\\n sum_grad = np.dot(prod, data_x)\\n print(\\\"总梯度的值：\\\",sum_grad.shape)\\n\\n # batch-gradient descent\\n theta = theta -(alpha / n) * sum_grad\\n return theta\",\n \"def train(self, train_x, train_y, optimzer='adam'):\\n self.history = self.model.fit(train_x, train_y, epochs=self.epochs, batch_size=self.batch_size,\\n verbose=self.verbose, shuffle=False)\",\n \"def get_sgd_solution(TRAINING_PHI, TEST_PHI, VAL_PHI, W_Now, TrainingData,\\n TrainingTarget, TestData, ValData):\\n # Gradient Descent Solution for Linear Regression\\n La = 2\\n # learningRate = 0.01\\n L_Erms_Val, L_Erms_TR, L_Erms_Test, L_Accuracy_Test, W_Mat = [], [], [], [], []\\n\\n for i in range(0, 400):\\n\\n # print (f'---------Iteration: {i} M{M} LR {learningRate} L :{C_Lambda}--------------')\\n Delta_E_D = -np.dot(\\n (TrainingTarget[i] - np.dot(np.transpose(W_Now), TRAINING_PHI[i])),\\n TRAINING_PHI[i])\\n La_Delta_E_W = np.dot(La, W_Now)\\n Delta_E = np.add(Delta_E_D, La_Delta_E_W)\\n Delta_W = -np.dot(learningRate, Delta_E)\\n W_T_Next = W_Now + Delta_W\\n W_Now = W_T_Next\\n\\n #-----------------TrainingData Accuracy---------------------#\\n TR_TEST_OUT = GetValTest(TRAINING_PHI, W_T_Next)\\n Erms_TR = GetErms(TR_TEST_OUT, TrainingTarget)\\n L_Erms_TR.append(float(Erms_TR.split(',')[1]))\\n\\n #-----------------ValidationData Accuracy---------------------#\\n VAL_TEST_OUT = GetValTest(VAL_PHI, W_T_Next)\\n Erms_Val = GetErms(VAL_TEST_OUT, ValDataAct)\\n L_Erms_Val.append(float(Erms_Val.split(',')[1]))\\n\\n #-----------------TestingData Accuracy---------------------#\\n TEST_OUT = GetValTest(TEST_PHI, W_T_Next)\\n Erms_Test = GetErms(TEST_OUT, TestDataAct)\\n L_Erms_Test.append(float(Erms_Test.split(',')[1]))\\n L_Accuracy_Test.append(float(Erms_Test.split(',')[0]))\\n\\n return ([L_Erms_TR, L_Erms_Val, L_Erms_Test, L_Accuracy_Test])\",\n \"def train_lbfgs(self, x, y, epochs=2000, x_test=None, y_test=None, learning_rate=1.0, val_freq=1000, log_freq=1000,\\n verbose=1):\\n\\n # train the model with L-BFGS solver\\n if verbose:\\n logging.info(f'Start L-BFGS optimization')\\n\\n optimizer = LBFGS()\\n optimizer.minimize(\\n self.model, self.loss_object, x, y, self.epoch_callback, epochs, x_test=x_test, y_test=y_test,\\n val_freq=val_freq, log_freq=log_freq, verbose=verbose, learning_rate=learning_rate)\",\n \"def fit(self, X, y, max_iter=MAX_ITER):\\n n_tasks = len(X)\\n n_feats = X[0].shape[1]\\n W = np.random.randn(n_feats, n_tasks)\\n start = time.time()\\n cost_function = 0\\n X = self.normalize_data(X)\\n X = self.add_bias(X)\\n for t in range(n_tasks):\\n #print('Training {} task with lasso regression'.format(t))\\n lasso = Fista(self, self.lambda_1)\\n w = lasso.fit(xk=W[:, t], A=X[t], b=y[t], ind=self.groups,\\n max_iter=max_iter)\\n W[:, t] = w\\n stop = time.time() - start\\n self.W = W\\n return W, np.array([cost_function]), stop\",\n \"def nnRegression(data):\",\n \"def train_logisticRegression(data: np.array, labels: np.array)->None:\\n\\n n_examples = np.size(data, 0)\\n n_features = np.size(data, 1)\\n n_categories = np.size(labels, 1)\\n\\n data = np.hstack((np.ones((n_examples, 1)), data))\\n\\n print(data[0:5, :])\\n\\n X_train, X_test, y_train, y_test, idx_test = split_data(data, labels, 0.7)\\n\\n convergence_goal = 1e-3\\n learning_rate = 0.01\\n\\n theta = np.random.uniform(size=((n_features+1, n_categories)))\\n\\n for i in range(n_categories):\\n\\n cost_var = 1\\n\\n previous_cost = 1e6\\n iterations = 0\\n cost_to_plot = []\\n\\n while cost_var > convergence_goal:\\n iterations += 1\\n cost, grad = costFunction(X_train, y_train[:, i], theta[:, i])\\n theta[:, i] = update_theta(theta[:, i], grad, learning_rate)\\n cost_var = previous_cost - cost\\n previous_cost = cost\\n if iterations == 1: cost_var = 1\\n cost_to_plot.append(cost)\\n # print(cost)\\n\\n plt.plot(range(iterations), cost_to_plot, 'g-', label = 'cost')\\n plt.xlabel('iterations')\\n plt.ylabel('cost')\\n # plt.show()\\n\\n predictions = lrPredict(theta, X_test)\\n\\n print(predictions[0:5, :])\\n print(y_test[0:5, :])\\n\\n accuracy = np.mean([p == l for p, l in zip(predictions, y_test)])\\n print(\\\"Accuracy = {}\\\".format(accuracy))\\n\\n pass\",\n \"def train_step(model, x, optimizer):\\n with tf.GradientTape() as tape:\\n loss = compute_loss(model, x)\\n gradients = tape.gradient(loss, model.trainable_variables)\\n optimizer.apply_gradients(zip(gradients, model.trainable_variables))\",\n \"def fit(self, X_train, y_train):\\n if X_train.shape[0] != y_train.shape[0]:\\n raise AssertionError\\n\\n X_train = np.hstack((np.ones((X_train.shape[0], 1)), X_train))\\n rows = X_train.shape[0]\\n cols = X_train.shape[1]\\n self._weight = np.random.normal(size=cols)\\n for epoch in range(self._max_iter):\\n data = np.hstack((X_train, y_train.reshape((-1, 1))))\\n np.random.shuffle(data)\\n X_train = data[:, : -1]\\n y_train = data[:, -1].flatten()\\n for i in np.arange(0, rows, self._batch_size):\\n batch = X_train[i:i + self._batch_size]\\n y = y_train[i:i + self._batch_size]\\n pred = batch @ self._weight.T\\n f_error = pred - y\\n gradient = 2 * f_error.dot(batch) + self._alpha * self._l1_ratio * np.sign(\\n self._weight) + self._alpha * (1 - self._l1_ratio) * self._weight\\n self._weight -= self._lc * gradient / batch.shape[0]\\n self._loss.append(self.mse(X_train @ self._weight.T, y_train))\",\n \"def fit(self, X, y, X_validate, y_validate):\\n \\n iterate = 800\\n \\n self.SGD_theta_list = [0]*len(X[0])\\n self.SGD_bias = 0\\n\\n SGD_cost_history = []\\n SGD_validate_cost_history = []\\n\\n for i in range(iterate):\\n if(i%100==0):\\n print(i,\\\" iterations\\\")\\n selection = random.randint(0, len(X)-1) #selecting one random row for SGD\\n temp_X = []\\n temp_X.append(X[selection])\\n temp_y = []\\n temp_y.append(y[selection])\\n self.SGD_bias, self.SGD_theta_list = self.update_thetas(np.array(temp_X), np.array(temp_y), self.SGD_theta_list, self.SGD_bias,self.training_rate)\\n SGD_cost = self.cost_function(X, y, self.SGD_theta_list, self.SGD_bias)\\n SGD_cost_history.append(SGD_cost)\\n SGD_validate_cost = self.cost_function(X_validate, y_validate,self.SGD_theta_list, self.SGD_bias)\\n SGD_validate_cost_history.append(SGD_validate_cost)\\n\\n self.FINAL_SGD_TRAIN_LOSS.append(SGD_cost_history[-1])\\n self.FINAL_SGD_VALIDATE_LOSS.append(SGD_validate_cost_history[-1])\\n\\n plt.plot(list(range(iterate)), SGD_cost_history)\\n plt.plot(list(range(iterate)), SGD_validate_cost_history)\\n plt.xlabel(\\\"Iterations\\\")\\n plt.ylabel(\\\"Loss SGD\\\")\\n plt.show()\\n \\n \\n self.BGD_theta_list = [0]*len(X[0])\\n self.BGD_bias = 0\\n\\n BGD_cost_history = []\\n BGD_validate_cost_history = []\\n\\n for i in range(iterate):\\n if(i%100==0):\\n print(i,\\\" iterations\\\")\\n selection = random.randint(0, len(X)-1)\\n \\n self.BGD_bias, self.BGD_theta_list = self.update_thetas(X, y, self.BGD_theta_list, self.BGD_bias,self.training_rate)\\n\\n BGD_cost = self.cost_function(X, y, self.BGD_theta_list, self.BGD_bias)\\n BGD_cost_history.append(BGD_cost)\\n BGD_validate_cost = self.cost_function(X_validate, y_validate,self.BGD_theta_list, self.BGD_bias)\\n BGD_validate_cost_history.append(BGD_validate_cost)\\n\\n self.FINAL_BGD_TRAIN_LOSS.append(BGD_cost_history[-1])\\n self.FINAL_BGD_VALIDATE_LOSS.append(BGD_validate_cost_history[-1])\\n\\n plt.plot(list(range(iterate)), BGD_cost_history)\\n plt.plot(list(range(iterate)), BGD_validate_cost_history)\\n plt.xlabel(\\\"Iterations\\\")\\n plt.ylabel(\\\"Loss BGD\\\")\\n plt.show()\\n\\n print(\\\"FINAL_SGD_TRAIN_LOSS\\\\n\\\",self.FINAL_SGD_TRAIN_LOSS)\\n print(\\\"FINAL_SGD_VALIDATE_LOSS\\\\n\\\",self.FINAL_SGD_VALIDATE_LOSS)\\n print(\\\"FINAL_BGD_TRAIN_LOSS\\\\n\\\",self.FINAL_BGD_TRAIN_LOSS)\\n print(\\\"FINAL_BGD_VALIDATE_LOSS\\\\n\\\",self.FINAL_BGD_VALIDATE_LOSS)\\n\\n \\n return self\",\n \"def _batch_gradient_descent(self, X, y, lr, epochs):\\n\\n # Initialize the bias and weights.\\n _, n = X.shape\\n self.bias = 0\\n self.weights = np.random.normal(size=n)\\n\\n for i in range(epochs):\\n # Calculate and sum the gradient delta of each sample\\n grad_bias, grad_weights = self._get_gradient(X, y)\\n\\n # Show the gradient of each epoch.\\n grad = (grad_bias + grad_weights.mean()) / 2\\n print(\\\"Epochs %d gradient %.3f\\\" % (i + 1, grad), flush=True)\\n\\n # Update the bias and weight by gradient of current epoch\\n self.bias += lr * grad_bias\\n self.weights += lr * grad_weights\",\n \"def train_nn_regression_model(\\n optimizer,\\n steps,\\n batch_size,\\n hidden_units,\\n training_examples,\\n training_targets,\\n validation_examples,\\n validation_targets):\\n\\n periods = 10\\n steps_per_period = steps / periods\\n\\n # Create the input functions.\\n feature_columns = set([tf.contrib.layers.real_valued_column(my_feature) for my_feature in training_examples])\\n\\n training_input_fn = learn_io.pandas_input_fn(\\n x=training_examples, y=training_targets,\\n num_epochs=None, batch_size=batch_size)\\n\\n predict_training_input_fn = learn_io.pandas_input_fn(\\n x=training_examples, y=training_targets,\\n num_epochs=1, shuffle=False)\\n\\n predict_validation_input_fn = learn_io.pandas_input_fn(\\n x=validation_examples, y=validation_targets,\\n num_epochs=1, shuffle=False)\\n\\n\\n # Create a linear regressor object.\\n\\n dnn_regressor = tf.contrib.learn.DNNRegressor(\\n feature_columns=feature_columns,\\n hidden_units=hidden_units,\\n optimizer=optimizer,\\n gradient_clip_norm=5.0\\n )\\n\\n # Train the model, but do so inside a loop so that we can periodically assess\\n # loss metrics.\\n print \\\"Training model...\\\"\\n print \\\"RMSE (on training data):\\\"\\n training_rmse = []\\n validation_rmse = []\\n for period in range (0, periods):\\n # Train the model, starting from the prior state.\\n dnn_regressor.fit(\\n input_fn=training_input_fn,\\n steps=steps_per_period\\n )\\n # Take a break and compute predictions.\\n training_predictions = list(dnn_regressor.predict(input_fn=predict_training_input_fn))\\n validation_predictions = list(dnn_regressor.predict(input_fn=predict_validation_input_fn))\\n # Compute training and validation loss.\\n training_root_mean_squared_error = math.sqrt(\\n metrics.mean_squared_error(training_predictions, training_targets))\\n validation_root_mean_squared_error = math.sqrt(\\n metrics.mean_squared_error(validation_predictions, validation_targets))\\n # Occasionally print the current loss.\\n print \\\" period %02d : %0.2f\\\" % (period, training_root_mean_squared_error)\\n # Add the loss metrics from this period to our list.\\n training_rmse.append(training_root_mean_squared_error)\\n validation_rmse.append(validation_root_mean_squared_error)\\n print \\\"Model training finished.\\\"\\n\\n # Output a graph of loss metrics over periods.\\n plt.ylabel(\\\"RMSE\\\")\\n plt.xlabel(\\\"Periods\\\")\\n plt.title(\\\"Root Mean Squared Error vs. Periods\\\")\\n plt.tight_layout()\\n plt.plot(training_rmse, label=\\\"training\\\")\\n plt.plot(validation_rmse, label=\\\"validation\\\")\\n plt.legend()\\n\\n print \\\"Final RMSE (on training data): %0.2f\\\" % training_root_mean_squared_error\\n print \\\"Final RMSE (on validation data): %0.2f\\\" % validation_root_mean_squared_error\\n\\n return dnn_regressor, training_rmse, validation_rmse\",\n \"def train_regressor(self, data, opt='adam', val=None, batch_size=64,\\n start=0, **hooks):\\n metrics = 'mean_squared_error',\\n return self.train(data, metrics, opt, val, batch_size, start, **hooks)\",\n \"def train(self, x, y):\\n len_dim_0 = x.shape[0]\\n x = np.reshape(x, (len_dim_0, 784))\\n with tf.GradientTape() as tape:\\n tape.watch(self.layers)\\n y_out = self.forward(x)\\n loss = self.mean_squared_error(y_out, y)\\n grads = tape.gradient(loss, self.layers)\\n temp_layers = []\\n for layer, grad in zip(self.layers, grads):\\n new_w = layer.weights - (self.learning_rate * grad.weights)\\n new_b = layer.biases - (self.learning_rate * grad.biases)\\n temp_layers.append(self.Layer(new_w, new_b))\\n self.layers = temp_layers\\n\\n return loss\",\n \"def train_step(model,x,optimizer):\\r\\n\\twith tf.GradientTape() as tape:\\r\\n\\t\\tloss = compute_loss(model, x)\\r\\n\\t\\tgradients = tape.gradient(loss, model.trainable_variables)\\r\\n\\t\\toptimizer.apply_gradients(zip(gradients, model.trainable_variables))\\r\\n\\treturn loss\",\n \"def fit(self, X, y):\\n y = np.array(y)\\n rows, columns = X.shape\\n num_batches = int(np.ceil(rows / self.batch_size))\\n batches = np.arange(num_batches + 1) * self.batch_size\\n indxs = np.arange(rows)\\n\\n self.W = np.zeros(columns)\\n self.b = rng.random(1)\\n\\n # stochastic gradient descent logic\\n for _ in range(self.num_epochs):\\n rng.shuffle(indxs)\\n\\n for i, j in zip(batches[0:-1], batches[1:]):\\n batch_indxs = indxs[i:j]\\n x_batch = X[batch_indxs]\\n y_batch = y[batch_indxs]\\n self.update(x_batch, y_batch)\\n\\n # track loss history during training\\n self.loss_history.append(self.loss(self.predict_proba(X), y))\\n self.accuracies.append(self.accuracy(X, y))\",\n \"def experiment_linear_tradeoff_linf(_):\\n adv_norm_type = 'linf'\\n dual_norm_type = 'l1'\\n # Min l1-norm solution found (norm=0.6876)\\n attack_eps = 1/0.6876\\n attack_step_dir = 'sign_grad'\\n module_name = 'train'\\n log_dir = 'runs_linear_tradeoff_%s' % adv_norm_type\\n exclude = '*'\\n\\n d_over_n = [32]\\n dim = 100\\n num_train = [int(dim / p) for p in d_over_n]\\n\\n # Config params\\n shared_params = []\\n shared_params += [\\n ('config', './config.py'),\\n ('seed', list(range(3))),\\n ]\\n\\n # Data hyper-parameters\\n shared_params += [\\n ('temperature', 0.0001),\\n ('num_test', 500),\\n ('dim', dim),\\n ('num_train', num_train),\\n ]\\n\\n # Adversarial configuration: test\\n shared_params += nameit('adv', [\\n ('norm_type', adv_norm_type),\\n ('lr', 0.1),\\n ('niters', 10),\\n # ('eps_iter', attack_eps), # Overwritten by cvxpy\\n # ('eps_tot', attack_eps), # Overwritten by cvxpy\\n ('pre_normalize', True), # multi attacks\\n ('post_normalize', True),\\n ('eps_from_cvxpy', True),\\n ('step_dir', attack_step_dir),\\n ])\\n\\n # Logging to standard output\\n shared_params += [\\n ('log_interval', 10000), # 1000),\\n ('log_keys', '\\\\'(\\\"%s\\\")\\\\'' % ('\\\",\\\"'.join([\\n 'risk/train/zero_one',\\n 'risk/train/adv/%s' % adv_norm_type,\\n 'weight/linear/norm/%s' % dual_norm_type,\\n 'margin/%s' % dual_norm_type,\\n ]))),\\n # Compare with cvxpy\\n ('enable_cvxpy', True),\\n ]\\n params = []\\n\\n # reg_coeff = [1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1]\\n reg_coeff = [1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 1, 10]\\n # Between 1e-3 and 1e-1 for d/n=10 the adv robustness drops\\n reg_coeff += [3e-3, 5e-3, 3e-2, 5e-2, 3e-1, 5e-1]\\n\\n # Model hyper-parameters\\n linear_noreg_model_params = nameit('model', [\\n ('arch', 'linear'),\\n ('regularizer', 'none'),\\n ])\\n linear_reg_model_params = nameit('model', [\\n ('arch', 'linear'),\\n ('regularizer', ['w_%s' % dual_norm_type]),\\n ('reg_coeff', reg_coeff),\\n ])\\n\\n # Explicit regularization with line search\\n # njobs=3*6*20*4*2=2880\\n explicit_reg = nameit('optim', [\\n ('name', 'fista'),\\n ('niters', 10000),\\n ('bound_step', True),\\n ('step_size', [1, 10, 100, 1000]),\\n ])\\n params += [OrderedDict(shared_params+linear_reg_model_params+explicit_reg)]\\n\\n # Adversarial training with line search\\n for i in [1] + list(np.arange(0.1, 2, 0.2)): # [0.1, 0.3, 0.5, 0.7, 1, 1.3]:\\n adv_train_params = nameit('optim', [\\n ('name', 'gd_ls'),\\n ('niters', 10000),\\n ('bound_step', True),\\n ])\\n adv_train_params += nameit('optim', nameit('adv_train', [\\n ('enable', True),\\n ('norm_type', adv_norm_type),\\n ('lr', 0.1),\\n ('niters', 10), # niters, 1000\\n ('pre_normalize', True),\\n ('post_normalize', True),\\n ('step_dir', attack_step_dir),\\n ('eps_iter', float(attack_eps) * i),\\n ('eps_tot', float(attack_eps) * i),\\n ]))\\n params += [OrderedDict(\\n shared_params+linear_noreg_model_params+adv_train_params)]\\n\\n return params, log_dir, module_name, exclude\",\n \"def train():\\n model.train()\\n for batch_index, (xb, yb) in enumerate(train_dl):\\n loss = loss_func(model(xb), yb)\\n\\n loss.backward()\\n opt.step()\\n opt.zero_grad()\",\n \"def train_logistic_regression(x_train, y_train, learning_rate, fit_intercept=False, max_iter=500):\\r\\n if fit_intercept:\\r\\n intercept = np.ones(x_train.shape[0], 1)\\r\\n x_train = np.hstack((intercept, x_train)) # hstacks merges 2 arrays column wise\\r\\n weights = np.zeros(x_train.shape[1])\\r\\n for iteration in range(max_iter):\\r\\n weights = update_weights(x_train, y_train, weights, learning_rate)\\r\\n # printing cost for every 100 iterations\\r\\n if iteration % 100 == 0:\\r\\n print(calculate_cost(x_train, y_train, weights))\\r\\n return weights\",\n \"def fit(self, x_train, y_train):\\n\\n optimizers_functions = {'gd': self.__update_weights_grad_desc, 'sgd': self.__update_weights_stoc_gd}\\n\\n if self.__fit_intercept:\\n intercept = np.ones((x_train.shape[0], 1))\\n x_train = np.hstack((intercept, x_train))\\n\\n self.__weights = np.zeros(x_train.shape[1])\\n\\n for iteration in range(self.__max_iter):\\n optimizers_functions[self.__optimizer](x_train, y_train)\\n\\n if self.__verbose == 1 and iteration % 100 == 0:\\n print(\\\"Iteration: {}, training loss: {}\\\".format(iteration, self.__compute_cost(x_train, y_train)))\",\n \"def fit(self, x: np.array, y: np.array, epochs: int = 2) -> 'LinearRegressor':\\n self.rows, self.columns = x.shape\\n self.rows_target, self.columns_target = y.shape\\n\\n self.w0 = 1.0\\n self.w1 = np.random.randn(1, self.columns)\\n \\n print(f'Initials >> \\\"w0\\\": {self.w0}, \\\"w1\\\": {self.w1}')\\n \\n for _ in range(epochs):\\n preds = self.predict(x)\\n preds = np.reshape(preds, (-1,1))\\n \\n self.loss.append(np.sum(np.square(y - preds) / self.rows))\\n\\n dw0 = -(2 / self.rows) * np.sum(y - preds)\\n dw1 = -(2 / self.rows) * x.T.dot(y - preds)\\n\\n self.w0 -= self.learning_rate * dw0\\n self.w1 -= self.learning_rate * dw1\\n #print(f'dw0: {dw0}, dw1: {dw1}')\\n #print(f'\\\"w0\\\": {self.w0}, \\\"w1\\\": {self.w1}')\\n \\n return self\",\n \"def train(self, X, Y, iterations=5000, alpha=0.05, verbose=True,\\n graph=True, step=100):\\n if not isinstance(iterations, int):\\n raise TypeError('iterations must be an integer')\\n if iterations < 0:\\n raise ValueError('iterations must be a positive integer')\\n if not isinstance(alpha, float):\\n raise TypeError('alpha must be a float')\\n if alpha < 0:\\n raise ValueError('alpha must be positive')\\n if verbose or graph:\\n if not isinstance(step, int):\\n raise TypeError('step must be an integer')\\n if step <= 0 or step > iterations:\\n raise ValueError('step must be positive and <= iterations')\\n\\n costs = []\\n iteration = np.arange(0, iterations)\\n for i in range(iterations):\\n A, self.__cache = self.forward_prop(X)\\n key = \\\"A{}\\\".format(self.__L)\\n cost = self.cost(Y, A)\\n costs.append(cost)\\n if i % step == 0 or i == iterations:\\n if verbose:\\n print(\\\"Cost after {} iterations: {}\\\".format(i, cost))\\n self.gradient_descent(Y, self.__cache, alpha)\\n if graph:\\n plt.plot(iteration, costs, 'b-')\\n plt.xlabel('iteration')\\n plt.ylabel('cost')\\n plt.title('Training Cost')\\n plt.show()\\n\\n return self.evaluate(X, Y)\",\n \"def train_single_feature_linear_regressor(learning_rate, steps, batch_size, input_feature=\\\"nsmiles\\\"):\\n \\n print(\\\"TRAINING SINGLE FEATURE LINEAR REGRESSOR\\\")\\n\\n periods = 10\\n steps_per_period = steps / periods\\n\\n my_feature = input_feature\\n my_feature_data = airfare_report_dataframe[[my_feature]]\\n my_label = \\\"fare\\\"\\n targets = airfare_report_dataframe[my_label]\\n\\n # Create feature columns.\\n feature_columns = [tf.feature_column.numeric_column(my_feature)]\\n \\n # Create input functions.\\n training_input_fn = lambda: single_feature_input_fn(my_feature_data, targets, batch_size=batch_size)\\n prediction_input_fn = lambda: single_feature_input_fn(my_feature_data, targets, num_epochs=1, shuffle=False)\\n \\n # Create a linear regressor object.\\n my_optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)\\n my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)\\n linear_regressor = tf.estimator.LinearRegressor(\\n feature_columns=feature_columns,\\n optimizer=my_optimizer\\n )\\n\\n # Set up to plot the state of our model's line each period.\\n plt.figure(figsize=(15, 6))\\n plt.subplot(1, 2, 1)\\n plt.title(\\\"Learned Line by Period\\\")\\n plt.ylabel(my_label)\\n plt.xlabel(my_feature)\\n sample = airfare_report_dataframe.sample(n=300)\\n plt.scatter(sample[my_feature], sample[my_label])\\n colors = [cm.coolwarm(x) for x in np.linspace(-1, 1, periods)]\\n\\n plt.show()\\n\\n # Train the model, but do so inside a loop so that we can periodically assess\\n # loss metrics.\\n print(\\\"Training model...\\\")\\n print(\\\"RMSE (on training data):\\\")\\n root_mean_squared_errors = []\\n for period in range (0, periods):\\n # Train the model, starting from the prior state.\\n linear_regressor.train(\\n input_fn=training_input_fn,\\n steps=steps_per_period\\n )\\n # Take a break and compute predictions.\\n predictions = linear_regressor.predict(input_fn=prediction_input_fn)\\n predictions = np.array([item['predictions'][0] for item in predictions])\\n \\n # Compute loss.\\n root_mean_squared_error = math.sqrt(\\n metrics.mean_squared_error(predictions, targets))\\n # Occasionally print the current loss.\\n print(\\\" period %02d : %0.2f\\\" % (period, root_mean_squared_error))\\n # Add the loss metrics from this period to our list.\\n root_mean_squared_errors.append(root_mean_squared_error)\\n \\n # Finally, track the weights and biases over time.\\n # Apply some math to ensure that the data and line are plotted neatly.\\n y_extents = np.array([0, sample[my_label].max()])\\n\\n print(\\\"Model training finished.\\\")\\n\\n # Output a graph of loss metrics over periods.\\n plt.subplot(1, 2, 2)\\n plt.ylabel('RMSE')\\n plt.xlabel('Periods')\\n plt.title(\\\"Root Mean Squared Error vs. Periods\\\")\\n plt.tight_layout()\\n plt.plot(root_mean_squared_errors)\\n\\n plt.show()\\n\\n #I left out the calibration data graph\\n\\n print(\\\"Final RMSE (on training data): %0.2f\\\" % root_mean_squared_error)\",\n \"def linearReg(x,y):\\n X=np.array(x).reshape(-1,1)\\n Y=np.array(y).reshape(-1,1)\\n x_shape = X.shape\\n num_var = x_shape[1] \\n yintercept = 0\\n slope = 0\\n progress = []\\n #intialize the parameter\\n weight_matrix = np.random.normal(-1,1,(num_var,1))\\n yintercept = np.random.rand(1)\\n #cost minmization\\n for i in range(200):\\n dcostdm = np.sum(np.multiply(((np.matmul(X,weight_matrix)+ yintercept)-Y),X))*2/x_shape[0] #w.r.t to the weight\\n dcostdc = np.sum(((np.matmul(X,weight_matrix)+yintercept)-Y))*2/x_shape[0] #partial derivative of cost w.r.t the intercept\\n weight_matrix -= 0.1*dcostdm \\n #updating the weights with the calculated gradients\\n yintercept -= 0.1*dcostdc #updating the weights with the calculated gradients\\n progress.append(np.array((weight_matrix,yintercept)))\\n slope = weight_matrix\\n return (slope[-1],yintercept)\",\n \"def main():\\n ###################\\n ## Dataset ##\\n ###################\\n # (X, y) m = 100, n = 1\\n _data_x, data_y = make_regression(n_samples=100, n_features=1, noise=10)\\n\\n # show the dataset\\n plt.subplot(2, 2, 1)\\n plt.title(\\\"dataset\\\")\\n plt.scatter(_data_x, data_y)\\n\\n # Transform the dataset into matrices.\\n # That is used for writing the equations in the matrix form.\\n data_x = np.hstack((_data_x, np.ones(_data_x.shape)))\\n data_y = data_y.reshape(data_y.shape[0], 1)\\n\\n #################\\n ## Model ##\\n #################\\n # initial parameters\\n init_params = np.random.randn(2, 1)\\n\\n # initial model\\n init_model = model(data_x, init_params)\\n\\n # plot initial model\\n plt.subplot(2, 2, 2)\\n plt.title(\\\"initial model\\\")\\n plt.scatter(_data_x, data_y)\\n plt.plot(_data_x, init_model, c='g')\\n\\n #########################\\n ## cost function ##\\n #########################\\n # show cost function for initial parameters\\n print(cost_function(data_x, data_y, init_params))\\n\\n ####################\\n ## training ##\\n ####################\\n # learning rate\\n learn_rate = 0.005\\n # number of iterations\\n number_iterations = 1_000\\n\\n # final parameters for our model\\n final_params, cost_tracking = gradient_descent(\\n data_x, data_y, init_params, learn_rate, number_iterations)\\n\\n # final model\\n final_model = model(data_x, final_params)\\n\\n # show cost function for final parameters\\n print(cost_function(data_x, data_y, final_params))\\n\\n # plot final model\\n plt.subplot(2, 2, 3)\\n plt.title(\\\"final model\\\")\\n plt.scatter(_data_x, data_y)\\n plt.plot(_data_x, final_model, c='r')\\n\\n ##########################\\n ## learning curve ##\\n ##########################\\n # plot Cost history\\n plt.subplot(2, 2, 4)\\n plt.title(\\\"cost tracking\\\")\\n plt.plot(range(number_iterations), cost_tracking)\\n\\n ########################################\\n ## Coefficient of determination ##\\n ########################################\\n print(coefficient_determination(data_y, final_model))\\n\\n plt.show()\",\n \"def train_logistic_regression(train_x, train_y):\\n\\n logistic_regression_model = LogisticRegression(penalty='l2', C=1.0)\\n logistic_regression_model.fit(train_x, train_y)\\n return logistic_regression_model\",\n \"def train(self, X_train, y_train):\\n self.model.fit(X_train, y_train)\",\n \"def train_step(self, x):\\n with tf.GradientTape() as tape:\\n loss = self.compute_loss(x)\\n gradients = tape.gradient(loss, self.model.trainable_variables)\\n self.optimizer.apply_gradients(zip(gradients, self.model.trainable_variables))\",\n \"def linear_regression(features, values):\\n clf = SGDRegressor(n_iter=100)\\n clf.fit(features,values)\\n print(clf.score(features,values))\\n intercept = clf.intercept_ \\n params = clf.coef_\\n \\n return intercept, params\",\n \"def train_step(self, x, y):\\n\\n with tf.GradientTape() as tape:\\n y_pred = self.model(x)\\n loss = self.loss_object(y, y_pred)\\n gradients = tape.gradient(loss, self.model.trainable_variables)\\n self.optimizer.apply_gradients(zip(gradients, self.model.trainable_variables))\\n\\n return loss\",\n \"def train(epochs, batch_size, lr, verbose):\\n # autograd globally off\\n torch.set_grad_enabled(False)\\n # generate training and testing datasets\\n train_data, train_label = generate_data()\\n test_data, test_label = generate_data()\\n # normalize data be centered at 0\\n train_data, test_data = normalize(train_data, test_data)\\n\\n if verbose:\\n print(\\\"--- Dataset ---\\\")\\n print(\\\"Train X: \\\", train_data.size(), \\\" | Train y: \\\", train_label.size())\\n print(\\\" Test X: \\\", test_data.size(), \\\" | Test y: \\\", test_label.size())\\n\\n layers =[]\\n # input layer (2 input units)\\n linear1 = Linear(2, 25, bias= True, weight_init=xavier_uniform)\\n\\n # 3 hidden layers (each 25 units)\\n linear2 = Linear(25, 25, bias= True, weight_init=xavier_uniform)\\n linear3 = Linear(25, 25, bias= True, weight_init=xavier_uniform)\\n linear4 = Linear(25, 25, bias= True, weight_init=xavier_uniform)\\n\\n # output layer (2 output units)\\n linear5 = Linear(25, 2, bias= True, weight_init=xavier_uniform)\\n\\n\\n layers.append(linear1)\\n layers.append(Relu())\\n layers.append(linear2)\\n layers.append(Relu())\\n layers.append(linear3)\\n layers.append(Relu())\\n layers.append(linear4)\\n layers.append(Tanh())\\n layers.append(linear5)\\n\\n model = Sequential(layers)\\n if verbose: print(\\\"Number of model parameters: {}\\\".format(sum([len(p) for p in model.param()])))\\n\\n criterion = MSE()\\n optimizer = SGD(model, lr=lr)\\n\\n train_losses, test_losses = [], []\\n train_accuracies, test_accuracies = [], []\\n train_errors, test_errors = [], []\\n\\n if verbose: print(\\\"--- Training ---\\\")\\n for epoch in range(1, epochs+1):\\n if verbose:print(\\\"Epoch: {}\\\".format(epoch))\\n\\n # TRAINING\\n for batch_idx in range(0, train_data.size(0), batch_size):\\n # axis 0, start from batch_idx until batch_idx+batch_size\\n output = model.forward(train_data.narrow(0, batch_idx, batch_size))\\n\\n # Calculate loss\\n loss = criterion.forward(output, train_label.narrow(0, batch_idx, batch_size))\\n train_losses.append(loss)\\n if verbose: print(\\\"Train Loss: {:.2f}\\\".format(loss.item()))\\n\\n # put to zero weights and bias\\n optimizer.zero_grad()\\n\\n ## Backpropagation\\n # Calculate grad of loss\\n loss_grad = criterion.backward()\\n\\n # Grad of the model\\n model.backward(loss_grad)\\n\\n # Update parameters\\n optimizer.step()\\n\\n train_prediction = model.forward(train_data)\\n acc = accuracy(train_prediction, train_label)\\n train_accuracies.append(acc)\\n train_errors.append(1-acc)\\n if verbose: print(\\\"Train Accuracy: {:.2f}\\\".format(acc.item()))\\n\\n # EVALUATION\\n for batch_idx in range(0, test_data.size(0), batch_size):\\n # axis 0, start from batch_idx until batch_idx+batch_size\\n output = model.forward(test_data.narrow(0, batch_idx, batch_size))\\n\\n # Calculate loss\\n loss = criterion.forward(output, test_label.narrow(0, batch_idx, batch_size))\\n test_losses.append(loss)\\n if verbose: print(\\\"Test Loss: {:.2f}\\\".format(loss.item()))\\n\\n test_prediction = model.forward(test_data)\\n acc = accuracy(test_prediction, test_label)\\n test_accuracies.append(acc) \\n test_errors.append(1-acc)\\n if verbose: print(\\\"Test Accuracy: {:.2f}\\\".format(acc.item()))\\n\\n return train_losses, test_losses, train_accuracies, test_accuracies, train_errors, test_errors\",\n \"def backward_linear(Data):\\n\\n # data\\n graph = tf.Graph()\\n X = Data[0]\\n Y_ = Data[1]\\n\\n if X.shape[0] != Y_.shape[0]:\\n raise Exception(\\\"The quantity of Input X and Compare Y_ are not same!\\\")\\n\\n Loss = []\\n with graph.as_default():\\n print(\\\"This is the process of all the Dose!\\\")\\n print(\\\"There are %d data in this process.\\\" % X.shape[0])\\n print(\\\"Features of X: %d\\\" % X.shape[1])\\n print(\\\"Learning rate is: %f\\\" % learning_rate)\\n # Init all the parameters\\n global_step = tf.Variable(0, trainable=False)\\n\\n STEPS = int(Epoch * X.shape[0] / BATCH_SIZE) + 1\\n epoch = 0\\n\\n with tf.name_scope('inputs'):\\n x = tf.placeholder(tf.float32, [None, Forward.INPUT_NODE], name='x_Input')\\n y_ = tf.placeholder(tf.float32, [None, Forward.OUTPUT_NODE], name='y_Exact')\\n y = Forward.forward_linear(x, regularizer=None)\\n\\n # lost function\\n with tf.name_scope('loss'):\\n loss_mse = tf.reduce_mean(tf.square(y - y_))\\n loss = loss_mse + tf.add_n(tf.get_collection(\\\"losses\\\"))\\n tf.summary.scalar('loss', loss)\\n\\n # Todo\\n # LM algorithm\\n\\n # learning_rate = tf.train.exponential_decay(\\n # LEARNING_RATE_BASE,\\n # global_step,\\n # X.shape[0] / BATCH_SIZE,\\n # LEARNING_RATE_DECAY,\\n # staircase=True\\n # )\\n\\n with tf.name_scope('train'):\\n # train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step)\\n # train_step = tf.train.MomentumOptimizer(learning_rate, momentum=0.9).minimize(loss, global_step)\\n train_step = tf.train.AdamOptimizer(learning_rate, beta1=0.9, beta2=0.99).minimize(loss, global_step)\\n\\n # EMA algorithm\\n ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)\\n ema_op = ema.apply(tf.trainable_variables())\\n with tf.control_dependencies([train_step, ema_op]):\\n train_op = tf.no_op(name='train')\\n\\n # ready for storing the model\\n saver = tf.train.Saver()\\n\\n with tf.Session() as sess:\\n init_op = tf.global_variables_initializer()\\n sess.run(init_op)\\n\\n # Get the check point\\n ckpt = tf.train.get_checkpoint_state(MODEL_SAVE_PATH_LINEAR)\\n if ckpt and ckpt.model_checkpoint_path:\\n saver.restore(sess, ckpt.model_checkpoint_path)\\n\\n # begin multi threads\\n coord = tf.train.Coordinator()\\n threads = tf.train.start_queue_runners(sess, coord)\\n print(\\\"Begin the multi threads!\\\")\\n\\n # Graph\\n merged = tf.summary.merge_all()\\n writer = tf.summary.FileWriter(\\\"./logs_linear/\\\", sess.graph)\\n\\n # Training\\n for i in range(STEPS):\\n start = (i * BATCH_SIZE) % int(X.shape[0])\\n end = start + BATCH_SIZE\\n # if finish all the data\\n if end >= X.shape[0]:\\n end = X.shape[0]\\n\\n _, loss_value, step = sess.run([train_op, loss, global_step],\\n feed_dict={x: X[start:end], y_: Y_[start:end]})\\n\\n if i % 4000 == 0:\\n print(\\\"Steps are: %d , loss is: %g.\\\" % (step, loss_value))\\n rs = sess.run(merged, feed_dict={x: X[start:end], y_: Y_[start:end]})\\n writer.add_summary(rs, i)\\n saver.save(sess, os.path.join(MODEL_SAVE_PATH_LINEAR, MODEL_NAME), global_step)\\n\\n # a round\\n if end == X.shape[0]:\\n # get the results\\n epoch += 1\\n loss_total = sess.run(loss, feed_dict={x: X, y_: Y_})\\n\\n Loss.append(loss_total)\\n # Loss.append(loss_total*10000)\\n print(\\\"After %d epoch(s), steps are: %d, loss total is: %g.\\\\n\\\" % (epoch, step, loss_total))\\n saver.save(sess, os.path.join(MODEL_SAVE_PATH_LINEAR, MODEL_NAME), global_step)\\n\\n # close the multi threads\\n coord.request_stop()\\n coord.join(threads)\\n print(\\\"Close the multi threads!\\\")\\n\\n return Loss\",\n \"def fit(self, X, y):\\n X = self.normalize_data(X)\\n X = self.add_bias(X)\\n n_tasks = len(X)\\n n_feats = X[0].shape[1]\\n W = np.random.randn(n_feats, n_tasks)\\n cost_function = 0\\n start = time.time()\\n for t in range(n_tasks):\\n #print('Training task {} with group lasso'.format(t))\\n fista = Fista(self, self.lambda_1)\\n w_opt = fista.fit(W[:, t], X[t], y[t], self.groups,\\n max_iter=self.max_iter)\\n W[:, t] = w_opt\\n cost_function += self.cost(X[t], y[t], W[:, t])\\n stop = time.time() - start\\n self.W = W\\n return W, np.array([cost_function]), stop\",\n \"def fit(self, X, Y, lrate=0.01, training_steps=100, coeff_reg=0.1):#, batch_size=1):\\n num_instances = len(X)\\n num_features = len(X[0])\\n\\n x = T.matrix(\\\"x\\\")\\n y = T.vector(\\\"y\\\")\\n w = theano.shared(np.random.random((num_features,)), name=\\\"w\\\")\\n b = theano.shared(0., name=\\\"b\\\")\\n\\n #p = 1 / (1 + T.exp(-(T.dot(x, w) + b)))\\n p = (1 + T.tanh(-(T.dot(x, w) + b))) / 2\\n cost = ((p - y) ** 2).sum() + coeff_reg * (w ** 2).sum()\\n gw, gb = T.grad(cost, [w, b])\\n\\n train = theano.function(\\n inputs=[x,y],\\n outputs=[cost],\\n updates=((w, w - lrate * gw), (b, b - lrate * gb)),\\n allow_input_downcast=True)\\n\\n cst = [0] * training_steps\\n #num_batches = num_instances // batch_size\\n for i in xrange(training_steps):\\n \\\"\\\"\\\"\\n for j in xrange(num_batches):\\n #lidx = j*batch_size\\n #uidx = min(num_instances, lidx+batch_size)\\n #err = train(X[lidx:uidx], Y[lidx:uidx])\\n err = train(X[j:(j+1)], Y[j:(j+1)])\\n \\\"\\\"\\\"\\n err = train(X, Y)\\n cst[i] = sum(err)\\n print \\\"%d\\\\t%f\\\" % (i, cst[i])\\n\\n plt.plot(cst)\\n #plt.show()\\n plt.savefig('bgd.png')\\n\\n self.w = w.get_value()\\n self.b = b.get_value()\",\n \"def train_predict(self, xTrain, yTrain, xTest, yTest):\\n trainStats = {}\\n # TODO: DO SGD\\n #beta = np.linalg.inv(xTrain.transpose().dot(xTrain)).dot(xTrain.transpose()).dot(yTrain)\\n LinearRegression.beta = [[0],[0]]\\n intercept = 0\\n n = len(xTrain)\\n startall = time.time()\\n list = [x for x in range(0,len(xTrain))]\\n for i in range(self.mEpoch):\\n random.shuffle(list)\\n Dbetalist = []\\n Dinterceptlist = []\\n start = time.time()\\n for j in range(self.bs):\\n # Dbetalist = []\\n # Dinterceptlist = []\\n indexstart = len(list)/self.bs * j\\n indexend = len(list)/self.bs * j + len(list)/self.bs\\n subset = xTrain[int(indexstart):int(indexend)]\\n #print(subset)\\n ypredict = np.dot(subset,LinearRegression.beta) + intercept\\n subyTrain = yTrain[int(indexstart):int(indexend)]\\n Dbeta = (-2/n)*sum(np.dot(subset.transpose(),(subyTrain-ypredict)))\\n Dbetalist.append(Dbeta)\\n Dintercept = (-2/n)*sum(subyTrain-ypredict)\\n Dinterceptlist.append(Dintercept)\\n\\n end = time.time()\\n timeElapse = end - start\\n\\n avgDbeta = sum(Dbetalist) / len(Dbetalist)\\n avgDintercept = sum(Dinterceptlist) / len(Dinterceptlist)\\n #print(avgDbeta)\\n # print(avgDintercept)\\n LinearRegression.beta = LinearRegression.beta - self.lr * avgDbeta\\n #print(LinearRegression.beta)\\n # print(beta)\\n intercept = intercept - self.lr * avgDintercept\\n\\n value = {}\\n value['time'] = timeElapse\\n value['train-mse'] = LinearRegression.mse(LinearRegression, xTrain, yTrain)\\n value['test-mse'] = LinearRegression.mse(LinearRegression, xTest, yTest)\\n trainStats[i*self.bs] = value\\n\\n endall = time.time()\\n totaltime = endall - startall\\n\\n\\n return trainStats\",\n \"def train(self, X, y):\",\n \"def fit(self,X,y):\\n \\n rand_num = np.random.RandomState(self.random_state)\\n self.w_ = rand_num.normal(loc = 0.0, scale = 0.01,size = 1 + X.shape[1])\\n self.cost_ = []\\n \\n for i in range(self.n_iter):\\n net_input = self.net_input(X)\\n output = self.activation(net_input)\\n errors = (y - output)\\n self.w_[1:] += self.eta * X.T.dot(errors)\\n self.w_[0] += self.eta * errors.sum()\\n cost = (errors**2).sum()/2.0\\n self.cost_.append(cost)\\n return self\",\n \"def train_logistic_regression(train_exs: List[SentimentExample], feat_extractor: FeatureExtractor) -> LogisticRegressionClassifier:\\n lr = LogisticRegressionClassifier(feat_extractor.corpus_length, feat_extractor)\\n alpha = 1e0\\n # beta = 1e-4\\n for epoch in range(8):\\n loss = 0.\\n acc = 0\\n indices = np.arange(len(train_exs))\\n np.random.shuffle(indices)\\n for i in indices:\\n feat = feat_extractor.feats[i]\\n sentimentExample = train_exs[i]\\n y = sentimentExample.label\\n z = 1 / (1 + np.exp(-feat.dot(np.expand_dims(lr.w, axis=1))))[0, 0]\\n loss += -y * np.log(z) - (1 - y) * np.log(1 - z) \\\\\\n # + beta * np.expand_dims(lr.w, axis=0).dot(np.expand_dims(lr.w, axis=1))[0, 0]\\n predict = int(feat.dot(np.expand_dims(lr.w, axis=1))[0, 0] > 0)\\n acc += (predict == y)\\n grad = (z - y) * feat.toarray()[0] # + 2 * beta * lr.w\\n lr.w = lr.w - alpha * grad\\n print(\\\"epoch {:d}, loss: {:f}, accuracy: {:f}\\\".format(epoch, loss / len(train_exs), acc / len(train_exs)))\\n\\n for i in indices:\\n feat = feat_extractor.feats[i]\\n sentimentExample = train_exs[i]\\n y = sentimentExample.label\\n z = 1 / (1 + np.exp(-feat.dot(np.expand_dims(lr.w, axis=1))))[0, 0]\\n loss += -y * np.log(z) - (1 - y) * np.log(1 - z)\\n print(\\\"training loss: {:f}\\\".format(loss / len(train_exs)))\\n\\n return lr\",\n \"def train(self, obs, fcst):\\n D = obs.shape[0]\\n LT = obs.shape[1]\\n L = obs.shape[2]\\n w1 = np.zeros(LT)\\n w2 = np.zeros(LT)\\n l = 0\\n o = obs[:, :, :]\\n f = fcst[:, :, :]\\n bias = o - f\\n\\n model = sklearn.linear_model.LinearRegression()\\n\\n for lt in range(LT):\\n day = int(np.floor(lt / 24.0)) + 1\\n p = np.zeros([(D-day)*L, 2])\\n a = np.zeros([(D-day)*L])\\n for l in range(L):\\n I = range(l*(D-day), (l+1)*(D-day))\\n p[I, 0] = bias[day:, 0, l]\\n p[I, 1] = bias[0:-day, lt, l]\\n a[I] = bias[day:, lt, l]\\n I = np.where(np.isnan(np.min(p, axis=1) + a)==0)[0]\\n model.fit(p[I, :], a[I])\\n w1[lt] = model.coef_[0]\\n w2[lt] = model.coef_[1]\\n\\n self.weight_recent = w1\\n self.weight_yesterday = w2\\n return w1, w2\",\n \"def train_step(model, optimizer, x):\\n\\n with tf.GradientTape() as tape:\\n loss, RE, KL = model.loss(x, average=True)\\n\\n gradients = tape.gradient(loss, model.trainable_variables)\\n optimizer.apply_gradients(zip(gradients, model.trainable_variables))\\n\\n return loss, RE, KL\",\n \"def train(self, X_train, y_train, batch_size, num_epochs, alpha=0.8):\\r\\n batch_split = tf.data.Dataset.from_tensor_slices((X_train, y_train))\\r\\n batch_split = batch_split.batch(batch_size)\\r\\n for epoch in range(num_epochs):\\r\\n for step, (i,j) in enumerate(batch_split):\\r\\n with tf.GradientTape() as tape:\\r\\n predictions = self.predict(i)\\r\\n loss = self.calculate_loss(j, predictions)\\r\\n dloss_dw, dloss_db = tape.gradient(loss, [self.weights, self.biases])\\r\\n for k in range(len(self.weights)):\\r\\n self.weights[k].assign_sub(alpha * dloss_dw[k])\\r\\n self.biases[k].assign_sub(alpha * dloss_db[k])\",\n \"def train(self, X, Y, num_iterations = 1000, learning_rate = 0.01, print_cost = False, plot_cost = False):\\n costs = []\\n \\n for i in range(num_iterations + 1):\\n grads, cost = self.propagate(X,Y)\\n \\n # Retrieve derivatives from grads\\n dw = grads[\\\"dw\\\"]\\n db = grads[\\\"db\\\"]\\n \\n # Update rule\\n self.weight = self.weight - learning_rate * dw\\n self.bias = self.bias - learning_rate * db\\n \\n # Record the costs\\n if i % 100 == 0:\\n costs.append(cost)\\n \\n # Print the cost every 100 training examples\\n if print_cost and i % 100 == 0:\\n print(f\\\"cost after iteration: {i} is {np.round(cost, 4)}\\\")\\n \\n grads = {\\\"dw\\\": dw,\\n \\\"db\\\": db}\\n\\n if plot_cost:\\n plt.plot(np.arange(len(costs)) * 100, costs)\\n plt.xlabel(\\\"epoch\\\")\\n plt.ylabel(\\\"cost\\\")\\n plt.title(f\\\"Logistic curve fitting loss function (learning rate={learning_rate})\\\")\\n plt.show()\\n \\n return grads, costs\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self, x, t):\\n self.model.fit(x, t)\",\n \"def train(self):\\n learning_rate = tf.train.exponential_decay(self.learning_rate, self.global_step, self.decay_steps,self.decay_rate, staircase=True)\\n self.learning_rate_=learning_rate\\n #noise_std_dev = tf.constant(0.3) / (tf.sqrt(tf.cast(tf.constant(1) + self.global_step, tf.float32))) #gradient_noise_scale=noise_std_dev\\n train_op = tf_contrib.layers.optimize_loss(self.loss_val, global_step=self.global_step,\\n learning_rate=learning_rate, optimizer=\\\"Adam\\\",clip_gradients=self.clip_gradients)\\n return train_op\",\n \"def fit(self, X, y, **kwargs):\\n\\n start_time = time.time()\\n self.X = X\\n self.y = y\\n\\n # Normalize inputs and outputs if the respective flags were set\\n self.normalize_data()\\n\\n self.y = self.y[:, None]\\n\\n # Create the neural network\\n # self._init_nn()\\n\\n optimizer = optim.Adam(self.model.parameters(),\\n lr=self.mlp_params[\\\"learning_rate\\\"])\\n\\n if self.tb_logging:\\n self.tb_writer.add_graph(self.model, torch.rand(size=[self.batch_size, self.mlp_params[\\\"input_dims\\\"]],\\n dtype=torch.float, requires_grad=False))\\n\\n # Start training\\n self.model.train()\\n lc = np.zeros([self.mlp_params[\\\"num_epochs\\\"]])\\n for epoch in range(self.mlp_params[\\\"num_epochs\\\"]):\\n\\n epoch_start_time = time.time()\\n\\n train_err = 0\\n train_batches = 0\\n\\n for inputs, targets in self.iterate_minibatches(self.X, self.y, shuffle=True, as_tensor=True):\\n optimizer.zero_grad()\\n output = self.model(inputs)\\n\\n loss = torch.nn.functional.mse_loss(output, targets)\\n loss.backward()\\n optimizer.step()\\n\\n train_err += loss\\n train_batches += 1\\n\\n lc[epoch] = train_err / train_batches\\n curtime = time.time()\\n epoch_time = curtime - epoch_start_time\\n total_time = curtime - start_time\\n\\n if self.tb_logging:\\n # self.log_train_loss(scalar_value=lc[-1], global_step=(epoch + 1) * self.batch_size)\\n self.log_train_loss(scalar_value=lc[epoch], global_step=epoch + 1)\\n\\n if epoch % 100 == 99:\\n logger.debug(\\\"Epoch {} of {}\\\".format(epoch + 1, self.mlp_params[\\\"num_epochs\\\"]))\\n logger.debug(\\\"Epoch time {:.3f}s, total time {:.3f}s\\\".format(epoch_time, total_time))\\n logger.debug(\\\"Training loss:\\\\t\\\\t{:.5g}\\\".format(train_err / train_batches))\\n if self.log_plots:\\n try:\\n plotter = kwargs[\\\"plotter\\\"]\\n self.tb_writer.add_figure(tag=TAG_TRAIN_FIG, figure=plotter(self.predict), global_step=epoch + 1)\\n except KeyError:\\n logger.debug(\\\"No plotter specified. Not saving plotting logs.\\\")\\n self.log_plots = False\\n\\n return\",\n \"def _fit(self, _X, _y):\\n\\n self.model = linear_model.LogisticRegression(penalty=self.penalty, random_state=self.seed,\\n solver='saga', n_jobs=self.n_jobs)\\n self.model.fit(_X, _y)\",\n \"def linreg_stochastic_grad(X, y, alpha=.01):\\n m = X.shape[0]\\n n = X.shape[1]\\n theta = np.zeros(n)\\n for i in range(m):\\n delta = alpha * (np.dot(theta.transpose(), X[i,:]) -y[i]) * X[i,:]\\n theta = theta - delta\\n return theta\",\n \"def train_step(model, x, optimizer):\\n with tf.GradientTape() as tape:\\n loss = compute_loss(model, x)\\n gradients = tape.gradient(loss, model.trainable_variables)\\n optimizer.apply_gradients(zip(gradients, model.trainable_variables))\\n return loss\",\n \"def trainData(self, X, y, NeuralNet, epochs):\",\n \"def train(self, X, y, lr, epoch, method='adam', quit=1e-4):\\n if len(y.shape) == 1:\\n y = y.reshape((-1, 1))\\n if not (0 < lr < 1):\\n raise self.ANNException('learning rate cannot be negative or exceeds 1')\\n if epoch <= 0:\\n raise self.ANNException('epoch must be postitive integer')\\n if method == 'gd':\\n for _ in range(epoch):\\n nodes = self._forward(X)\\n self._backpropagate(y, nodes, lr)\\n elif method == 'adam':\\n alpha = 0.1\\n beta1 = 0.5\\n beta2 = 0.999\\n epsilon = 1e-8\\n mt = np.zeros(shape=self.weight.shape)\\n vt = np.zeros(shape=self.weight.shape)\\n before_err = self._energy(X, y)\\n for t in range(1, epoch+1):\\n nodes = self._forward(X)\\n gt = self._backpropagate(y, nodes, alpha, ret=True)\\n mt = beta1*mt + (1-beta1)*gt\\n vt = beta2*vt + (1-beta2)*gt**2\\n mthat = mt / (1-np.power(beta1, t))\\n vthat = vt / (1-np.power(beta2, t))\\n self.weight -= alpha * mthat/(np.sqrt(vthat)+epsilon)\\n after_err = self._energy(X, y)\\n if 0 < after_err-before_err < quit:\\n return\\n else:\\n before_err = after_err\\n else:\\n raise self.ANNException('only gd and adam optimizer are supported')\",\n \"def fit(self, w):\\n w_former = w\\n w_next = w\\n w_t = w\\n w_t_100 = w\\n w_diff = 10000\\n i = 0\\n #tim_beg = t.time()\\n # use two part to calculate the a(w,w0):calculate the gradient using regular or SDG, batch = 10\\n # calculate the gradient and update the w,w0\\n while i < 10000 and np.abs(w_diff) > 0.00001:\\n loss_func = self.lost\\n grads = self.gradient(loss_func)\\n # calculate the y_pred(eta)\\n w_next = w_former - grads(w_former) / (10000)\\n k =self.lost(w_next) - self.lost(w_former)\\n m = np.dot(w_next-w_former, grads(w_former).T)\\n if i != 0 and i % 100 == 0:\\n w_t = w_t_100\\n w_t_100 = w_next\\n w_diff = 1 / len(w) * (np.sum(np.abs(w_t_100 - w_t)))\\n i_loss = self.lost(w_next)\\n print(\\\"Iteration < %d > with loss < %f >\\\" % (i, i_loss))\\n #self.los_plt.append(i_loss)\\n #tim = t.time() - tim_beg\\n #self.tim.append(tim)\\n i += 1\\n w_former = w_next\\n #plt.plot(self.tim, self.los_plt)\\n #plt.xlabel(\\\"time\\\")\\n #plt.ylabel('loss')\\n #plt.show()\\n if i >= 10000:\\n print(\\\"~Optimization stops because finishing iteration~\\\")\\n if np.abs(w_diff) <= 0.00001:\\n print(\\\"~Optimization stops because of difference between weights are less than 0.00001~\\\")\\n self.w_result = w_next\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7195158","0.71620756","0.71615815","0.71331125","0.70809966","0.7030623","0.70056266","0.69661504","0.6926212","0.690336","0.68971825","0.6893532","0.6856372","0.6845524","0.6811018","0.6810703","0.6780936","0.67630255","0.6749425","0.67289364","0.671933","0.6708056","0.6702422","0.6698361","0.6685683","0.6685409","0.6684982","0.6674937","0.66676444","0.6667622","0.66340923","0.6610984","0.65958834","0.6583059","0.6581987","0.6581429","0.657239","0.6562748","0.65621984","0.65586376","0.65564","0.6547515","0.653725","0.6536739","0.65350646","0.6533573","0.6520685","0.65142864","0.64942205","0.64849985","0.64797133","0.647614","0.64713144","0.6468763","0.64476615","0.64471656","0.6442605","0.6439853","0.64391035","0.642524","0.64244324","0.6423341","0.64168143","0.64157784","0.64134127","0.6411914","0.64111805","0.6397734","0.63967586","0.6394176","0.63878673","0.63818336","0.6381489","0.6368658","0.6368506","0.6367188","0.6365136","0.63518333","0.63501346","0.6347661","0.6344703","0.63440996","0.63428676","0.6341662","0.6341022","0.6335666","0.6331714","0.6324974","0.6324974","0.6324974","0.6324974","0.6324974","0.6321524","0.63201094","0.6318009","0.63147384","0.63061744","0.63023007","0.63003546","0.62923294"],"string":"[\n \"0.7195158\",\n \"0.71620756\",\n \"0.71615815\",\n \"0.71331125\",\n \"0.70809966\",\n \"0.7030623\",\n \"0.70056266\",\n \"0.69661504\",\n \"0.6926212\",\n \"0.690336\",\n \"0.68971825\",\n \"0.6893532\",\n \"0.6856372\",\n \"0.6845524\",\n \"0.6811018\",\n \"0.6810703\",\n \"0.6780936\",\n \"0.67630255\",\n \"0.6749425\",\n \"0.67289364\",\n \"0.671933\",\n \"0.6708056\",\n \"0.6702422\",\n \"0.6698361\",\n \"0.6685683\",\n \"0.6685409\",\n \"0.6684982\",\n \"0.6674937\",\n \"0.66676444\",\n \"0.6667622\",\n \"0.66340923\",\n \"0.6610984\",\n \"0.65958834\",\n \"0.6583059\",\n \"0.6581987\",\n \"0.6581429\",\n \"0.657239\",\n \"0.6562748\",\n \"0.65621984\",\n \"0.65586376\",\n \"0.65564\",\n \"0.6547515\",\n \"0.653725\",\n \"0.6536739\",\n \"0.65350646\",\n \"0.6533573\",\n \"0.6520685\",\n \"0.65142864\",\n \"0.64942205\",\n \"0.64849985\",\n \"0.64797133\",\n \"0.647614\",\n \"0.64713144\",\n \"0.6468763\",\n \"0.64476615\",\n \"0.64471656\",\n \"0.6442605\",\n \"0.6439853\",\n \"0.64391035\",\n \"0.642524\",\n \"0.64244324\",\n \"0.6423341\",\n \"0.64168143\",\n \"0.64157784\",\n \"0.64134127\",\n \"0.6411914\",\n \"0.64111805\",\n \"0.6397734\",\n \"0.63967586\",\n \"0.6394176\",\n \"0.63878673\",\n \"0.63818336\",\n \"0.6381489\",\n \"0.6368658\",\n \"0.6368506\",\n \"0.6367188\",\n \"0.6365136\",\n \"0.63518333\",\n \"0.63501346\",\n \"0.6347661\",\n \"0.6344703\",\n \"0.63440996\",\n \"0.63428676\",\n \"0.6341662\",\n \"0.6341022\",\n \"0.6335666\",\n \"0.6331714\",\n \"0.6324974\",\n \"0.6324974\",\n \"0.6324974\",\n \"0.6324974\",\n \"0.6324974\",\n \"0.6321524\",\n \"0.63201094\",\n \"0.6318009\",\n \"0.63147384\",\n \"0.63061744\",\n \"0.63023007\",\n \"0.63003546\",\n \"0.62923294\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.631829"},"document_rank":{"kind":"string","value":"94"}}},{"rowIdx":12197,"cells":{"query":{"kind":"string","value":"Predict labels for test data using this classifier."},"document":{"kind":"string","value":"def predict(self, X, return_scores=False):\n scores, cache_list = self.network_forward(X)\n probs = self.softmax(scores)\n prediction = np.argmax(probs, axis=1)\n\n\n if return_scores:\n return prediction, scores\n else:\n return prediction"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def predict(self):\n self.get_test_data()\n predicted_labels = []\n for row in self.test_data:\n predicted_labels.append(DecisionTree.predict_row(self.classifier, row))\n return predicted_labels","def predict(self, X_test):\n\n # Predict Label 0\n i = 0\n X = X_test\n\n # Retrieve trained classifier for label 0\n clf = self.trained[i]\n\n # Make prediction\n y = clf.predict(X)\n result = np.zeros((X_test.shape[0], self.label_dim))\n\n result[:, i] = y\n\n # Concatenate result to X\n # X = sp.hstack([X, sp.csr_matrix(y)], format=\"csr\")\n\n # iterator = tqdm.trange(1, self.label_dim)\n iterator = range(1, self.label_dim)\n for i in iterator:\n # Predict Label i\n\n # Retrieve trained classifier for label i\n clf = self.trained[i]\n\n # Make prediction\n y = clf.predict(X)\n\n result[:, i] = y\n\n # Concatenate result to X\n # X = sp.hstack([X, sp.csr_matrix(y)], format=\"csr\")\n\n return result","def predict(self, testData=[]):\n result = []\n for classValue in self._classAttrs:\n #print(f'Computing Label: {classValue}, {self._classLabelMap[classValue]}')\n result.append(self._computeCondProb(testData, classValue))\n return self._classLabelMap[result.index(max(result))]","def predictTest(k, train, test):\r\n\r\n pred_labels = []\r\n\r\n # for each instance in the testing dataset, calculate all L2 distance from all training instances\r\n for te in range(len(test)):\r\n all_D = np.zeros((len(train), 1))\r\n\r\n # calculate the L2 distance of the testing instance from each training instance\r\n for tr in range(len(train)):\r\n D = 0\r\n for var in range(len(train.columns)-1):\r\n # if feature is real-valued, add (testing value - training value)^2\r\n if train[var].dtype == np.float64 or train[var].dtype == np.int64:\r\n D += (test[var][te] - train[var][tr])**2\r\n # if feature is nominal, add 1 if testing and training values are different\r\n else:\r\n if test[var][te] != train[var][tr]:\r\n D += 1\r\n all_D[tr] = D**(1/2)\r\n\r\n # sort all L2 distances, select K closest neighbors, and choose the most prevalent label\r\n all_D = np.column_stack((all_D, np.array(range(len(train)))))\r\n all_D = all_D[np.argsort(all_D[:, 0])]\r\n prob_labels = train[len(train.columns)-1][all_D[0:k, 1]].as_matrix()\r\n pred_labels.append(Counter(prob_labels).most_common(1)[0][0])\r\n\r\n return pred_labels","def predict(self, X_test):\n predicted_label = [self._predict(x_test) for x_test in X_test]\n\n return np.array(predicted_label)","def predict(self, test_set, test_labels):\n\n with tf.Session() as self.tf_session:\n self.tf_saver.restore(self.tf_session, self.models_dir + self.model_name)\n return self.accuracy.eval({self.input_data: test_set, self.input_labels: test_labels})","def predict_labels(model, x_test):\n \n pred = model.predict(x_test)\n #pred_labels = model.predict_classes(x_test) # depricated\n pred_labels = np.argmax(model.predict(x_test), axis=-1)\n \n return pred, pred_labels","def predict(self, X, y=None):\n # Check is fit had been called\n check_is_fitted(self, ['X_', 'y_'])\n\n _, Predicted_Labels =\\\n RankSVM_test(test_data=X,\n num_class=self.num_class,\n Weights=self.Weights,\n Bias=self.Bias,\n SVs=self.SVs,\n svm=self.svm, gamma=self.gamma,\n coefficient=self.coefficient,\n degree=self.degree)\n\n return Predicted_Labels","def test(self, test_instances, test_labels):\n scores = self.classifier.predict(test_instances)\n # TODO: print report","def predict(self, test_file_path: str) -> List[Dict[str, float]]:\n # TODO write code to extract features from test_file_path and \n # predict the labels for the model.\n pass","def predict(self):\n self.predicted_test_summary = []\n for step in xrange(0, self.test_size // self.test_batch_size):\n print 'Predicting Batch No.:', step\n offset = (step * self.test_batch_size) % self.test_size\n batch_data_fwd = self.X_tst_fwd[offset:(offset + self.test_batch_size), :].T\n batch_data_bwd = self.X_tst_bwd[offset:(offset + self.test_batch_size), :].T\n summary_test_out = self._predict_batch(batch_data_fwd, batch_data_bwd)\n self.predicted_test_summary.extend(summary_test_out)\n\n print 'Prediction Complete. Moving Forward..'\n\n # test answers\n self.test_review = self.X_tst_fwd\n self.predicted_test_summary = self.predicted_test_summary\n self.true_summary = self.Y_tst","def predict(self, test_vectors):\n # Calculate the best matching label for each node\n if not self.ready_for_prediction:\n # totals = sum((node.labels for node in self.codebook), Counter())\n for node in self.codebook:\n # Remove unlabeled hits\n try:\n node.labels.pop(None)\n except KeyError:\n pass\n # # Take into account small clusters. A frequency approach\n # freq_counter = Counter({label: count / totals[label]\n # for label, count in node.labels.items()})\n # if len(freq_counter) > 0:\n # node.label = freq_counter.most_common(1)[0][0]\n # else:\n # node.label = ''\n # Or ignore small clusters and just aim for accuracy\n if len(node.labels) > 0:\n node.label = node.labels.most_common(1)[0][0]\n else:\n node.label = ''\n self.ready_for_prediction = True\n\n # Return the label of the best matching unit for the given test_vectors\n if isinstance(test_vectors, collections.Iterable):\n return [self.bmu(test_vector).label for test_vector in test_vectors]\n else:\n return self.bmu(test_vectors).label","def _predict(self, classify: np.array, n_preds=1):\r\n tmp = classify.argsort()[:, :n_preds] # Return the index of the best label classification\r\n preds = copy(tmp) # allow to copy tmp\r\n for index, target in enumerate(self.targets):\r\n preds = np.where(tmp == index, target, preds) # Return the target label corresponding to the index\r\n self.preds = preds","def predict(self, testFeatures): \r\n\r\n if(not self._fitCalled):\r\n print('The fit method has not been called yet')\r\n return None\r\n\r\n l,d = testFeatures.shape\r\n n,d = self.data.shape \r\n\r\n \"\"\" Fill and return this in your implementation. \"\"\"\r\n predictions = np.empty(shape=(l,), dtype=self.labels.dtype)\r\n\r\n \"\"\" Implement kNN prediction here. \"\"\"\r\n\r\n for i in range(0, l):\r\n distances = []\r\n for j in range(0, n):\r\n distances.append((np.sqrt(np.sum((testFeatures[i]-self.data[j])**2)), self.labels[j]))\r\n distances.sort()\r\n kNearestLabels = [x[1] for x in distances][0:self.k]\r\n most_common, num_most_common = Counter(kNearestLabels).most_common(1)[0]\r\n predictions[i] = most_common\r\n return predictions","def predict(test_dataset,test_tX,weights):\n for idx, dataset in enumerate(test_tX):\n test_dataset[idx]['Prediction'] = predict_labels(weights[idx],dataset)\n return test_dataset","def predict(self, test_data):\n return self.leader.predict(test_data)","def test(self) -> None:\n\n self._predictions = self._lr.predict(self._X_test)","def fit_predict(self):\n self.classifier = self.model\n self.classifier.fit(self.X_sample, self.y_sample)\n self.y_pred = self.classifier.predict(self.X_test)","def predict(self, X):\r\n num_test = X.shape[0]\r\n # lets make sure that the output type matches the input type\r\n Ypred = np.zeros(num_test, dtype = self.ytr.dtype)\r\n\r\n # loop over all test rows\r\n for i in range(num_test):\r\n print (\"Testing example \" + str(i))\r\n distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1)\r\n # distances = self.chi2_distance(self.Xtr, X[i,:])\r\n min_index = np.argmin(distances) # get the index with smallest distance\r\n Ypred[i] = self.ytr[min_index] # predict the label of the nearest example\r\n print (\"Class Label: \" + str(Yte[i]) + \" \" + \"Predicted label: \" + str(Ypred[i]))\r\n return Ypred","def predict(self, data):\n xdata, _ = self.array_from_cases(data)\n preds = self.model.predict(xdata)\n label_preds = [dict(zip(self.binarizer.classes_, pred)) for pred in preds]\n return label_preds","def predict(self, test):\n test_data = np.asarray(test)\n assert self.x is not None and self.y is not None, \"You must train the classifier before testing\"\n results = []\n for i in range(test_data.shape[0]):\n m = self.x - test_data[i]\n # dist holds the Euclidean distance to every training point\n dist = np.sum(m*m, 1)\n # this call uses a quickselect algo to find k-smallest\n ind = np.argpartition(dist, self.k)[:self.k]\n # take the class present the most among the k closest\n out = int(scipy.stats.mode(self.y[ind], axis=None)[0])\n results.append(out)\n return results","def _predict(self, data):\n # make sure we're talking about arrays\n data = N.asarray(data)\n\n # checks only in debug mode\n if __debug__:\n if not data.ndim == 2:\n raise ValueError, \"Data array must be two-dimensional.\"\n\n if not data.shape[1] == self.__data.nfeatures:\n raise ValueError, \"Length of data samples (features) does \" \\\n \"not match the classifier.\"\n\n # compute the distance matrix between training and test data with\n # distances stored row-wise, ie. distances between test sample [0]\n # and all training samples will end up in row 0\n dists = self.__dfx(self.__data.samples, data).T\n\n # determine the k nearest neighbors per test sample\n knns = dists.argsort(axis=1)[:, :self.__k]\n\n # predicted class labels will go here\n predicted = []\n\n if self.__voting == 'majority':\n vfx = self.getMajorityVote\n elif self.__voting == 'weighted':\n vfx = self.getWeightedVote\n else:\n raise ValueError, \"kNN told to perform unknown voting '%s'.\" \\\n % self.__voting\n\n # perform voting\n results = [vfx(knn) for knn in knns]\n\n # extract predictions\n predicted = [r[0] for r in results]\n\n # store the predictions in the state. Relies on State._setitem to do\n # nothing if the relevant state member is not enabled\n self.predictions = predicted\n self.values = [r[1] for r in results]\n\n return predicted","def predict(self, X):\n num_test = X.shape[0]\n # lets make sure that the output type matches the input type\n Ypred = np.zeros(num_test, dtype = self.ytr.dtype)\n\n # loop over all test rows\n for i in range(num_test):\n # find the nearest training image to the i'th test image\n # using the L1 distance (sum of absolute value differences)\n #distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1) # L1 distance\n distances = np.sqrt(np.sum(np.square(self.Xtr - X[i, :]), axis=1)) # L2 distance\n min_index = np.argmin(distances) # get the index with smallest distance\n Ypred[i] = self.ytr[min_index] # predict the label of the nearest example\n\n return Ypred","def test_predict(self):\n\n classifier = BertCCAMClassifier()\n classifier.load_model(\"models\")\n prediction = classifier.predict([\"bartosz\"])\n self.assertEqual(prediction, [{\"labels\": (\"B\",)}])\n\n # with multiple labels\n prediction = classifier.predict([\"ala bert\"])\n self.assertEqual(prediction, [{\"labels\": (\"A\", \"B\")}])\n\n # in a batch\n prediction = classifier.predict([\"bartosz\", \"adam\"])\n self.assertEqual(prediction, [{\"labels\": (\"B\",)}, {\"labels\": (\"A\",)}])","def predict(self, X_test):\n return self.model.predict(X_test)","def predict(self, X):\n\n num_test=X.shape[0]\n\n #make sure that the output type matches the input type\n Ypred = np.zeros(num_test, dtype=self.ytr.dtype)\n\n #Loop over all test rows\n for i in xrange(num_test): #https://www.geeksforgeeks.org/range-vs-xrange-python/\n #find the nearest training image to the ith test image\n #using the L1 distance (sum of absolute value differences)\n print \"Running test example %d\" % (i)\n #distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1)\n distances = np.sum(np.square(self.Xtr - X[i,:]), axis=1)\n min_index = np.argmin(distances) #get the index with the smallest distance\n Ypred[i] = self.ytr[min_index] #predict the lable of the nearest example\n\n return Ypred","def predict(self, Xtest):\n ytest = np.dot(Xtest, self.weights)\n return ytest","def fit_predict(self, X, y=None):\n self.fit(X)\n return self.labels_","def fit_predict(self, X, y=None):\n self.fit(X)\n return self.labels_","def predict(self, X):\n prob = self.predict_proba(X)\n if self.rule == 'fda':\n prob_1 = prob[:, :self.n_class_]\n prob_2 = prob[:, self.n_class_:]\n return np.vstack((self.labels_[prob_1.argmax(1)], self.labels_[prob_2.argmax(1)]))\n else:\n return self.labels_[prob.argmax(1)]","def predict(self,X):\n y_pred = np.random.choice(self.labels, size=(X.shape[0],), p=self.thresholds)\n return y_pred","def test(self, dataset = None, debug = True, labels = None):\n\n\t\tdataset = self.vectorize(dataset) if (dataset != None) else self.testing_set_vector;\n\t\tlabels = labels if (labels != None) else self.testing_labels;\n\n\t\tprediction = self.classifier.predict(dataset)\n\n\t\tif(debug):\n\t\t\tprint(classification_report(labels, prediction))\n\n\t\treturn prediction","def predict(self, model, x_test):\n pass","def test_text_classifier_get_labels(self):\n pass","def predictSet(self, testData=\"\"):\n rawTestDataDump = self._read_file(testData)\n formattedTestData = [line.split(' ') for line in rawTestDataDump.split('\\n')]\n for test in formattedTestData:\n self._predictions.append(self.predict(test))\n return self._predictions","def _predict(self, testX):\n pass","def predict(self):\n train_vec, test_vec = self.get_tfidf_vectors()\n clf = self.get_classifier()\n\n print '-'*40\n print 'Making predictions ...'\n clf.fit(train_vec, self.train_ans)\n clf_predictions = clf.predict_proba(test_vec)\n\n print 'Storing predictions in', self.pred_file\n pred_out = [\"Id,predictions\"]\n num_pred = range(30)\n for fid, pred in zip(self.test_index, clf_predictions):\n top_rec = sorted(num_pred, key=lambda k: pred[k], reverse=True)[:3]\n pred_out.append(\"%s,%s\" % (fid, ' '.join( [clf.classes_[rec] for rec in top_rec] )))\n with open(self.pred_file, 'w') as f:\n f.write('%s\\n' % ('\\n'.join(pred_out)))","def predict(self, test_data):\n random.seed(self.seed)\n preds = [{\"id\": instance['id'], \"prediction\": random.choice([0, 1])} for instance in test_data]\n return preds","def predict_class(clf, X_test, Y_test, labels=None, stats_fname=None):\n expected = Y_test\n if isinstance(clf, KerasModel):\n char_probs = clf.predict(X_test)\n predicted = np.argmax(char_probs, axis=1)\n\n if len(Y_test.shape) > 1:\n expected = np.argmax(Y_test, axis=1)\n else:\n predicted = clf.predict(X_test)\n\n conf_mat = metrics.confusion_matrix(\n expected, predicted, labels=range(len(labels))\n )\n\n stats = {\n 'Accuracy': metrics.accuracy_score(expected, predicted),\n 'F1': metrics.f1_score(expected, predicted, average='weighted'),\n 'Precision': metrics.precision_score(expected, predicted,\n average='weighted'),\n 'Recall': metrics.recall_score(expected, predicted,\n average='weighted')\n }\n print('Accuracy: %f' % stats['Accuracy'])\n print('F1: %f' % stats['F1'])\n print('percision: %f' % stats['Precision'])\n print('recall: %f' % stats['Recall'])\n\n save_conf_mat(conf_mat, stats, labels, stats_fname)\n\n return predicted","def model_predict(classifier, X_test:list) -> list:\n y_predict = classifier.predict(X_test)\n return y_predict","def predict(self):\n\n if self.test_file is not None:\n for user in self.test_set['users']:\n pu = self.p[self.user_to_user_id[user]] + self.y_sum_rows(self.user_to_user_id[user])\n\n for item in self.test_set['feedback'][user]:\n self.predictions.append(\n (user, item, self._predict_svd_plus_plus_score(self.user_to_user_id[user],\n self.item_to_item_id[item], pu, True)))\n else:\n raise NotImplemented","def classify (self, text_test):\n test_features = self.vectorizer.transform(text_test)\n return self.nbc.predict(test_features)","def getPredictions(self):\n\t\tself.bestLabel = self.testingProbs.apply(lambda x: x.argmax(),1)","def predict(model, X):\n\tmodel.eval()\n\t# make the predictions\n\tscores = model.forward(X)\n\n\t# scores contains, for each example, two scores that can be interpreted as the\n\t# probability of each example belonging to each of the classes. To select the\n\t# final predicted label, we will select the class with higher probability.\n\tpredicted_labels = scores.argmax(dim=-1) # predicted_labels shape: (n_examples)\n\n\treturn predicted_labels","def test():\n # load dataset and model\n X, observed_y = load_data('../data/dev.txt')\n\n model = pickle.load(open('test.model', 'rb'))\n model.traverse()\n\n # predict labels for dataset\n preds = model.predict(X)\n\n # print(preds)\n # output model predictions\n np.savetxt('test.predictions', preds, fmt='%s')","def predict(self, data, training_report=False):\n output = []\n for r in range(0, len(data)):\n label = self.predict_single(data.iloc[r])\n output.append(label)\n\n label_array = data[[self.class_column]].as_matrix()\n target = list(pd.DataFrame(label_array)[0])\n\n if training_report:\n self.fit_report['output'] = output\n self.fit_report['target'] = target\n print(\"Training Fit done.\")\n self.report()\n\n else:\n self.predict_summary['output'] = output\n self.predict_summary['target'] = target\n\n print(\"Testing done.\")\n self.summary()","def predict(self, test_data):\r\n return self.gs.predict(test_data)","def test_model (self, text_test, labels_test):\n print(classification_report(labels_test, self.classify(text_test)))","def predict(self, Xtt):\n # predict outputs for test dataset\n self.logger.info(\n self.__name__ + ' predicts on {:d} samples.'.format(Xtt.shape[0]))\n pass","def predict(self, testX):\n predicted = self.model.predict(testX)\n return predicted","def predict(self):\n probabilities = self.probability_array()\n # THIS ASSUMES the classifiers are in order: 0th column of the\n # probabilities corresponds to label = 0, ..., 9th col is for 9.\n classes = np.argmax(probabilities, axis=1)\n return classes","def evaluate(y_test, pred_labels):\n \n # Converts one-hot code to a label (the index of 1)\n y_test_labels = np.argmax(y_test, axis=1)\n \n # Compare test labels to predicted labels\n score = accuracy_score(y_test_labels, pred_labels)\n \n return y_test_labels, score","def predict(self, x_test):\n\n # convert input to format for classifier\n list_of_embeddings = list(x_test[self.embeddings_col])\n x_test = np.array([[float(i) for i in embedding.strip('[]').split()] for embedding in list_of_embeddings])\n\n scores = {}\n\n for model_group in tqdm(self.models, desc='Test Review Groups'):\n\n # get the classifier\n classifier = self.models[model_group]\n\n # predictions as probabilities\n y_preds = classifier.predict_proba(x_test)\n\n probabilities = y_preds[:,1]\n\n # store scores of model\n scores[model_group] = probabilities\n\n scores = pd.DataFrame.from_dict(scores)\n\n return scores","def predict(self): \n return self.model.predict(self.test_x)","def predict(self, data):\n try:\n getattr(self, \"tree\")\n except AttributeError:\n raise RuntimeError(\"You must train classifer before predicting data!\")\n\n predicts_proba = self.predict_proba(data)\n predicts = _classify_from_probs(predicts_proba)\n return predicts","def _predict_label(self, df_train, df_test, label=None):\n #train k-nearest neighbors classifier \n neigh = KNeighborsClassifier(n_neighbors=5)\n X, y = df_train[['longitude', 'latitude']], df_train[label]\n neigh.fit(X, y)\n #predict the label for wildfire incidents\n pred_label = neigh.predict(df_test[['longitude', 'latitude']])\n return pred_label","def test_test_model(self):\n\n dataset = ClassificationTestDataset()\n model = ClassificationTestModel(dataset)\n preds = list(model.predict(dataset.examples))\n self.assertEqual(np.argmax(preds[0]['preds']), 2)\n self.assertEqual(np.argmax(preds[1]['preds']), 1)\n self.assertEqual(np.argmax(preds[2]['preds']), 4)\n self.assertEqual(np.argmax(preds[3]['preds']), 3)","def predict(self, X):\n num_test = X.shape[0]\n Ypred = np.zeros(num_test, dtype=self.ytr.dtype)\n\n # loop over all test rows\n for i in range(num_test):\n # 没有axis参数表示全部相加，axis＝0表示按列相加，axis＝1表示按照行的方向相加\n distances = np.sum(np.abs(self.Xtr - X[i, :]), axis=1)\n min_index = np.argmin(\n distances) # get the index with smallest distance\n Ypred[i] = self.ytr[\n min_index] # predict the label of the nearest example\n\n return Ypred","def predict(self, inputs):\n if self.use_logistic:\n return self.predict_labels_logistic(self.w, inputs)\n return predict_labels(self.w, inputs)","def predict(self):\n batch = get_predict_batch(1, num_rec_out=self.num_test_rec)\n self.g_model.test_batch(\n batch, self.global_step, num_rec_out=self.num_test_rec)","def predict_label(self, src): # real signature unknown; restored from __doc__\n pass","def predict(self, X): \n # Check is fit had been called\n check_is_fitted(self, ['X_', 'y_'])\n\n # Input validation\n X = check_array(X)\n\n j= 0\n predicted_labels = np.array([])\n while(j < X.shape[0]):\n current_batch_end = j+self.batch_size if j+self.batch_size < X.shape[0] else X.shape[0]\n current_batch = X[j:current_batch_end]\n self._feedforward(current_batch)\n predicted_labels = np.append(predicted_labels, np.take(self.map_labels, self.bmu_indices))\n j = current_batch_end\n \n return predicted_labels","def predict(self):\r\n\r\n # reshape test_array since it is a single row of data\r\n user_array = np.asanyarray(self.test_array).reshape(1, -1)\r\n # one hot encode user_array\r\n self.enc.fit(user_array)\r\n user_array = self.enc.transform(user_array)\r\n # create, train and predict the model with the dataset\r\n model = (\"Ridge\", linear_model.Ridge(alpha=0.01, random_state=4))\r\n model[1].fit(self.X_train, self.y_train)\r\n y_pred = model[1].predict(self.X_test)\r\n # predict with user provided chords\r\n y_usr = model[1].predict(user_array)\r\n if y_usr[0] < 0:\r\n y_usr[0] = 0\r\n acc = metrics.r2_score(self.y_test, y_pred)\r\n output = \"I am {}% sure that you like this progression.\".format('%.2f' % (100 * y_usr[0]))\r\n model_info = \"Predicted using a {} model with {} accuracy from {} data samples.\".format(model[0], '%.3f' % acc,\r\n self.data_count())\r\n return output, model_info","def predict(self, x):\n pred_labels = np.zeros((x.shape[0], 10))\n\n N = len(self.NET)\n for i in range(N):\n\n inputs = self.apply_dct_permutation(x.copy(), self.permutation[i])\n pred_labels += self.NET[i].model.predict(inputs)\n\n return pred_labels","def predict(self, params, test):\n vect_logit = np.vectorize(logit)\n vect_comp = np.vectorize(complement)\n n_test = np.shape(test)[0]\n prior = self.model_prior\n conditional = self.model_conditional\n K = len(prior)\n p = np.shape(conditional)[1]\n test_p = np.shape(test)[1]\n if p != test_p:\n print \"Error: Number of training and testing features differ\"\n return\n preds = []\n weight = vect_logit(conditional)\n # Stores weight matrix\n condition_comp = vect_comp(conditional)\n intercept = np.log(\n prior) + np.sum(np.apply_along_axis(np.log, 1, condition_comp), axis=1)\n # Stores intercept vector\n weight = weight.transpose()\n classifier = test.dot(weight) + intercept\n preds = np.argmax(classifier, axis=1) + 1\n # Add 1 because the classes have a 1-based index\n preds = preds.reshape(n_test, 1)\n return preds","def predict(self, test_dataset: Dataset) -> PredictionOutput:\n test_dataloader = self.get_test_dataloader(test_dataset)\n return self._prediction_loop(test_dataloader, description=\"Prediction\")","def predict(self, testx=None):\n if self.best_model is None:\n raise Exception(\"Train a model first\")\n\n if testx is None:\n testx = self.test_X\n\n return self._predict(testx)","def _predict(self, X):\n predictions = np.asarray([clf.predict(X) for clf in self.clfs_]).T\n predicted_labels = self.combiner.combine(predictions)\n return predicted_labels","def get_test_labels(self):\n raise NotImplementedError","def predict(model):\n # load test dataset\n test = dict(json.load(open('util_files/test.json')))\n ids = test['ids']\n data = test['data']\n\n df = pd.read_csv('data/document_departments.csv')\n labels = dict(df.values.tolist())\n\n id2cls = dict(json.load(open('util_files/id2cls.json')))\n \n ytrue = []\n ypredicted = []\n \n for i in range(len(data)):\n \n prediction = np.argmax(model.predict_on_batch(np.expand_dims(data[i], axis=0)))\n \n ypredicted.append(id2cls[str(prediction)])\n \n cls = labels[int(ids[i])]\n ytrue.append(cls)\n \n print \"classification report\"\n print classification_report(y_true=ytrue,\n y_pred=ypredicted)\n \n print \"*********************\"\n print \"Accuracy on test set\"\n print accuracy_score(y_true=ytrue,\n y_pred=ypredicted)\n print \"*********************\"","def predict(self, X):\n num_test = X.shape[0] #records the number of rows\n # lets make sure that the output type matches the input type\n Ypred = np.zeros(num_test, dtype = self.ytr.dtype) #with num_test rows of zeroes\n\n # loop over all test rows\n for i in range(num_test):\n # find the nearest training image to the i'th test image\n # using the L1 distance (sum of absolute value differences)\n \n #distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1)\n distances = np.sqrt(np.sum(np.square(self.Xtr - X[i,:]))) #another way of getting the distances, sqrt of sum of squares (standard)\n \n min_index = np.argmin(distances) # get the index with smallest distance\n Ypred[i] = self.ytr[min_index] # predict the label of the nearest example\n\n return Ypred #will have a prediction index Ypred[i] for each row/test image at i","def predict_labels(self, dists, k=1):\n num_test = dists.shape[0]\n y_pred = np.zeros(num_test)\n for i in range(num_test):\n # A list of length k storing the labels of the k nearest neighbors to\n # the ith test point.\n closest_y = []\n indices = np.argsort(dists[i])\n indices = indices[range(k)]\n closest_y = self.y_train[indices]\n counts = np.bincount(closest_y)\n y_pred[i] = np.argmax(counts)\n\n return y_pred","def predict(self, data):\n data['predicted'] = self.sentiment_classifier.predict_estimator(data)\n return data","def test_predict(self):\n \n\n model ,vec, x_testing=setup_log_reg_classifier(self.training_data, self.training_y, self.testing_data,\"text\", method=\"count\")\n \n model2 ,vec_tfidf, x_testing2=setup_log_reg_classifier(self.training_data, self.training_y, self.testing_data,\"text\", method=\"tfidf\")\n \n \n \"\"\" Test correct data types and corrrect range of predicted values (1,0) for predict with countVectorizer\"\"\" \n \n self.assertIsInstance(predict(model,x_testing),\n np.ndarray)\n \n self.assertTrue(([0,1] ==np.unique(predict(model2,x_testing2))).all())\n\n \n \"\"\" Test correct data types and corrrect range of predicted values (1,0) for predict with tfidfVectorizer\"\"\" \n \n self.assertIsInstance(predict(model,x_testing),\n np.ndarray)\n \n self.assertTrue(([0,1] ==np.unique(predict(model2,x_testing2))).all())","def predict(self, texts):\n\n texts = preprocess_text(texts)\n labels = self.pipeline.predict(texts)\n\n return labels","def classify(self):\n\n if self.classifier is None:\n raise ValueError('self.classifier is None')\n if self.df is None:\n raise ValueError('self.df is None')\n if self.features is None:\n raise ValueError('self.features is None')\n\n train_set = self.df[self.df[self.label_col] != CLASSIFIER_NAN]\n test_set = self.df[self.df[self.label_col] == CLASSIFIER_NAN]\n\n test_set_timestamps = list(test_set.index.strftime('%Y-%m-%d %H:%M:%S.%f'))\n\n self.classifier.fit(\n train_set[self.features],\n train_set[self.label_col]\n )\n\n preds = self.classifier.predict(test_set[self.features])\n probs = self.classifier.predict_proba(test_set[self.features])\n\n res = []\n\n for i in range(0, len(preds)):\n probability = max(probs[i])\n res.append([test_set_timestamps[i], preds[i], probability])\n\n return res","def predictAuthors(training_fvs, labels, test_fvs):\n clf = MultinomialNB()\n clf.fit(training_fvs, labels)\n return clf.predict(test_fvs)","def predict(self, X_test):\n if self.w is None: self.learn()\n \n Xt = np.append(np.ones((X_test.shape[0], 1)), X_test, axis=1)\n return np.dot(Xt, self.w)","def predict_labels(self, dists, k=1):\n num_test = dists.shape[0]\n y_pred = np.zeros(num_test)\n for i in range(num_test):\n indices = np.argsort(dists[i])[:k]\n closest_y = self.y_train[indices]\n y_pred_i = mode(closest_y)[0]\n y_pred[i] = y_pred_i\n return y_pred","def predict_labels(self, dists, k=1):\n num_test = dists.shape[0]\n y_pred = np.zeros(num_test)\n for i in range(num_test):\n # A list of length k storing the labels of the k nearest neighbors to\n # the ith test point.\n closest_y = []\n closest_y = self.y_train[np.argsort(dists[i])][0:k]\n closest_y = closest_y.astype(int)\n y_pred[i] = np.bincount(closest_y).argmax()\n return y_pred","def knnTest(k, knnTrained, dataTest):\n x_test = []\n for data in dataTest:\n x_test.append(data[0])\n\n y_pred = knnTrained.predict(x_test)\n\n print(\" + Pred: {class: \", y_pred, ', character: ', mapOfCharacters[y_pred[0]], '}')\n \n return y_pred","def predict(self):\n path = self._artifact_repo.artifact_path(self._ARTIFACT_MODEL)\n model = tf.keras.models.load_model(path)\n\n _, _, x_test, y_test = self._load_data()\n x_test = tf.keras.utils.normalize(x_test, axis=1)\n\n preds = model.predict(x_test)\n self._show_cf_matrix(np.array([np.argmax(probas) for probas in preds]), y_test)","def predict_estimator(self, X, y=None, labels=[0, 1]):\n # throw an exception if classifier is not trained\n if not self.classifier_trained:\n raise Exception(\"Train estimator first\")\n if len(X) == 1: # predict doesn't work if only one element\n X.append(\"\")\n labels = labels\n result = []\n input_features = self.sentences_to_features(\n X, [0 for i in range(len(X))])\n predict_input_fn = run_classifier.input_fn_builder(features=input_features,\n seq_length=self.params[\"MAX_SEQ_LENGTH\"],\n is_training=False, drop_remainder=False)\n predictions = self.estimator.predict(predict_input_fn)\n\n # output : tuple (sentence, probability of each class, predicted class)\n for sentence, prediction in zip(X, predictions):\n result.append(\n (sentence, np.exp(prediction['probabilities']), labels[prediction['labels']]))\n\n if y is not None:\n pred = [result[i][2] for i in range(len(result))]\n print(\"Accuracy: %s\" % accuracy_score(y, pred))\n print(\"Precision: %s\" % precision_score(y, pred))\n print(\"Recall: %s\" % recall_score(y, pred))\n print(\"f1: %s\" % f1_score(y, pred))\n print(confusion_matrix(y, pred))\n\n return result","def predict(self, X):\n\n\t\tn_samples = X.shape[0]\n\t\tpredicted = np.zeros(n_samples)\n\n\t\tfor i in xrange(n_samples):\n\t\t\tpredicted[i] = self.classify_example(X[i])\n\n\t\treturn predicted","def predict_proba(self, X_test):\n return self.classifier.predict_proba(X_test)","def predict(self, X_test):\n \n X_test = np.insert(X_test, 0, 1, axis=1)\n Y_out = self.W.T.dot(X_test.T)\n pred = np.argmax(Y_out, axis=0)\n \n \n return pred","def predict_labels(model):\n test_datagen = ImageDataGenerator(featurewise_center=True,\n featurewise_std_normalization=True\n #rescale=1. / 255,\n #samplewise_center=True,\n #samplewise_std_normalization=True\n )\n test_datagen.fit(test_data)\n # datagen.fit(val_data)\n # create generator for train data\n test_generator = test_datagen.flow(\n test_data,\n batch_size=batch_size,\n shuffle=False)\n pred_prob=model.predict_generator(test_generator,test_data.shape[0])\n pred_prob=pred_prob[:,0]\n def pre_class(x):\n \tif x<0.5:\n return 0\n else:\n return 1\n #def true_label(id):\n #\tif 'f0' in id:\n #\t return 0\n # elif 'f1' in id: \n # return 1\n #\telse:\n #\t pass\n #pred_true=map(true_label,test_id)\n #pred_true=np.array(pred_true)\n #print roc_auc_score(val_target, pred_prob)\n #prediction=map(pre_class,pred_prob)\n #print confusion_matrix(val_target,prediction)\n with open(\"prediction.csv\", \"w\") as f: \n\tp_writer = csv.writer(f, delimiter=',', lineterminator='\\n')\n for id,label in zip(test_id,pred_prob):\n\t p_writer.writerow([id, label])\n\t\n #base_path = \"PZ/test/test/\"\n\n #with open(\"prediction.csv\", \"w\") as f:\n # p_writer = csv.writer(f, delimiter=',', lineterminator='\\n')\n # for _, _, imgs in os.walk(base_path):\n # for im in imgs:\n # pic_id = im.split(\".\")[0]\n #img = cv2.imread(base_path+im)\n #img = cv2.resize(img, (img_width, img_height), cv2.INTER_LINEAR)\n #img = img.transpose((2,0,1))\n #img = np.expand_dims(img,axis=0)\n #img = load_img(base_path + im)\n #img = imresize(img, size=(img_height, img_width))\n #test_x = img_to_array(img).reshape(3, img_height, img_width)\n #test_x = test_x.reshape((1,) + test_x.shape)\n #test_datagen.fit(img)\n #test_generator = test_datagen.flow(img,\n # batch_size=1,\n # shuffle=False)\n #prediction = model.predict_generator(test_generator, 1)\n #p_writer.writerow([pic_id, prediction])","def predict(self, datafile):\r\n \r\n # We load the test data and lower the text\r\n data_test = pd.read_csv(datafile, sep = \"\\t\", names = [\"polarity\", \"category\", \"word\", \"offsets\", \"sentence\"])\r\n data_test['sentence_l'] = data_test['sentence'].apply(str.lower)\r\n data_test['word'] = data_test['word'].apply(str.lower)\r\n \r\n # We try to keep all the no/nor/not words as this changes radically the sentiment analysis\r\n data_test['sentence_l'] = data_test[\"sentence_l\"].apply(lambda sentence: sentence.replace(\"can\\'t\", \"can not\"))\r\n data_test['sentence_l'] = data_test[\"sentence_l\"].apply(lambda sentence: sentence.replace(\"n\\'t\", \" not\"))\r\n \r\n # We clean the data and stem the words\r\n clean_sentences = []\r\n for row in data_test['sentence_l']:\r\n tokens = word_tokenize(row)\r\n tokens = [word for word in tokens if word.isalpha()]\r\n tokens = [w for w in tokens if not w in self.stopwords] \r\n tokens = [self.stemmer.stem(word) for word in tokens]\r\n clean_sentences.append(tokens)\r\n data_test['stems'] = clean_sentences\r\n \r\n # We also stem the target words to be coherent with the stemmed words in the sentences\r\n data_test['word'] = [self.stemmer.stem(word) for word in data_test['word']]\r\n\r\n # We recreate the sentences with the selected and cleaned words\r\n Classifier.create_sentence = staticmethod(Classifier.create_sentence)\r\n data_test.clean_sentence = Classifier.create_sentence(data_test.stems)\r\n \r\n # We create a BOW vector\r\n reviews_new_counts = self.restaurant_vect.transform(data_test.clean_sentence)\r\n \r\n # We transform the BOW vector with the tfidf scores\r\n reviews_new_tfidf = self.tfidf_transformer.transform(reviews_new_counts)\r\n \r\n # We make a prediction with the classifier\r\n self.pred = self.model.predict(reviews_new_tfidf)\r\n \r\n return self.pred","def classify(self, data):\n \"*** YOUR CODE HERE ***\"\n return self.sklearn_classifier.predict(data)","def predict(self, X_test, lamb=None):\n self.y_pred_ = self.model_.predict(X_test, lamb=lamb)\n\n return self.y_pred_","def predict(self):\n train_array = np.array(self.labels != 0, dtype=float)\n if not self.ising:\n labels_logit = self.ising_weights['vertices']\n else:\n neigh_num = self.adj.dot(train_array)\n neigh_num = np.where(neigh_num == 0, 1, neigh_num)\n neigh_weights = self.ising_weights['edges'] * self.labels\n labels_logit = (np.multiply(neigh_weights, neigh_num**(-1))\n + self.ising_weights['vertices'])\n self.prediction = np.where(labels_logit > 0, 1, -1)\n return self","def mlp_classification_test(self, dataset, labels, number_of_labels, method,\n noise_ratio, sparsity_coeff, sensitivity):\n net_activity = self.full_net_dataset_response(dataset, method, \n noise_ratio, \n sparsity_coeff,\n sensitivity)\n last_layer_activity = net_activity[-1][0] \n concatenated_last_layer_activity = np.concatenate(last_layer_activity)\n predicted_labels_ev=self.mlp.predict(concatenated_last_layer_activity,batch_size=125)\n counter=0\n predicted_labels=[]\n for recording in range(len(last_layer_activity)):\n activity_sum = sum(predicted_labels_ev[counter:counter+len(last_layer_activity[recording])])\n predicted_labels.append(np.argmax(activity_sum))\n counter += len(last_layer_activity[recording])\n prediction_rate=0\n for i,true_label in enumerate(labels):\n prediction_rate += (predicted_labels[i] == true_label)/len(labels)\n return prediction_rate, predicted_labels, predicted_labels_ev","def class_predict_3(trained_model, X_test, y_test, image_name):\n # Predict test set\n try:\n test_pred = trained_model.predict_proba(X_test)\n except:\n test_pred = trained_model.predict(X_test)\n \n if len(test_pred.shape) == 1:\n raise Exception(\"Probabilistic prediction needed.\")\n \n # Transform y_test\n if len(y_test.shape) > 1:\n y_test = np.argmax(y_test, axis=1)\n \n classes = np.unique(y_test)\n results = np.zeros((len(classes), ))\n for class_num in classes:\n \n # Take predictions for current class\n X_pred = test_pred[y_test == class_num, :]\n \n # Number of hits\n pred_ok = (np.argmax(X_pred, axis=1) == class_num).sum()\n \n # Percentage of hits\n pred_acc = pred_ok / X_pred.shape[0]\n \n # Actualize data for plotting results\n results[class_num] = pred_acc\n \n # Write test message\n with open(OUTPUT_FILE, 'a') as f:\n f.write(\"test_acc of class {}: {:.3f}\\n\".format(class_num,\n pred_acc))\n \n # Generate accuracy plot\n plt.figure()\n plt.bar(classes, results, align='center')\n plt.xticks(classes, classes)\n plt.title('Per class test accuracy')\n plt.xlabel('class')\n plt.ylabel('accuracy')\n plt.legend()\n \n # Save test plot\n plot_file = os.path.join(OUTPUT_DIR, \"{}_test_accuracy\".format(image_name))\n plt.savefig(plot_file + \".svg\", bbox_inches='tight', format='svg')","def predict_ensemble(test_df):\n instances = [wongnai_predictor._dataset_reader.text_to_instance(word_tokenize(review)) \n for review in list(test_df.review)]\n model_paths = glob('output_*/model.tar.gz')\n all_predicted_labels = []\n for model_path in model_paths:\n archive = load_archive(model_path) # load trained model\n wongnai_predictor = Predictor.from_archive(archive, 'wongnai_predictor')\n predicted_labels = [int(wongnai_predictor.predict_instance(instance)['predicted_label']) \n for instance in instances]\n all_predicted_labels.append(predicted_labels)\n all_predicted_labels = np.array(all_predicted_labels)\n predicted_labels_vote = mode(np.array(all_predicted_labels).T, axis=-1).mode.ravel()\n test_df['rating'] = predicted_labels_vote\n return test_df.drop('review', axis=1)","def test(self):\n\t\treturn classification_report(self.test_labels, self.predict(self.test_data), target_names=self.le.classes_)","def _predict_labels(self) -> pd.Series:\n\n # get the prediction dataset\n data = self._get_prediction_data()\n data_as_array = data.to_numpy()\n\n if self._standardize_data:\n data_as_array = self._final_scaler.transform(data_as_array)\n\n # predict with final model using the optimal threshold\n y_pred = self._final_model.predict_proba(data_as_array)[:,1]\n threshold_predictions = [1 if y > self._optimal_threshold else 0 for y in y_pred]\n\n # create series out of predictions\n y_labels = pd.Series(data = threshold_predictions, index = data.index)\n return y_labels","def predict_labels(self, x: list, decode=\"posterior\"):\n assert decode in self.decode, \"decode `{}` is not valid\".format(decode)\n \n if decode is 'posterior':\n return self.posterior_decode(x)\n \n if decode is 'viterbi':\n return self.viterbi_decode(x)","def predict(self, x_test):\n x_test = self.tabular_preprocessor.encode(x_test)\n if self.clf is not None:\n y = self.clf.predict(x_test)\n elif self.save_filename is not None:\n booster = lgb.Booster(model_file=self.save_filename)\n y = booster.predict(x_test)\n else:\n pre_model_name = []\n for file in os.listdir(self.path):\n if file.endswith(\"_lgb.txt\"):\n file_ind_pat = re.compile(\"(\\d+)\")\n tmp_filename = int(file_ind_pat.findall(file)[0])\n pre_model_name.append(tmp_filename)\n total_model = len(pre_model_name)\n if total_model == 0:\n raise ValueError(\"Tabular predictor does not exist\")\n else:\n # Use the latest predictor\n self.save_filename = self.path + '/' + str(max(pre_model_name)) + '_lgb.txt'\n booster = lgb.Booster(model_file=self.save_filename)\n y = booster.predict(x_test)\n\n if y is None:\n raise ValueError(\"Tabular predictor does not exist\")\n return y","def predict(self, df):\n # TODO: REMOVE type column\n\n tokenizer = self.__create_tokenizer_from_hub_module()\n label_list = test_other[LABEL_COLUMN].unique().tolist()\n #label_list = [0, 1]\n test_features = self.__create_features(\n df, label_list,\n self.max_seq_len, tokenizer, 'text', 'type'\n )\n\n preds = []\n if type(self.model) == tf.estimator.Estimator:\n # Is trained\n input_fn = input_fn_builder(\n features=test_features,\n seq_length=self.max_seq_len,\n is_training=False,\n drop_remainder=False)\n pred = self.model.predict(input_fn=input_fn)\n for p in pred:\n preds.append(p)\n else:\n # Is loaded from a SavedModel\n # Format inputs\n inpu = {\n 'label_ids': np.array([x.label_id for x in test_features]).reshape(-1,),\n 'input_ids': np.array([x.input_ids for x in test_features]).reshape(-1, self.max_seq_len),\n 'input_mask': np.array([x.input_mask for x in test_features]).reshape(-1, self.max_seq_len),\n 'segment_ids': np.array([x.segment_ids for x in test_features]).reshape(-1, self.max_seq_len)\n }\n preds = self.model(inpu)\n\n return preds","def predict_estimator_test(self, X, y=None):\n if self.classifier_model.classifier_trained:\n results = self.classifier_model.predict_estimator(\n X, y, self.classifier_model.label_list)\n return results","def predict_labels(self, distances, k=1):\n\n num_test = distances.shape[0]\n Y_pred = np.zeros((num_test,))\n\n \n for i in range(num_test):\n # extracting k-nearest-neighbors for each test-point\n kNN_idxs = np.argsort(distances[i,:])[0:k]\n \n # voting among the k-nearest-neighbors\n kNN_labels = {}\n # print(type(kNN_labels))\n\n for j in range(k):\n m_label = self.Y_train[kNN_idxs[j]]\n if m_label in kNN_labels.keys():\n # print(type(kNN_labels))\n kNN_labels[m_label] += 1 # increment count\n else:\n # print(m_label,'....', type(kNN_labels))\n kNN_labels[m_label] = 1 # initial count when the label occurs\n \n # counting the winning label\n\n winning_label = kNN_labels.keys()[0] # initialization\n \n for label in kNN_labels.keys():\n if kNN_labels[label] > kNN_labels[winning_label]:\n winning_label = label\n elif kNN_labels[label] == kNN_labels[winning_label]:\n # tie breaker\n if label < winning_label:\n winning_label = label\n \n\n Y_pred[i] = winning_label # storing winning label for each test-point\n \n return Y_pred"],"string":"[\n \"def predict(self):\\n self.get_test_data()\\n predicted_labels = []\\n for row in self.test_data:\\n predicted_labels.append(DecisionTree.predict_row(self.classifier, row))\\n return predicted_labels\",\n \"def predict(self, X_test):\\n\\n # Predict Label 0\\n i = 0\\n X = X_test\\n\\n # Retrieve trained classifier for label 0\\n clf = self.trained[i]\\n\\n # Make prediction\\n y = clf.predict(X)\\n result = np.zeros((X_test.shape[0], self.label_dim))\\n\\n result[:, i] = y\\n\\n # Concatenate result to X\\n # X = sp.hstack([X, sp.csr_matrix(y)], format=\\\"csr\\\")\\n\\n # iterator = tqdm.trange(1, self.label_dim)\\n iterator = range(1, self.label_dim)\\n for i in iterator:\\n # Predict Label i\\n\\n # Retrieve trained classifier for label i\\n clf = self.trained[i]\\n\\n # Make prediction\\n y = clf.predict(X)\\n\\n result[:, i] = y\\n\\n # Concatenate result to X\\n # X = sp.hstack([X, sp.csr_matrix(y)], format=\\\"csr\\\")\\n\\n return result\",\n \"def predict(self, testData=[]):\\n result = []\\n for classValue in self._classAttrs:\\n #print(f'Computing Label: {classValue}, {self._classLabelMap[classValue]}')\\n result.append(self._computeCondProb(testData, classValue))\\n return self._classLabelMap[result.index(max(result))]\",\n \"def predictTest(k, train, test):\\r\\n\\r\\n pred_labels = []\\r\\n\\r\\n # for each instance in the testing dataset, calculate all L2 distance from all training instances\\r\\n for te in range(len(test)):\\r\\n all_D = np.zeros((len(train), 1))\\r\\n\\r\\n # calculate the L2 distance of the testing instance from each training instance\\r\\n for tr in range(len(train)):\\r\\n D = 0\\r\\n for var in range(len(train.columns)-1):\\r\\n # if feature is real-valued, add (testing value - training value)^2\\r\\n if train[var].dtype == np.float64 or train[var].dtype == np.int64:\\r\\n D += (test[var][te] - train[var][tr])**2\\r\\n # if feature is nominal, add 1 if testing and training values are different\\r\\n else:\\r\\n if test[var][te] != train[var][tr]:\\r\\n D += 1\\r\\n all_D[tr] = D**(1/2)\\r\\n\\r\\n # sort all L2 distances, select K closest neighbors, and choose the most prevalent label\\r\\n all_D = np.column_stack((all_D, np.array(range(len(train)))))\\r\\n all_D = all_D[np.argsort(all_D[:, 0])]\\r\\n prob_labels = train[len(train.columns)-1][all_D[0:k, 1]].as_matrix()\\r\\n pred_labels.append(Counter(prob_labels).most_common(1)[0][0])\\r\\n\\r\\n return pred_labels\",\n \"def predict(self, X_test):\\n predicted_label = [self._predict(x_test) for x_test in X_test]\\n\\n return np.array(predicted_label)\",\n \"def predict(self, test_set, test_labels):\\n\\n with tf.Session() as self.tf_session:\\n self.tf_saver.restore(self.tf_session, self.models_dir + self.model_name)\\n return self.accuracy.eval({self.input_data: test_set, self.input_labels: test_labels})\",\n \"def predict_labels(model, x_test):\\n \\n pred = model.predict(x_test)\\n #pred_labels = model.predict_classes(x_test) # depricated\\n pred_labels = np.argmax(model.predict(x_test), axis=-1)\\n \\n return pred, pred_labels\",\n \"def predict(self, X, y=None):\\n # Check is fit had been called\\n check_is_fitted(self, ['X_', 'y_'])\\n\\n _, Predicted_Labels =\\\\\\n RankSVM_test(test_data=X,\\n num_class=self.num_class,\\n Weights=self.Weights,\\n Bias=self.Bias,\\n SVs=self.SVs,\\n svm=self.svm, gamma=self.gamma,\\n coefficient=self.coefficient,\\n degree=self.degree)\\n\\n return Predicted_Labels\",\n \"def test(self, test_instances, test_labels):\\n scores = self.classifier.predict(test_instances)\\n # TODO: print report\",\n \"def predict(self, test_file_path: str) -> List[Dict[str, float]]:\\n # TODO write code to extract features from test_file_path and \\n # predict the labels for the model.\\n pass\",\n \"def predict(self):\\n self.predicted_test_summary = []\\n for step in xrange(0, self.test_size // self.test_batch_size):\\n print 'Predicting Batch No.:', step\\n offset = (step * self.test_batch_size) % self.test_size\\n batch_data_fwd = self.X_tst_fwd[offset:(offset + self.test_batch_size), :].T\\n batch_data_bwd = self.X_tst_bwd[offset:(offset + self.test_batch_size), :].T\\n summary_test_out = self._predict_batch(batch_data_fwd, batch_data_bwd)\\n self.predicted_test_summary.extend(summary_test_out)\\n\\n print 'Prediction Complete. Moving Forward..'\\n\\n # test answers\\n self.test_review = self.X_tst_fwd\\n self.predicted_test_summary = self.predicted_test_summary\\n self.true_summary = self.Y_tst\",\n \"def predict(self, test_vectors):\\n # Calculate the best matching label for each node\\n if not self.ready_for_prediction:\\n # totals = sum((node.labels for node in self.codebook), Counter())\\n for node in self.codebook:\\n # Remove unlabeled hits\\n try:\\n node.labels.pop(None)\\n except KeyError:\\n pass\\n # # Take into account small clusters. A frequency approach\\n # freq_counter = Counter({label: count / totals[label]\\n # for label, count in node.labels.items()})\\n # if len(freq_counter) > 0:\\n # node.label = freq_counter.most_common(1)[0][0]\\n # else:\\n # node.label = ''\\n # Or ignore small clusters and just aim for accuracy\\n if len(node.labels) > 0:\\n node.label = node.labels.most_common(1)[0][0]\\n else:\\n node.label = ''\\n self.ready_for_prediction = True\\n\\n # Return the label of the best matching unit for the given test_vectors\\n if isinstance(test_vectors, collections.Iterable):\\n return [self.bmu(test_vector).label for test_vector in test_vectors]\\n else:\\n return self.bmu(test_vectors).label\",\n \"def _predict(self, classify: np.array, n_preds=1):\\r\\n tmp = classify.argsort()[:, :n_preds] # Return the index of the best label classification\\r\\n preds = copy(tmp) # allow to copy tmp\\r\\n for index, target in enumerate(self.targets):\\r\\n preds = np.where(tmp == index, target, preds) # Return the target label corresponding to the index\\r\\n self.preds = preds\",\n \"def predict(self, testFeatures): \\r\\n\\r\\n if(not self._fitCalled):\\r\\n print('The fit method has not been called yet')\\r\\n return None\\r\\n\\r\\n l,d = testFeatures.shape\\r\\n n,d = self.data.shape \\r\\n\\r\\n \\\"\\\"\\\" Fill and return this in your implementation. \\\"\\\"\\\"\\r\\n predictions = np.empty(shape=(l,), dtype=self.labels.dtype)\\r\\n\\r\\n \\\"\\\"\\\" Implement kNN prediction here. \\\"\\\"\\\"\\r\\n\\r\\n for i in range(0, l):\\r\\n distances = []\\r\\n for j in range(0, n):\\r\\n distances.append((np.sqrt(np.sum((testFeatures[i]-self.data[j])**2)), self.labels[j]))\\r\\n distances.sort()\\r\\n kNearestLabels = [x[1] for x in distances][0:self.k]\\r\\n most_common, num_most_common = Counter(kNearestLabels).most_common(1)[0]\\r\\n predictions[i] = most_common\\r\\n return predictions\",\n \"def predict(test_dataset,test_tX,weights):\\n for idx, dataset in enumerate(test_tX):\\n test_dataset[idx]['Prediction'] = predict_labels(weights[idx],dataset)\\n return test_dataset\",\n \"def predict(self, test_data):\\n return self.leader.predict(test_data)\",\n \"def test(self) -> None:\\n\\n self._predictions = self._lr.predict(self._X_test)\",\n \"def fit_predict(self):\\n self.classifier = self.model\\n self.classifier.fit(self.X_sample, self.y_sample)\\n self.y_pred = self.classifier.predict(self.X_test)\",\n \"def predict(self, X):\\r\\n num_test = X.shape[0]\\r\\n # lets make sure that the output type matches the input type\\r\\n Ypred = np.zeros(num_test, dtype = self.ytr.dtype)\\r\\n\\r\\n # loop over all test rows\\r\\n for i in range(num_test):\\r\\n print (\\\"Testing example \\\" + str(i))\\r\\n distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1)\\r\\n # distances = self.chi2_distance(self.Xtr, X[i,:])\\r\\n min_index = np.argmin(distances) # get the index with smallest distance\\r\\n Ypred[i] = self.ytr[min_index] # predict the label of the nearest example\\r\\n print (\\\"Class Label: \\\" + str(Yte[i]) + \\\" \\\" + \\\"Predicted label: \\\" + str(Ypred[i]))\\r\\n return Ypred\",\n \"def predict(self, data):\\n xdata, _ = self.array_from_cases(data)\\n preds = self.model.predict(xdata)\\n label_preds = [dict(zip(self.binarizer.classes_, pred)) for pred in preds]\\n return label_preds\",\n \"def predict(self, test):\\n test_data = np.asarray(test)\\n assert self.x is not None and self.y is not None, \\\"You must train the classifier before testing\\\"\\n results = []\\n for i in range(test_data.shape[0]):\\n m = self.x - test_data[i]\\n # dist holds the Euclidean distance to every training point\\n dist = np.sum(m*m, 1)\\n # this call uses a quickselect algo to find k-smallest\\n ind = np.argpartition(dist, self.k)[:self.k]\\n # take the class present the most among the k closest\\n out = int(scipy.stats.mode(self.y[ind], axis=None)[0])\\n results.append(out)\\n return results\",\n \"def _predict(self, data):\\n # make sure we're talking about arrays\\n data = N.asarray(data)\\n\\n # checks only in debug mode\\n if __debug__:\\n if not data.ndim == 2:\\n raise ValueError, \\\"Data array must be two-dimensional.\\\"\\n\\n if not data.shape[1] == self.__data.nfeatures:\\n raise ValueError, \\\"Length of data samples (features) does \\\" \\\\\\n \\\"not match the classifier.\\\"\\n\\n # compute the distance matrix between training and test data with\\n # distances stored row-wise, ie. distances between test sample [0]\\n # and all training samples will end up in row 0\\n dists = self.__dfx(self.__data.samples, data).T\\n\\n # determine the k nearest neighbors per test sample\\n knns = dists.argsort(axis=1)[:, :self.__k]\\n\\n # predicted class labels will go here\\n predicted = []\\n\\n if self.__voting == 'majority':\\n vfx = self.getMajorityVote\\n elif self.__voting == 'weighted':\\n vfx = self.getWeightedVote\\n else:\\n raise ValueError, \\\"kNN told to perform unknown voting '%s'.\\\" \\\\\\n % self.__voting\\n\\n # perform voting\\n results = [vfx(knn) for knn in knns]\\n\\n # extract predictions\\n predicted = [r[0] for r in results]\\n\\n # store the predictions in the state. Relies on State._setitem to do\\n # nothing if the relevant state member is not enabled\\n self.predictions = predicted\\n self.values = [r[1] for r in results]\\n\\n return predicted\",\n \"def predict(self, X):\\n num_test = X.shape[0]\\n # lets make sure that the output type matches the input type\\n Ypred = np.zeros(num_test, dtype = self.ytr.dtype)\\n\\n # loop over all test rows\\n for i in range(num_test):\\n # find the nearest training image to the i'th test image\\n # using the L1 distance (sum of absolute value differences)\\n #distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1) # L1 distance\\n distances = np.sqrt(np.sum(np.square(self.Xtr - X[i, :]), axis=1)) # L2 distance\\n min_index = np.argmin(distances) # get the index with smallest distance\\n Ypred[i] = self.ytr[min_index] # predict the label of the nearest example\\n\\n return Ypred\",\n \"def test_predict(self):\\n\\n classifier = BertCCAMClassifier()\\n classifier.load_model(\\\"models\\\")\\n prediction = classifier.predict([\\\"bartosz\\\"])\\n self.assertEqual(prediction, [{\\\"labels\\\": (\\\"B\\\",)}])\\n\\n # with multiple labels\\n prediction = classifier.predict([\\\"ala bert\\\"])\\n self.assertEqual(prediction, [{\\\"labels\\\": (\\\"A\\\", \\\"B\\\")}])\\n\\n # in a batch\\n prediction = classifier.predict([\\\"bartosz\\\", \\\"adam\\\"])\\n self.assertEqual(prediction, [{\\\"labels\\\": (\\\"B\\\",)}, {\\\"labels\\\": (\\\"A\\\",)}])\",\n \"def predict(self, X_test):\\n return self.model.predict(X_test)\",\n \"def predict(self, X):\\n\\n num_test=X.shape[0]\\n\\n #make sure that the output type matches the input type\\n Ypred = np.zeros(num_test, dtype=self.ytr.dtype)\\n\\n #Loop over all test rows\\n for i in xrange(num_test): #https://www.geeksforgeeks.org/range-vs-xrange-python/\\n #find the nearest training image to the ith test image\\n #using the L1 distance (sum of absolute value differences)\\n print \\\"Running test example %d\\\" % (i)\\n #distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1)\\n distances = np.sum(np.square(self.Xtr - X[i,:]), axis=1)\\n min_index = np.argmin(distances) #get the index with the smallest distance\\n Ypred[i] = self.ytr[min_index] #predict the lable of the nearest example\\n\\n return Ypred\",\n \"def predict(self, Xtest):\\n ytest = np.dot(Xtest, self.weights)\\n return ytest\",\n \"def fit_predict(self, X, y=None):\\n self.fit(X)\\n return self.labels_\",\n \"def fit_predict(self, X, y=None):\\n self.fit(X)\\n return self.labels_\",\n \"def predict(self, X):\\n prob = self.predict_proba(X)\\n if self.rule == 'fda':\\n prob_1 = prob[:, :self.n_class_]\\n prob_2 = prob[:, self.n_class_:]\\n return np.vstack((self.labels_[prob_1.argmax(1)], self.labels_[prob_2.argmax(1)]))\\n else:\\n return self.labels_[prob.argmax(1)]\",\n \"def predict(self,X):\\n y_pred = np.random.choice(self.labels, size=(X.shape[0],), p=self.thresholds)\\n return y_pred\",\n \"def test(self, dataset = None, debug = True, labels = None):\\n\\n\\t\\tdataset = self.vectorize(dataset) if (dataset != None) else self.testing_set_vector;\\n\\t\\tlabels = labels if (labels != None) else self.testing_labels;\\n\\n\\t\\tprediction = self.classifier.predict(dataset)\\n\\n\\t\\tif(debug):\\n\\t\\t\\tprint(classification_report(labels, prediction))\\n\\n\\t\\treturn prediction\",\n \"def predict(self, model, x_test):\\n pass\",\n \"def test_text_classifier_get_labels(self):\\n pass\",\n \"def predictSet(self, testData=\\\"\\\"):\\n rawTestDataDump = self._read_file(testData)\\n formattedTestData = [line.split(' ') for line in rawTestDataDump.split('\\\\n')]\\n for test in formattedTestData:\\n self._predictions.append(self.predict(test))\\n return self._predictions\",\n \"def _predict(self, testX):\\n pass\",\n \"def predict(self):\\n train_vec, test_vec = self.get_tfidf_vectors()\\n clf = self.get_classifier()\\n\\n print '-'*40\\n print 'Making predictions ...'\\n clf.fit(train_vec, self.train_ans)\\n clf_predictions = clf.predict_proba(test_vec)\\n\\n print 'Storing predictions in', self.pred_file\\n pred_out = [\\\"Id,predictions\\\"]\\n num_pred = range(30)\\n for fid, pred in zip(self.test_index, clf_predictions):\\n top_rec = sorted(num_pred, key=lambda k: pred[k], reverse=True)[:3]\\n pred_out.append(\\\"%s,%s\\\" % (fid, ' '.join( [clf.classes_[rec] for rec in top_rec] )))\\n with open(self.pred_file, 'w') as f:\\n f.write('%s\\\\n' % ('\\\\n'.join(pred_out)))\",\n \"def predict(self, test_data):\\n random.seed(self.seed)\\n preds = [{\\\"id\\\": instance['id'], \\\"prediction\\\": random.choice([0, 1])} for instance in test_data]\\n return preds\",\n \"def predict_class(clf, X_test, Y_test, labels=None, stats_fname=None):\\n expected = Y_test\\n if isinstance(clf, KerasModel):\\n char_probs = clf.predict(X_test)\\n predicted = np.argmax(char_probs, axis=1)\\n\\n if len(Y_test.shape) > 1:\\n expected = np.argmax(Y_test, axis=1)\\n else:\\n predicted = clf.predict(X_test)\\n\\n conf_mat = metrics.confusion_matrix(\\n expected, predicted, labels=range(len(labels))\\n )\\n\\n stats = {\\n 'Accuracy': metrics.accuracy_score(expected, predicted),\\n 'F1': metrics.f1_score(expected, predicted, average='weighted'),\\n 'Precision': metrics.precision_score(expected, predicted,\\n average='weighted'),\\n 'Recall': metrics.recall_score(expected, predicted,\\n average='weighted')\\n }\\n print('Accuracy: %f' % stats['Accuracy'])\\n print('F1: %f' % stats['F1'])\\n print('percision: %f' % stats['Precision'])\\n print('recall: %f' % stats['Recall'])\\n\\n save_conf_mat(conf_mat, stats, labels, stats_fname)\\n\\n return predicted\",\n \"def model_predict(classifier, X_test:list) -> list:\\n y_predict = classifier.predict(X_test)\\n return y_predict\",\n \"def predict(self):\\n\\n if self.test_file is not None:\\n for user in self.test_set['users']:\\n pu = self.p[self.user_to_user_id[user]] + self.y_sum_rows(self.user_to_user_id[user])\\n\\n for item in self.test_set['feedback'][user]:\\n self.predictions.append(\\n (user, item, self._predict_svd_plus_plus_score(self.user_to_user_id[user],\\n self.item_to_item_id[item], pu, True)))\\n else:\\n raise NotImplemented\",\n \"def classify (self, text_test):\\n test_features = self.vectorizer.transform(text_test)\\n return self.nbc.predict(test_features)\",\n \"def getPredictions(self):\\n\\t\\tself.bestLabel = self.testingProbs.apply(lambda x: x.argmax(),1)\",\n \"def predict(model, X):\\n\\tmodel.eval()\\n\\t# make the predictions\\n\\tscores = model.forward(X)\\n\\n\\t# scores contains, for each example, two scores that can be interpreted as the\\n\\t# probability of each example belonging to each of the classes. To select the\\n\\t# final predicted label, we will select the class with higher probability.\\n\\tpredicted_labels = scores.argmax(dim=-1) # predicted_labels shape: (n_examples)\\n\\n\\treturn predicted_labels\",\n \"def test():\\n # load dataset and model\\n X, observed_y = load_data('../data/dev.txt')\\n\\n model = pickle.load(open('test.model', 'rb'))\\n model.traverse()\\n\\n # predict labels for dataset\\n preds = model.predict(X)\\n\\n # print(preds)\\n # output model predictions\\n np.savetxt('test.predictions', preds, fmt='%s')\",\n \"def predict(self, data, training_report=False):\\n output = []\\n for r in range(0, len(data)):\\n label = self.predict_single(data.iloc[r])\\n output.append(label)\\n\\n label_array = data[[self.class_column]].as_matrix()\\n target = list(pd.DataFrame(label_array)[0])\\n\\n if training_report:\\n self.fit_report['output'] = output\\n self.fit_report['target'] = target\\n print(\\\"Training Fit done.\\\")\\n self.report()\\n\\n else:\\n self.predict_summary['output'] = output\\n self.predict_summary['target'] = target\\n\\n print(\\\"Testing done.\\\")\\n self.summary()\",\n \"def predict(self, test_data):\\r\\n return self.gs.predict(test_data)\",\n \"def test_model (self, text_test, labels_test):\\n print(classification_report(labels_test, self.classify(text_test)))\",\n \"def predict(self, Xtt):\\n # predict outputs for test dataset\\n self.logger.info(\\n self.__name__ + ' predicts on {:d} samples.'.format(Xtt.shape[0]))\\n pass\",\n \"def predict(self, testX):\\n predicted = self.model.predict(testX)\\n return predicted\",\n \"def predict(self):\\n probabilities = self.probability_array()\\n # THIS ASSUMES the classifiers are in order: 0th column of the\\n # probabilities corresponds to label = 0, ..., 9th col is for 9.\\n classes = np.argmax(probabilities, axis=1)\\n return classes\",\n \"def evaluate(y_test, pred_labels):\\n \\n # Converts one-hot code to a label (the index of 1)\\n y_test_labels = np.argmax(y_test, axis=1)\\n \\n # Compare test labels to predicted labels\\n score = accuracy_score(y_test_labels, pred_labels)\\n \\n return y_test_labels, score\",\n \"def predict(self, x_test):\\n\\n # convert input to format for classifier\\n list_of_embeddings = list(x_test[self.embeddings_col])\\n x_test = np.array([[float(i) for i in embedding.strip('[]').split()] for embedding in list_of_embeddings])\\n\\n scores = {}\\n\\n for model_group in tqdm(self.models, desc='Test Review Groups'):\\n\\n # get the classifier\\n classifier = self.models[model_group]\\n\\n # predictions as probabilities\\n y_preds = classifier.predict_proba(x_test)\\n\\n probabilities = y_preds[:,1]\\n\\n # store scores of model\\n scores[model_group] = probabilities\\n\\n scores = pd.DataFrame.from_dict(scores)\\n\\n return scores\",\n \"def predict(self): \\n return self.model.predict(self.test_x)\",\n \"def predict(self, data):\\n try:\\n getattr(self, \\\"tree\\\")\\n except AttributeError:\\n raise RuntimeError(\\\"You must train classifer before predicting data!\\\")\\n\\n predicts_proba = self.predict_proba(data)\\n predicts = _classify_from_probs(predicts_proba)\\n return predicts\",\n \"def _predict_label(self, df_train, df_test, label=None):\\n #train k-nearest neighbors classifier \\n neigh = KNeighborsClassifier(n_neighbors=5)\\n X, y = df_train[['longitude', 'latitude']], df_train[label]\\n neigh.fit(X, y)\\n #predict the label for wildfire incidents\\n pred_label = neigh.predict(df_test[['longitude', 'latitude']])\\n return pred_label\",\n \"def test_test_model(self):\\n\\n dataset = ClassificationTestDataset()\\n model = ClassificationTestModel(dataset)\\n preds = list(model.predict(dataset.examples))\\n self.assertEqual(np.argmax(preds[0]['preds']), 2)\\n self.assertEqual(np.argmax(preds[1]['preds']), 1)\\n self.assertEqual(np.argmax(preds[2]['preds']), 4)\\n self.assertEqual(np.argmax(preds[3]['preds']), 3)\",\n \"def predict(self, X):\\n num_test = X.shape[0]\\n Ypred = np.zeros(num_test, dtype=self.ytr.dtype)\\n\\n # loop over all test rows\\n for i in range(num_test):\\n # 没有axis参数表示全部相加，axis＝0表示按列相加，axis＝1表示按照行的方向相加\\n distances = np.sum(np.abs(self.Xtr - X[i, :]), axis=1)\\n min_index = np.argmin(\\n distances) # get the index with smallest distance\\n Ypred[i] = self.ytr[\\n min_index] # predict the label of the nearest example\\n\\n return Ypred\",\n \"def predict(self, inputs):\\n if self.use_logistic:\\n return self.predict_labels_logistic(self.w, inputs)\\n return predict_labels(self.w, inputs)\",\n \"def predict(self):\\n batch = get_predict_batch(1, num_rec_out=self.num_test_rec)\\n self.g_model.test_batch(\\n batch, self.global_step, num_rec_out=self.num_test_rec)\",\n \"def predict_label(self, src): # real signature unknown; restored from __doc__\\n pass\",\n \"def predict(self, X): \\n # Check is fit had been called\\n check_is_fitted(self, ['X_', 'y_'])\\n\\n # Input validation\\n X = check_array(X)\\n\\n j= 0\\n predicted_labels = np.array([])\\n while(j < X.shape[0]):\\n current_batch_end = j+self.batch_size if j+self.batch_size < X.shape[0] else X.shape[0]\\n current_batch = X[j:current_batch_end]\\n self._feedforward(current_batch)\\n predicted_labels = np.append(predicted_labels, np.take(self.map_labels, self.bmu_indices))\\n j = current_batch_end\\n \\n return predicted_labels\",\n \"def predict(self):\\r\\n\\r\\n # reshape test_array since it is a single row of data\\r\\n user_array = np.asanyarray(self.test_array).reshape(1, -1)\\r\\n # one hot encode user_array\\r\\n self.enc.fit(user_array)\\r\\n user_array = self.enc.transform(user_array)\\r\\n # create, train and predict the model with the dataset\\r\\n model = (\\\"Ridge\\\", linear_model.Ridge(alpha=0.01, random_state=4))\\r\\n model[1].fit(self.X_train, self.y_train)\\r\\n y_pred = model[1].predict(self.X_test)\\r\\n # predict with user provided chords\\r\\n y_usr = model[1].predict(user_array)\\r\\n if y_usr[0] < 0:\\r\\n y_usr[0] = 0\\r\\n acc = metrics.r2_score(self.y_test, y_pred)\\r\\n output = \\\"I am {}% sure that you like this progression.\\\".format('%.2f' % (100 * y_usr[0]))\\r\\n model_info = \\\"Predicted using a {} model with {} accuracy from {} data samples.\\\".format(model[0], '%.3f' % acc,\\r\\n self.data_count())\\r\\n return output, model_info\",\n \"def predict(self, x):\\n pred_labels = np.zeros((x.shape[0], 10))\\n\\n N = len(self.NET)\\n for i in range(N):\\n\\n inputs = self.apply_dct_permutation(x.copy(), self.permutation[i])\\n pred_labels += self.NET[i].model.predict(inputs)\\n\\n return pred_labels\",\n \"def predict(self, params, test):\\n vect_logit = np.vectorize(logit)\\n vect_comp = np.vectorize(complement)\\n n_test = np.shape(test)[0]\\n prior = self.model_prior\\n conditional = self.model_conditional\\n K = len(prior)\\n p = np.shape(conditional)[1]\\n test_p = np.shape(test)[1]\\n if p != test_p:\\n print \\\"Error: Number of training and testing features differ\\\"\\n return\\n preds = []\\n weight = vect_logit(conditional)\\n # Stores weight matrix\\n condition_comp = vect_comp(conditional)\\n intercept = np.log(\\n prior) + np.sum(np.apply_along_axis(np.log, 1, condition_comp), axis=1)\\n # Stores intercept vector\\n weight = weight.transpose()\\n classifier = test.dot(weight) + intercept\\n preds = np.argmax(classifier, axis=1) + 1\\n # Add 1 because the classes have a 1-based index\\n preds = preds.reshape(n_test, 1)\\n return preds\",\n \"def predict(self, test_dataset: Dataset) -> PredictionOutput:\\n test_dataloader = self.get_test_dataloader(test_dataset)\\n return self._prediction_loop(test_dataloader, description=\\\"Prediction\\\")\",\n \"def predict(self, testx=None):\\n if self.best_model is None:\\n raise Exception(\\\"Train a model first\\\")\\n\\n if testx is None:\\n testx = self.test_X\\n\\n return self._predict(testx)\",\n \"def _predict(self, X):\\n predictions = np.asarray([clf.predict(X) for clf in self.clfs_]).T\\n predicted_labels = self.combiner.combine(predictions)\\n return predicted_labels\",\n \"def get_test_labels(self):\\n raise NotImplementedError\",\n \"def predict(model):\\n # load test dataset\\n test = dict(json.load(open('util_files/test.json')))\\n ids = test['ids']\\n data = test['data']\\n\\n df = pd.read_csv('data/document_departments.csv')\\n labels = dict(df.values.tolist())\\n\\n id2cls = dict(json.load(open('util_files/id2cls.json')))\\n \\n ytrue = []\\n ypredicted = []\\n \\n for i in range(len(data)):\\n \\n prediction = np.argmax(model.predict_on_batch(np.expand_dims(data[i], axis=0)))\\n \\n ypredicted.append(id2cls[str(prediction)])\\n \\n cls = labels[int(ids[i])]\\n ytrue.append(cls)\\n \\n print \\\"classification report\\\"\\n print classification_report(y_true=ytrue,\\n y_pred=ypredicted)\\n \\n print \\\"*********************\\\"\\n print \\\"Accuracy on test set\\\"\\n print accuracy_score(y_true=ytrue,\\n y_pred=ypredicted)\\n print \\\"*********************\\\"\",\n \"def predict(self, X):\\n num_test = X.shape[0] #records the number of rows\\n # lets make sure that the output type matches the input type\\n Ypred = np.zeros(num_test, dtype = self.ytr.dtype) #with num_test rows of zeroes\\n\\n # loop over all test rows\\n for i in range(num_test):\\n # find the nearest training image to the i'th test image\\n # using the L1 distance (sum of absolute value differences)\\n \\n #distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1)\\n distances = np.sqrt(np.sum(np.square(self.Xtr - X[i,:]))) #another way of getting the distances, sqrt of sum of squares (standard)\\n \\n min_index = np.argmin(distances) # get the index with smallest distance\\n Ypred[i] = self.ytr[min_index] # predict the label of the nearest example\\n\\n return Ypred #will have a prediction index Ypred[i] for each row/test image at i\",\n \"def predict_labels(self, dists, k=1):\\n num_test = dists.shape[0]\\n y_pred = np.zeros(num_test)\\n for i in range(num_test):\\n # A list of length k storing the labels of the k nearest neighbors to\\n # the ith test point.\\n closest_y = []\\n indices = np.argsort(dists[i])\\n indices = indices[range(k)]\\n closest_y = self.y_train[indices]\\n counts = np.bincount(closest_y)\\n y_pred[i] = np.argmax(counts)\\n\\n return y_pred\",\n \"def predict(self, data):\\n data['predicted'] = self.sentiment_classifier.predict_estimator(data)\\n return data\",\n \"def test_predict(self):\\n \\n\\n model ,vec, x_testing=setup_log_reg_classifier(self.training_data, self.training_y, self.testing_data,\\\"text\\\", method=\\\"count\\\")\\n \\n model2 ,vec_tfidf, x_testing2=setup_log_reg_classifier(self.training_data, self.training_y, self.testing_data,\\\"text\\\", method=\\\"tfidf\\\")\\n \\n \\n \\\"\\\"\\\" Test correct data types and corrrect range of predicted values (1,0) for predict with countVectorizer\\\"\\\"\\\" \\n \\n self.assertIsInstance(predict(model,x_testing),\\n np.ndarray)\\n \\n self.assertTrue(([0,1] ==np.unique(predict(model2,x_testing2))).all())\\n\\n \\n \\\"\\\"\\\" Test correct data types and corrrect range of predicted values (1,0) for predict with tfidfVectorizer\\\"\\\"\\\" \\n \\n self.assertIsInstance(predict(model,x_testing),\\n np.ndarray)\\n \\n self.assertTrue(([0,1] ==np.unique(predict(model2,x_testing2))).all())\",\n \"def predict(self, texts):\\n\\n texts = preprocess_text(texts)\\n labels = self.pipeline.predict(texts)\\n\\n return labels\",\n \"def classify(self):\\n\\n if self.classifier is None:\\n raise ValueError('self.classifier is None')\\n if self.df is None:\\n raise ValueError('self.df is None')\\n if self.features is None:\\n raise ValueError('self.features is None')\\n\\n train_set = self.df[self.df[self.label_col] != CLASSIFIER_NAN]\\n test_set = self.df[self.df[self.label_col] == CLASSIFIER_NAN]\\n\\n test_set_timestamps = list(test_set.index.strftime('%Y-%m-%d %H:%M:%S.%f'))\\n\\n self.classifier.fit(\\n train_set[self.features],\\n train_set[self.label_col]\\n )\\n\\n preds = self.classifier.predict(test_set[self.features])\\n probs = self.classifier.predict_proba(test_set[self.features])\\n\\n res = []\\n\\n for i in range(0, len(preds)):\\n probability = max(probs[i])\\n res.append([test_set_timestamps[i], preds[i], probability])\\n\\n return res\",\n \"def predictAuthors(training_fvs, labels, test_fvs):\\n clf = MultinomialNB()\\n clf.fit(training_fvs, labels)\\n return clf.predict(test_fvs)\",\n \"def predict(self, X_test):\\n if self.w is None: self.learn()\\n \\n Xt = np.append(np.ones((X_test.shape[0], 1)), X_test, axis=1)\\n return np.dot(Xt, self.w)\",\n \"def predict_labels(self, dists, k=1):\\n num_test = dists.shape[0]\\n y_pred = np.zeros(num_test)\\n for i in range(num_test):\\n indices = np.argsort(dists[i])[:k]\\n closest_y = self.y_train[indices]\\n y_pred_i = mode(closest_y)[0]\\n y_pred[i] = y_pred_i\\n return y_pred\",\n \"def predict_labels(self, dists, k=1):\\n num_test = dists.shape[0]\\n y_pred = np.zeros(num_test)\\n for i in range(num_test):\\n # A list of length k storing the labels of the k nearest neighbors to\\n # the ith test point.\\n closest_y = []\\n closest_y = self.y_train[np.argsort(dists[i])][0:k]\\n closest_y = closest_y.astype(int)\\n y_pred[i] = np.bincount(closest_y).argmax()\\n return y_pred\",\n \"def knnTest(k, knnTrained, dataTest):\\n x_test = []\\n for data in dataTest:\\n x_test.append(data[0])\\n\\n y_pred = knnTrained.predict(x_test)\\n\\n print(\\\" + Pred: {class: \\\", y_pred, ', character: ', mapOfCharacters[y_pred[0]], '}')\\n \\n return y_pred\",\n \"def predict(self):\\n path = self._artifact_repo.artifact_path(self._ARTIFACT_MODEL)\\n model = tf.keras.models.load_model(path)\\n\\n _, _, x_test, y_test = self._load_data()\\n x_test = tf.keras.utils.normalize(x_test, axis=1)\\n\\n preds = model.predict(x_test)\\n self._show_cf_matrix(np.array([np.argmax(probas) for probas in preds]), y_test)\",\n \"def predict_estimator(self, X, y=None, labels=[0, 1]):\\n # throw an exception if classifier is not trained\\n if not self.classifier_trained:\\n raise Exception(\\\"Train estimator first\\\")\\n if len(X) == 1: # predict doesn't work if only one element\\n X.append(\\\"\\\")\\n labels = labels\\n result = []\\n input_features = self.sentences_to_features(\\n X, [0 for i in range(len(X))])\\n predict_input_fn = run_classifier.input_fn_builder(features=input_features,\\n seq_length=self.params[\\\"MAX_SEQ_LENGTH\\\"],\\n is_training=False, drop_remainder=False)\\n predictions = self.estimator.predict(predict_input_fn)\\n\\n # output : tuple (sentence, probability of each class, predicted class)\\n for sentence, prediction in zip(X, predictions):\\n result.append(\\n (sentence, np.exp(prediction['probabilities']), labels[prediction['labels']]))\\n\\n if y is not None:\\n pred = [result[i][2] for i in range(len(result))]\\n print(\\\"Accuracy: %s\\\" % accuracy_score(y, pred))\\n print(\\\"Precision: %s\\\" % precision_score(y, pred))\\n print(\\\"Recall: %s\\\" % recall_score(y, pred))\\n print(\\\"f1: %s\\\" % f1_score(y, pred))\\n print(confusion_matrix(y, pred))\\n\\n return result\",\n \"def predict(self, X):\\n\\n\\t\\tn_samples = X.shape[0]\\n\\t\\tpredicted = np.zeros(n_samples)\\n\\n\\t\\tfor i in xrange(n_samples):\\n\\t\\t\\tpredicted[i] = self.classify_example(X[i])\\n\\n\\t\\treturn predicted\",\n \"def predict_proba(self, X_test):\\n return self.classifier.predict_proba(X_test)\",\n \"def predict(self, X_test):\\n \\n X_test = np.insert(X_test, 0, 1, axis=1)\\n Y_out = self.W.T.dot(X_test.T)\\n pred = np.argmax(Y_out, axis=0)\\n \\n \\n return pred\",\n \"def predict_labels(model):\\n test_datagen = ImageDataGenerator(featurewise_center=True,\\n featurewise_std_normalization=True\\n #rescale=1. / 255,\\n #samplewise_center=True,\\n #samplewise_std_normalization=True\\n )\\n test_datagen.fit(test_data)\\n # datagen.fit(val_data)\\n # create generator for train data\\n test_generator = test_datagen.flow(\\n test_data,\\n batch_size=batch_size,\\n shuffle=False)\\n pred_prob=model.predict_generator(test_generator,test_data.shape[0])\\n pred_prob=pred_prob[:,0]\\n def pre_class(x):\\n \\tif x<0.5:\\n return 0\\n else:\\n return 1\\n #def true_label(id):\\n #\\tif 'f0' in id:\\n #\\t return 0\\n # elif 'f1' in id: \\n # return 1\\n #\\telse:\\n #\\t pass\\n #pred_true=map(true_label,test_id)\\n #pred_true=np.array(pred_true)\\n #print roc_auc_score(val_target, pred_prob)\\n #prediction=map(pre_class,pred_prob)\\n #print confusion_matrix(val_target,prediction)\\n with open(\\\"prediction.csv\\\", \\\"w\\\") as f: \\n\\tp_writer = csv.writer(f, delimiter=',', lineterminator='\\\\n')\\n for id,label in zip(test_id,pred_prob):\\n\\t p_writer.writerow([id, label])\\n\\t\\n #base_path = \\\"PZ/test/test/\\\"\\n\\n #with open(\\\"prediction.csv\\\", \\\"w\\\") as f:\\n # p_writer = csv.writer(f, delimiter=',', lineterminator='\\\\n')\\n # for _, _, imgs in os.walk(base_path):\\n # for im in imgs:\\n # pic_id = im.split(\\\".\\\")[0]\\n #img = cv2.imread(base_path+im)\\n #img = cv2.resize(img, (img_width, img_height), cv2.INTER_LINEAR)\\n #img = img.transpose((2,0,1))\\n #img = np.expand_dims(img,axis=0)\\n #img = load_img(base_path + im)\\n #img = imresize(img, size=(img_height, img_width))\\n #test_x = img_to_array(img).reshape(3, img_height, img_width)\\n #test_x = test_x.reshape((1,) + test_x.shape)\\n #test_datagen.fit(img)\\n #test_generator = test_datagen.flow(img,\\n # batch_size=1,\\n # shuffle=False)\\n #prediction = model.predict_generator(test_generator, 1)\\n #p_writer.writerow([pic_id, prediction])\",\n \"def predict(self, datafile):\\r\\n \\r\\n # We load the test data and lower the text\\r\\n data_test = pd.read_csv(datafile, sep = \\\"\\\\t\\\", names = [\\\"polarity\\\", \\\"category\\\", \\\"word\\\", \\\"offsets\\\", \\\"sentence\\\"])\\r\\n data_test['sentence_l'] = data_test['sentence'].apply(str.lower)\\r\\n data_test['word'] = data_test['word'].apply(str.lower)\\r\\n \\r\\n # We try to keep all the no/nor/not words as this changes radically the sentiment analysis\\r\\n data_test['sentence_l'] = data_test[\\\"sentence_l\\\"].apply(lambda sentence: sentence.replace(\\\"can\\\\'t\\\", \\\"can not\\\"))\\r\\n data_test['sentence_l'] = data_test[\\\"sentence_l\\\"].apply(lambda sentence: sentence.replace(\\\"n\\\\'t\\\", \\\" not\\\"))\\r\\n \\r\\n # We clean the data and stem the words\\r\\n clean_sentences = []\\r\\n for row in data_test['sentence_l']:\\r\\n tokens = word_tokenize(row)\\r\\n tokens = [word for word in tokens if word.isalpha()]\\r\\n tokens = [w for w in tokens if not w in self.stopwords] \\r\\n tokens = [self.stemmer.stem(word) for word in tokens]\\r\\n clean_sentences.append(tokens)\\r\\n data_test['stems'] = clean_sentences\\r\\n \\r\\n # We also stem the target words to be coherent with the stemmed words in the sentences\\r\\n data_test['word'] = [self.stemmer.stem(word) for word in data_test['word']]\\r\\n\\r\\n # We recreate the sentences with the selected and cleaned words\\r\\n Classifier.create_sentence = staticmethod(Classifier.create_sentence)\\r\\n data_test.clean_sentence = Classifier.create_sentence(data_test.stems)\\r\\n \\r\\n # We create a BOW vector\\r\\n reviews_new_counts = self.restaurant_vect.transform(data_test.clean_sentence)\\r\\n \\r\\n # We transform the BOW vector with the tfidf scores\\r\\n reviews_new_tfidf = self.tfidf_transformer.transform(reviews_new_counts)\\r\\n \\r\\n # We make a prediction with the classifier\\r\\n self.pred = self.model.predict(reviews_new_tfidf)\\r\\n \\r\\n return self.pred\",\n \"def classify(self, data):\\n \\\"*** YOUR CODE HERE ***\\\"\\n return self.sklearn_classifier.predict(data)\",\n \"def predict(self, X_test, lamb=None):\\n self.y_pred_ = self.model_.predict(X_test, lamb=lamb)\\n\\n return self.y_pred_\",\n \"def predict(self):\\n train_array = np.array(self.labels != 0, dtype=float)\\n if not self.ising:\\n labels_logit = self.ising_weights['vertices']\\n else:\\n neigh_num = self.adj.dot(train_array)\\n neigh_num = np.where(neigh_num == 0, 1, neigh_num)\\n neigh_weights = self.ising_weights['edges'] * self.labels\\n labels_logit = (np.multiply(neigh_weights, neigh_num**(-1))\\n + self.ising_weights['vertices'])\\n self.prediction = np.where(labels_logit > 0, 1, -1)\\n return self\",\n \"def mlp_classification_test(self, dataset, labels, number_of_labels, method,\\n noise_ratio, sparsity_coeff, sensitivity):\\n net_activity = self.full_net_dataset_response(dataset, method, \\n noise_ratio, \\n sparsity_coeff,\\n sensitivity)\\n last_layer_activity = net_activity[-1][0] \\n concatenated_last_layer_activity = np.concatenate(last_layer_activity)\\n predicted_labels_ev=self.mlp.predict(concatenated_last_layer_activity,batch_size=125)\\n counter=0\\n predicted_labels=[]\\n for recording in range(len(last_layer_activity)):\\n activity_sum = sum(predicted_labels_ev[counter:counter+len(last_layer_activity[recording])])\\n predicted_labels.append(np.argmax(activity_sum))\\n counter += len(last_layer_activity[recording])\\n prediction_rate=0\\n for i,true_label in enumerate(labels):\\n prediction_rate += (predicted_labels[i] == true_label)/len(labels)\\n return prediction_rate, predicted_labels, predicted_labels_ev\",\n \"def class_predict_3(trained_model, X_test, y_test, image_name):\\n # Predict test set\\n try:\\n test_pred = trained_model.predict_proba(X_test)\\n except:\\n test_pred = trained_model.predict(X_test)\\n \\n if len(test_pred.shape) == 1:\\n raise Exception(\\\"Probabilistic prediction needed.\\\")\\n \\n # Transform y_test\\n if len(y_test.shape) > 1:\\n y_test = np.argmax(y_test, axis=1)\\n \\n classes = np.unique(y_test)\\n results = np.zeros((len(classes), ))\\n for class_num in classes:\\n \\n # Take predictions for current class\\n X_pred = test_pred[y_test == class_num, :]\\n \\n # Number of hits\\n pred_ok = (np.argmax(X_pred, axis=1) == class_num).sum()\\n \\n # Percentage of hits\\n pred_acc = pred_ok / X_pred.shape[0]\\n \\n # Actualize data for plotting results\\n results[class_num] = pred_acc\\n \\n # Write test message\\n with open(OUTPUT_FILE, 'a') as f:\\n f.write(\\\"test_acc of class {}: {:.3f}\\\\n\\\".format(class_num,\\n pred_acc))\\n \\n # Generate accuracy plot\\n plt.figure()\\n plt.bar(classes, results, align='center')\\n plt.xticks(classes, classes)\\n plt.title('Per class test accuracy')\\n plt.xlabel('class')\\n plt.ylabel('accuracy')\\n plt.legend()\\n \\n # Save test plot\\n plot_file = os.path.join(OUTPUT_DIR, \\\"{}_test_accuracy\\\".format(image_name))\\n plt.savefig(plot_file + \\\".svg\\\", bbox_inches='tight', format='svg')\",\n \"def predict_ensemble(test_df):\\n instances = [wongnai_predictor._dataset_reader.text_to_instance(word_tokenize(review)) \\n for review in list(test_df.review)]\\n model_paths = glob('output_*/model.tar.gz')\\n all_predicted_labels = []\\n for model_path in model_paths:\\n archive = load_archive(model_path) # load trained model\\n wongnai_predictor = Predictor.from_archive(archive, 'wongnai_predictor')\\n predicted_labels = [int(wongnai_predictor.predict_instance(instance)['predicted_label']) \\n for instance in instances]\\n all_predicted_labels.append(predicted_labels)\\n all_predicted_labels = np.array(all_predicted_labels)\\n predicted_labels_vote = mode(np.array(all_predicted_labels).T, axis=-1).mode.ravel()\\n test_df['rating'] = predicted_labels_vote\\n return test_df.drop('review', axis=1)\",\n \"def test(self):\\n\\t\\treturn classification_report(self.test_labels, self.predict(self.test_data), target_names=self.le.classes_)\",\n \"def _predict_labels(self) -> pd.Series:\\n\\n # get the prediction dataset\\n data = self._get_prediction_data()\\n data_as_array = data.to_numpy()\\n\\n if self._standardize_data:\\n data_as_array = self._final_scaler.transform(data_as_array)\\n\\n # predict with final model using the optimal threshold\\n y_pred = self._final_model.predict_proba(data_as_array)[:,1]\\n threshold_predictions = [1 if y > self._optimal_threshold else 0 for y in y_pred]\\n\\n # create series out of predictions\\n y_labels = pd.Series(data = threshold_predictions, index = data.index)\\n return y_labels\",\n \"def predict_labels(self, x: list, decode=\\\"posterior\\\"):\\n assert decode in self.decode, \\\"decode `{}` is not valid\\\".format(decode)\\n \\n if decode is 'posterior':\\n return self.posterior_decode(x)\\n \\n if decode is 'viterbi':\\n return self.viterbi_decode(x)\",\n \"def predict(self, x_test):\\n x_test = self.tabular_preprocessor.encode(x_test)\\n if self.clf is not None:\\n y = self.clf.predict(x_test)\\n elif self.save_filename is not None:\\n booster = lgb.Booster(model_file=self.save_filename)\\n y = booster.predict(x_test)\\n else:\\n pre_model_name = []\\n for file in os.listdir(self.path):\\n if file.endswith(\\\"_lgb.txt\\\"):\\n file_ind_pat = re.compile(\\\"(\\\\d+)\\\")\\n tmp_filename = int(file_ind_pat.findall(file)[0])\\n pre_model_name.append(tmp_filename)\\n total_model = len(pre_model_name)\\n if total_model == 0:\\n raise ValueError(\\\"Tabular predictor does not exist\\\")\\n else:\\n # Use the latest predictor\\n self.save_filename = self.path + '/' + str(max(pre_model_name)) + '_lgb.txt'\\n booster = lgb.Booster(model_file=self.save_filename)\\n y = booster.predict(x_test)\\n\\n if y is None:\\n raise ValueError(\\\"Tabular predictor does not exist\\\")\\n return y\",\n \"def predict(self, df):\\n # TODO: REMOVE type column\\n\\n tokenizer = self.__create_tokenizer_from_hub_module()\\n label_list = test_other[LABEL_COLUMN].unique().tolist()\\n #label_list = [0, 1]\\n test_features = self.__create_features(\\n df, label_list,\\n self.max_seq_len, tokenizer, 'text', 'type'\\n )\\n\\n preds = []\\n if type(self.model) == tf.estimator.Estimator:\\n # Is trained\\n input_fn = input_fn_builder(\\n features=test_features,\\n seq_length=self.max_seq_len,\\n is_training=False,\\n drop_remainder=False)\\n pred = self.model.predict(input_fn=input_fn)\\n for p in pred:\\n preds.append(p)\\n else:\\n # Is loaded from a SavedModel\\n # Format inputs\\n inpu = {\\n 'label_ids': np.array([x.label_id for x in test_features]).reshape(-1,),\\n 'input_ids': np.array([x.input_ids for x in test_features]).reshape(-1, self.max_seq_len),\\n 'input_mask': np.array([x.input_mask for x in test_features]).reshape(-1, self.max_seq_len),\\n 'segment_ids': np.array([x.segment_ids for x in test_features]).reshape(-1, self.max_seq_len)\\n }\\n preds = self.model(inpu)\\n\\n return preds\",\n \"def predict_estimator_test(self, X, y=None):\\n if self.classifier_model.classifier_trained:\\n results = self.classifier_model.predict_estimator(\\n X, y, self.classifier_model.label_list)\\n return results\",\n \"def predict_labels(self, distances, k=1):\\n\\n num_test = distances.shape[0]\\n Y_pred = np.zeros((num_test,))\\n\\n \\n for i in range(num_test):\\n # extracting k-nearest-neighbors for each test-point\\n kNN_idxs = np.argsort(distances[i,:])[0:k]\\n \\n # voting among the k-nearest-neighbors\\n kNN_labels = {}\\n # print(type(kNN_labels))\\n\\n for j in range(k):\\n m_label = self.Y_train[kNN_idxs[j]]\\n if m_label in kNN_labels.keys():\\n # print(type(kNN_labels))\\n kNN_labels[m_label] += 1 # increment count\\n else:\\n # print(m_label,'....', type(kNN_labels))\\n kNN_labels[m_label] = 1 # initial count when the label occurs\\n \\n # counting the winning label\\n\\n winning_label = kNN_labels.keys()[0] # initialization\\n \\n for label in kNN_labels.keys():\\n if kNN_labels[label] > kNN_labels[winning_label]:\\n winning_label = label\\n elif kNN_labels[label] == kNN_labels[winning_label]:\\n # tie breaker\\n if label < winning_label:\\n winning_label = label\\n \\n\\n Y_pred[i] = winning_label # storing winning label for each test-point\\n \\n return Y_pred\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.811686","0.80712956","0.78437126","0.7705113","0.7671728","0.7612549","0.7588116","0.7575117","0.7493927","0.7471557","0.74658227","0.74150544","0.7381984","0.73806554","0.73481315","0.73377925","0.72906667","0.72607785","0.7221459","0.72066003","0.7181395","0.71710676","0.7131888","0.7093993","0.7040942","0.70353025","0.69980377","0.6991253","0.6991253","0.6990202","0.69845355","0.6981027","0.6980048","0.6974628","0.6967047","0.69611514","0.6943963","0.6937903","0.6925473","0.6911428","0.69051486","0.69014484","0.6895849","0.68878525","0.68755585","0.6869963","0.6867669","0.6867661","0.6863796","0.6853511","0.6850038","0.6849518","0.68428504","0.6797838","0.67950344","0.6793001","0.6786743","0.67794716","0.6767383","0.6766133","0.67646617","0.6762686","0.6761742","0.6761629","0.6755172","0.67535347","0.6753017","0.6752192","0.6750684","0.6749208","0.6744556","0.6734464","0.6728436","0.672755","0.6725314","0.67055863","0.67033947","0.6696077","0.66905135","0.66780496","0.66531014","0.6645555","0.6641394","0.66282576","0.6627616","0.6624711","0.65957147","0.65950716","0.6581436","0.65741575","0.6572348","0.65673625","0.65590847","0.6557718","0.65563875","0.65558577","0.6551115","0.65374833","0.6537404","0.6525099","0.6522475"],"string":"[\n \"0.811686\",\n \"0.80712956\",\n \"0.78437126\",\n \"0.7705113\",\n \"0.7671728\",\n \"0.7612549\",\n \"0.7588116\",\n \"0.7575117\",\n \"0.7493927\",\n \"0.7471557\",\n \"0.74658227\",\n \"0.74150544\",\n \"0.7381984\",\n \"0.73806554\",\n \"0.73481315\",\n \"0.73377925\",\n \"0.72906667\",\n \"0.72607785\",\n \"0.7221459\",\n \"0.72066003\",\n \"0.7181395\",\n \"0.71710676\",\n \"0.7131888\",\n \"0.7093993\",\n \"0.7040942\",\n \"0.70353025\",\n \"0.69980377\",\n \"0.6991253\",\n \"0.6991253\",\n \"0.6990202\",\n \"0.69845355\",\n \"0.6981027\",\n \"0.6980048\",\n \"0.6974628\",\n \"0.6967047\",\n \"0.69611514\",\n \"0.6943963\",\n \"0.6937903\",\n \"0.6925473\",\n \"0.6911428\",\n \"0.69051486\",\n \"0.69014484\",\n \"0.6895849\",\n \"0.68878525\",\n \"0.68755585\",\n \"0.6869963\",\n \"0.6867669\",\n \"0.6867661\",\n \"0.6863796\",\n \"0.6853511\",\n \"0.6850038\",\n \"0.6849518\",\n \"0.68428504\",\n \"0.6797838\",\n \"0.67950344\",\n \"0.6793001\",\n \"0.6786743\",\n \"0.67794716\",\n \"0.6767383\",\n \"0.6766133\",\n \"0.67646617\",\n \"0.6762686\",\n \"0.6761742\",\n \"0.6761629\",\n \"0.6755172\",\n \"0.67535347\",\n \"0.6753017\",\n \"0.6752192\",\n \"0.6750684\",\n \"0.6749208\",\n \"0.6744556\",\n \"0.6734464\",\n \"0.6728436\",\n \"0.672755\",\n \"0.6725314\",\n \"0.67055863\",\n \"0.67033947\",\n \"0.6696077\",\n \"0.66905135\",\n \"0.66780496\",\n \"0.66531014\",\n \"0.6645555\",\n \"0.6641394\",\n \"0.66282576\",\n \"0.6627616\",\n \"0.6624711\",\n \"0.65957147\",\n \"0.65950716\",\n \"0.6581436\",\n \"0.65741575\",\n \"0.6572348\",\n \"0.65673625\",\n \"0.65590847\",\n \"0.6557718\",\n \"0.65563875\",\n \"0.65558577\",\n \"0.6551115\",\n \"0.65374833\",\n \"0.6537404\",\n \"0.6525099\",\n \"0.6522475\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":12198,"cells":{"query":{"kind":"string","value":"Given gradient, will update the layer weights"},"document":{"kind":"string","value":"def update_params(self, update_weights, update_bias):\n\n if not self.trainable:\n return\n\n update_weights = np.squeeze(update_weights)\n update_bias = np.squeeze(update_bias)\n\n # some have non-trainable parameters, in addition to the\n # weights and biases\n if len(self.params) == 2:\n self.params = (self.params[0] + update_weights, self.params[1] + update_bias)\n else:\n self.params = (self.params[0] + update_weights, self.params[1] + update_bias) + self.params[2:]\n\n # create updated function\n self.f = self.gen_f(self.params, self.output_shape)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def perform_update(self, gradient):\n w = sys.modules[self.shared_mem_name].__dict__[\"w\"]\n w -= self.learning_rate * gradient","def update_weights(self, X, Y, learning_rate):\n grads = self.calculate_gradients(X, Y)\n #update weights and biases\n self.weights[0] = self.weights[0] - learning_rate * grads[\"dW1\"]\n self.weights[1] = self.weights[1] - learning_rate * grads[\"dW2\"]\n self.biases[0] = self.biases[0] - learning_rate * grads[\"db1\"]\n self.biases[1] = self.biases[1] - learning_rate * grads[\"db2\"]","def __update_weights_grad_desc(self, x_train, y_train):\n\n predictions = self.__compute_prediction(x_train)\n weights_delta = np.dot(x_train.T, y_train - predictions)\n\n m = y_train.shape[0]\n self.__weights += self.__learning_rate / float(m) * weights_delta","def update_weights(self):\n\n self.weights -= self.loss_grads\n self.loss_grads = np.zeros(self.weights.shape)","def update_weights(self, gradient, n):\n lr_decay = self.learning_rate*(1/2)*(n/100)\n self.delta_weights = lr_decay * gradient + self.momentum*self.delta_weights\n self.weights += self.delta_weights","def apply_gradient(self, learning_rate):\n raise NotImplementedError()","def update_weights(architecture,grad_weights,grad_bias,m,v,t,lr,optimizer=\"adam\"):\n \n for layer in range(len(architecture)):\n if not (grad_weights['layer{}'.format(layer+1)] is None) and grad_bias['layer{}'.format(layer+1)] is not None:\n grad_weightsi = grad_weights['layer{}'.format(layer+1)]\n grad_weightsi /= bs\n grad_biasi = grad_bias['layer{}'.format(layer+1)]\n grad_biasi /= bs\n\n \n if optimizer.lower()==\"sgd\":\n # Mini-Batch SGD\n qw = lr*grad_weightsi\n qb = lr*grad_biasi\n else:\n # Mini-Batch Adam\n mw,mb = m['layer{}'.format(layer+1)]\n vw,vb = v['layer{}'.format(layer+1)]\n qw,mw,vw = adam(grad_weightsi,beta_1,beta_2,mw,vw,t,lr) # Have obtained dw\n qb,mb,vb = adam(grad_biasi,beta_1,beta_2,mb,vb,t,lr) # Have obtained db\n\n architecture['layer{}'.format(layer+1)][2].requires_grad = False\n architecture['layer{}'.format(layer+1)][3].requires_grad = False\n # Updating weights and biases now\n try:\n architecture['layer{}'.format(layer+1)][2] -= torch.Tensor(qw)\n except:\n architecture['layer{}'.format(layer+1)][2] -= torch.t(torch.Tensor(qw))\n try:\n architecture['layer{}'.format(layer+1)][3] -= torch.Tensor(qb)\n except:\n architecture['layer{}'.format(layer+1)][3] -= torch.t(torch.Tensor(qb))\n\n m['layer{}'.format(layer+1)][0] = torch.Tensor(mw)\n m['layer{}'.format(layer+1)][1] = torch.Tensor(mb)\n v['layer{}'.format(layer+1)][0] = torch.Tensor(vw)\n v['layer{}'.format(layer+1)][1] = torch.Tensor(vb)\n grad_weights['layer{}'.format(layer+1)] = torch.zeros(grad_weightsi.shape)\n grad_bias['layer{}'.format(layer+1)] = torch.zeros(grad_biasi.shape)\n return grad_weights,grad_bias,m,v","def update(self, gradient, optimizer=None, relink=None):\n # Recover the defaults, if missing\n optimizer = self._resolve_defaults(optimizer=optimizer)[0]\n # Set the gradient\n self.set_gradient(gradient, relink=(self._config.relink if relink is None else relink))\n # Perform the update step\n optimizer.step()","def backward(self, gradient: Tensor) -> Tensor:\n self.b_grad = np.sum(gradient, axis=0)\n self.w_grad = self.inputs.T @ gradient\n return gradient @ self.w.T","def _update_params(self, gradients: dict, learning_rate: float):\n L = len(self.activations)\n\n for l in range(L):\n self.params[\"W_\" + str(l + 1)] = self.params[\"W_\" + str(l + 1)] - learning_rate * gradients[\n \"dW\" + str(l + 1)]\n\n self.params[\"b_\" + str(l + 1)] = self.params[\"b_\" + str(l + 1)] - learning_rate * gradients[\n \"db\" + str(l + 1)]","def update_weights(self):\n activation, activation_p = self.feedforward()\n # initialize delta_weights\n delta_w = np.zeros(2)\n # simultaneous calculate delta_weights\n for i, element in enumerate(self.y):\n delta_w += (activation[i]-element)*(activation_p[i])*self.X[i]\n # update weight\n self.weights -= self.alfa*delta_w","def update_step(image_batch, label_batch, model, learning_rate):\n f = model.forward(image_batch)\n gradient = model.backward(f,label_batch)\n model.w = model.w - learning_rate*gradient","def update_gradients(self, dw, db):\n self.w = self.w - self.lr * dw\n self.b = self.b - (self.lr * db)","def update(self):\n # Update the weight matrix: \n self.W -= self.lr * self.grad_W \n \n # Update the bias matrices:\n self.b -= self.lr * np.array(self.grad_b) \n self.c -= self.lr * np.array(self.grad_c)","def optimize(self,gradients):\n\n for k in range(self.size):\n delta_weight = self.learningRate * gradients[k]\n full_change = delta_weight + self.momentum*self.last_change[k]\n self.weights[k] -= full_change\n self.last_change[k] = 1*gradients[k] #copy gradient mat","def update_weights(self):\n\n\n self.w += self.learn_rate * (self.X.T.dot(self.T - self.Y)\n - self.reg_L1 * np.sign(self.w)\n - self.reg_L2 * 2*self.w)","def update_weights(x_train, y_train, weights, learning_rate):\r\n predictions = compute_prediction(x_train, weights)\r\n weights_delta = np.dot(x_train.T, y_train - predictions)\r\n m = y_train.shape[0]\r\n weights += learning_rate / float(m) * weights_delta\r\n return weights","def __update(self, learning_rate):\n for layer in self.layers:\n layer.weights.set_value((layer.weights - learning_rate * layer.dW).eval())\n layer.biases.set_value((layer.biases - learning_rate * layer.db).eval())","def update_weights(self, X: np.ndarray, y: np.ndarray, learning_rate: float, reg_coeff: float):\n ################################################################################\n # TODO: Compute the gradient of loss computed above w.r.t the svm weights. #\n # and then update self.w with the computed gradient. #\n # (don't forget learning rate and reg_coeff in update rule) #\n # Don't forget L2-regularization term in your implementation! #\n ################################################################################\n\n # write your code here\n N = len(X)\n gradient = ((-1 * np.sum(((X.T * y).T)[np.where((1 - np.matmul(X, self.weights) * y) > 0)], axis=0)) / N) + reg_coeff * self.weights\n self.weights -= learning_rate * gradient\n\n\n ################################################################################\n # END OF YOUR CODE #\n ################################################################################","def pull_weights(self, learning_rate):\n for w in self.weights:\n w.value += learning_rate * w.gradient\n # Reset all the weights' gradient to 0\n # We will not reset all other units' gradient, because all other units should be initialized in next training\n # round, and the init value of gradient is 0\n for w in self.weights:\n w.gradient = 0","def gradient_update(self, states, Q_target):\n params = [self.w1, self.w2, self.w3, self.b1, self.b2, self.b3]\n loss = self.get_loss(states, Q_target)\n gradients = nn.gradients(loss, params)\n self.w1.update(gradients[0], -self.learning_rate)\n self.w2.update(gradients[1], -self.learning_rate)\n self.w3.update(gradients[2], -self.learning_rate)\n self.b1.update(gradients[3], -self.learning_rate)\n self.b2.update(gradients[4], -self.learning_rate)\n self.b3.update(gradients[5], -self.learning_rate)","def update_weights(self):\n\t\tpass","def update_weights(self, weight_delta):\n\n self._weights = math_util.vector_sum(self._weights, weight_delta)","def _UpdateGradient(self):\n self.mol.GetGradient('analytic')","def add_grad_updates(self):\n \n gradients = T.grad(self.cost, self.theta)\n \n for target_param, grad in zip(self.theta, gradients):\n \n if target_param.name ==\"W\" and self.num_hidden ==0\\\n and self.zero_diag:\n \n grad = grad - T.diag(T.diag(grad)) # no x i - xi connections\n # for all i = 1, ..., D\n ##############################################################\n if target_param.name ==\"b\" and self.learn_biases == False:\n print(\"Will not learn bias terms\")\n pass\n \n elif target_param.name ==\"bhid\" and self.learn_biases == False:\n print(\"Will not learn bias terms\")\n pass\n \n else:\n \n if self.use_momentum:\n \n # alternative definition (mostly seen):\n #g_tilda = self.momentum*self.grad_vec[target_param.name] - \\\n #T.cast(self.learning_rate, dtype = theano.config.floatX)*grad\n #self.updates[target_param] = target_param + g_tilda\n \n g_tilda = self.momentum*self.grad_vec[target_param.name] - \\\n (1-self.momentum)*grad\n \n self.updates[target_param] = target_param +\\\n T.cast(self.learning_rate, dtype = theano.config.floatX)*g_tilda\n \n # store g_tilda for next iteration:\n self.updates[self.grad_vec[target_param.name]] = g_tilda\n \n else:\n \n self.updates[target_param] = target_param -\\\n T.cast(self.learning_rate, dtype = theano.config.floatX)*grad\n \n if (\"PCD\" in self.algorithm) and self.num_hidden > 0:\n \n self.updates[self.persistent_gibbs] = self.hid_samples","def updateWeights(self, LR, M):\n assert self._batch\n for i,(dws,odws) in enumerate(zip(self._wDeltas, self._oldWDeltas)):\n ws = self._layer.weightsAt(i)\n for j, (dw, odw) in enumerate(zip(dws, odws)):\n dw = LR*dw + M*odw\n ws[j] += dw\n odws[j] = dw\n dws[j] = 0.0","def gradient_weight(X, Y, model):\n W = model['weight']\n b = model['bias']\n weight_decay = model['weight_decay']\n\n # YOUR CODE HERE\n # Write the gradient with respect to the weights.\n return np.add(np.subtract(np.dot(np.transpose(predict(X, model)), X), np.dot(np.transpose(Y), X)), 2 * LAMBDA * np.transpose(model['weight'])) #np.zeros((X.shape[1], Y.shape[1]))","def test_update_parameters(model):\n train_inputs = torch.tensor([[1., 2., 3.]])\n train_loss = 0.5 * (model(train_inputs) ** 2)\n\n params = gradient_update_parameters(model,\n train_loss,\n params=None,\n step_size=0.5,\n first_order=False)\n\n assert train_loss.item() == 264.5\n assert list(params.keys()) == ['weight']\n assert torch.all(params['weight'].data == torch.tensor([[-9.5, -20., -29.5]]))\n\n \"\"\"\n The new loss function (still with respect to the weights of the model w) is\n defined as:\n g(w) = 0.5 * (4 * w'_1 + 5 * w'_2 + 6 * w'_3) ** 2\n = 0.5 * (4 * (w_1 - 0.5 * df / dw_1)\n + 5 * (w_2 - 0.5 * df / dw_2)\n + 6 * (w_3 - 0.5 * df / dw_3)) ** 2\n = 0.5 * (4 * (w_1 - 0.5 * 1 * (1 * w_1 + 2 * w_2 + 3 * w_3))\n + 5 * (w_2 - 0.5 * 2 * (1 * w_1 + 2 * w_2 + 3 * w_3))\n + 6 * (w_3 - 0.5 * 3 * (1 * w_1 + 2 * w_2 + 3 * w_3))) ** 2\n = 0.5 * ((4 - 4 * 0.5 - 5 * 1.0 - 6 * 1.5) * w_1\n + (5 - 4 * 1.0 - 5 * 2.0 - 6 * 3.0) * w_2\n + (6 - 4 * 1.5 - 5 * 3.0 - 6 * 4.5) * w_3) ** 2\n = 0.5 * (-12 * w_1 - 27 * w_2 - 42 * w_3) ** 2\n\n Therefore the gradient of the function g with respect to w (and evaluated\n at w = [2, 3, 5]) is:\n dg / dw_1 = -12 * (-12 * w_1 - 27 * w_2 - 42 * w_3) = 3780\n dg / dw_2 = -27 * (-12 * w_1 - 27 * w_2 - 42 * w_3) = 8505\n dg / dw_3 = -42 * (-12 * w_1 - 27 * w_2 - 42 * w_3) = 13230\n \"\"\"\n test_inputs = torch.tensor([[4., 5., 6.]])\n test_loss = 0.5 * (model(test_inputs, params=params) ** 2)\n\n grads = torch.autograd.grad(test_loss, model.parameters())\n\n assert test_loss.item() == 49612.5\n assert len(grads) == 1\n assert torch.all(grads[0].data == torch.tensor([[3780., 8505., 13230.]]))","def weight_update(u_ff, u_wc, alpha, beta, w, fan_all):\r\n mult_wc = np.matmul(np.reshape(hard_sigmoid_array(u_wc), (fan_all, 1)),\r\n np.reshape(hard_sigmoid_array(u_wc), (1, fan_all)))\r\n mult_ff = np.matmul(np.reshape(hard_sigmoid_array(u_ff), (fan_all, 1)),\r\n np.reshape(hard_sigmoid_array(u_ff), (1, fan_all)))\r\n delta_w = alpha * (1 / beta) * (mult_wc - mult_ff)\r\n delta_w[np.diag_indices(fan_all)] = 0\r\n w = w + delta_w\r\n return w","def update_weights(self):\n self._weights = self._weights + self.update_weights_value\n self.weights_clipping()","def backward(self, inGradient, lr=0.001): # batchSize = 1\n wGradient = np.dot(inGradient.T, self.data)\n bGradient = np.sum(inGradient, axis=0)\n outGradient = np.dot(inGradient, self.weights)\n\n self.weights = self.weights - lr * wGradient\n self.bias = self.bias - lr * bGradient\n self.wGradient = wGradient\n self.bGradient = bGradient\n\n #print \"weight gradient \", wGradient\n #print \"bias gradient \", bGradient\n\n return outGradient","def update_params(self, learning_rate):\n\t\t#######################################################################\n\t\t# ** START OF YOUR CODE **\n\t\t#######################################################################\n\t\tself._W = self._W - learning_rate * self._grad_W_current\n\t\tself._b = self._b - learning_rate * self._grad_b_current\n\t\t#######################################################################\n\t\t# ** END OF YOUR CODE **\n\t\t#######################################################################","def update(self, weights, grads):\n learn_rate_t = self.learn_rate\n\n new_weights = []\n for w, g in zip(weights, grads):\n\n # Apply weight decay\n if w.shape[1] > 1:\n # Weight matrix\n g_t = learn_rate_t * (g + self.weight_decay * w)\n else:\n # Bias matrix\n g_t = learn_rate_t * g\n w_t = w - g_t\n new_weights.append(w_t)\n return new_weights","def update_weights(self):\r\n\r\n inedges=self.in_edges\r\n for edge in inedges:\r\n weight=edge.weight+self.learning_rate*self.delta*(edge.source.activation)\r\n edge.change_weight(weight)","def update(self, X, y):\n proba = self.predict_proba(X)\n top_loss = proba - y\n bias_gradient = np.sum(top_loss)\n weight_gradient = (top_loss).T.dot(X)\n\n # the gradient update\n self.b = self.b - self.lrate * bias_gradient\n self.W = self.W - self.lrate * weight_gradient","def update_params(self, learning_rate=0.1):\n\n self.params['W'] = self.params['W'] - learning_rate * self.dW # update weights\n self.params['b'] = self.params['b'] - learning_rate * self.db # update bias(es)","def weights_update(self, previous_layer_output, learning_rate, l2_lambda, batch_size):\n theta, b, delta, alpha = self.theta, self.b, self.delta, learning_rate\n dc_dtheta = np.dot(previous_layer_output, delta.T).transpose()\n dc_dtheta = np.divide(1, batch_size) * dc_dtheta\n new_theta = theta*(1 - l2_lambda * alpha) - alpha * dc_dtheta\n b_prime = np.sum(delta, axis=1).reshape(b.shape)\n b_prime = b_prime * np.divide(1, batch_size)\n new_b = b - alpha * b_prime\n self.theta, self.b = new_theta, new_b","def update_weights_sum(self):\n vals = self.nn.get_param_values()\n # only use the last layer for summation (w, b)\n self.w_sum = np.sum(vals[-2]) + np.sum(vals[-1])","def update_param(self, lr):\n\n\n self.W=self.W-lr*self.W_grad\n self.b = self.b - lr*self.b_grad","def handle_gradient(self):\n self._optimizer.sync_grad()","def update_weights(self):\n self._weights = self._weights + self.update_weights_value","def update_layers(self):\n\n # Para cada layer atualiza utilizando o gradiente descendente e o learning rate\n for layer in self.layers:\n layer.update_layer(self.learning_rate)","def update_network(self, loss_dict):\r\n loss = sum(loss_dict.values())\r\n self.optimizer.zero_grad()\r\n loss.backward()\r\n self.optimizer.step()","def step(self, layers, d_weights, d_biases, lr):\n for layer, d_W, d_b in zip(layers, d_weights, d_biases):\n layer.update(-lr * d_W, -lr * d_b)","def backward(self, gradient):\n raise NotImplementedError()","def updateParams(self,gradients):\n for i in xrange(len(self.params)):\n self.params[i].set_value(self.params[i].get_value()-gradients[i]/(1/self.learning_rate+self.iterations))","def update_weights(self, gradient_steps):\n for gradient_step in range(int(gradient_steps)):\n states, actions, rewards, dones, new_states = tf.numpy_function(\n self.concat_buffer_samples, [], self.batch_dtypes\n )\n self.update_critic_weights(states, actions, new_states, dones, rewards)\n if gradient_step % self.policy_delay == 0:\n self.update_actor_weights(states)\n self.sync_target_models()","def update_parameters(self, learning_rate):\n for i in range(self.L - 1):\n self.W[i] -= learning_rate * self.dW[i]\n self.b[i] -= learning_rate * self.db[i]","def update(self, loss=None, inputs=None, targets=None, outputs=None):\n\n # TODO: add gradient accumulation\n\n self.optimizer.zero_grad(set_to_none=self.none_grad)\n\n if self.grad_scaler:\n self.grad_scaler.scale(loss).backward()\n self.grad_scaler.step(self.optimizer)\n\n if self.clip_grad:\n self.grad_scaler.unscale_(self.optimizer)\n self.clip_grad(self.model.parameters())\n self.grad_scaler.update()\n else:\n loss.backward()\n\n if self.clip_grad:\n self.clip_grad(self.model.parameters())\n\n self.optimizer.step()","def gradients_to_updates(self, params, grads):\n return NotImplementedError('Abstract class method')","def adjust_weights(self, weights_deltas):\n for layer_index in xrange(len(self.w)):\n self.w[layer_index] = np.add(self.w[layer_index], weights_deltas[layer_index])","def apply_gradient(params: torch.Tensor, grads: torch.Tensor, lr: float) -> torch.Tensor:\n params_prime = params + lr * grads\n return params_prime","def updateWeights(inputs, outputs, learning_rate, y, weights):\n for i in range(len(weights)):\n weights[i] = weights[i] + learning_rate * (outputs - y) * inputs[i]\n return weights","def update(params: hk.Params, opt_state: OptState, batch, labels, xent_weight=self.weights, l1_coeff=self.l1_coef, l2_coeff=self.l2_coef) -> Tuple[hk.Params, OptState]:\n grads = jax.grad(loss)(params, batch, labels, xent_weight, l1_coeff, l2_coeff)\n updates, opt_state = opt.update(grads, opt_state)\n new_params = optax.apply_updates(params, updates)","def learning_by_gradient_descent(y, tx, w, gamma):\n loss = calculate_loss(y,tx,w)\n grad = calculate_gradient(y,tx,w)\n w_new = w - gamma*grad\n #grad is for debugging purpose\n return loss, w_new,grad","def backward(self, gradient):\n #TODO\n pass","def backward(self, gradient):\n #TODO\n pass","def update_network(self, tr_d, lr, relz=\"\", lmbda=0.0, mu=0.0):\n trlen = float(len(tr_d))\n delta_b = [np.zeros(b.shape) for b in self.biases]\n delta_w = [np.zeros(w.shape) for w in self.weights]\n for x,y in tr_d:\n delta_b_single, delta_w_single = self.backppg_ce(x,y)\n delta_b = [db+dbs for db,dbs in zip(delta_b, delta_b_single)]\n delta_w = [dw+dws for dw,dws in zip(delta_w, delta_w_single)]\n #update the parameters in network\n if(relz==\"\"):\n mu=0.0\n elif(relz[0:2] == \"MO\"):\n relz = relz[2:]\n self.velw = [mu*vw-(lr/trlen)*dw for vw,dw in zip(self.velw, delta_w)]\n self.velb = [mu*vb-(lr/trlen)*db for vb,db in zip(self.velb, delta_b)]\n self.biases = [b + vb for b,vb in zip(self.biases, self.velb)]\n if(relz == \"L2\"):\n self.weights = [w + vw - (lr/trlen/100)*lmbda*w for w,vw in zip(self.weights, self.velw)]\n elif(relz == \"L1\"):\n self.weights = [w + vw - (lr/trlen/100)*lmbda*np.sign(w) for w,vw in zip(self.weights, self.velw)]\n else:\n self.weights = [w + vw for w,vw in zip(self.weights, self.velw)]","def update_params(layers, param_grads, learning_rate):\n for layer, layer_backprop_grads in zip(layers, param_grads):\n for param, grad in zip(layer.get_params_iter(), layer_backprop_grads):\n # The parameter returned by the iterator point to the memory space of\n # the original layer and can thus be modified inplace.\n param -= learning_rate * grad # Update each parameter","def update(self, weights, grads):\n\n learn_rate = self.learn_rate\n\n # Scale the learning rate by the iteration number\n t = self.iters + 1\n learn_rate_t = learn_rate * (np.sqrt(1 - self.beta2**t) /\n (1 - self.beta1**t))\n\n # Store the momentum and velocities for each node\n if self.ms is None:\n self.ms = [np.zeros(w.shape) for w in weights]\n if self.vs is None:\n self.vs = [np.zeros(w.shape) for w in weights]\n ms, vs = self.ms, self.vs\n\n # Make sure everything has the right length\n assert len(weights) == len(grads)\n assert len(weights) == len(ms)\n assert len(weights) == len(vs)\n\n # Now, for each weight stack, update momentum, velocity, weights\n new_ms = []\n new_vs = []\n new_weights = []\n for w, g, m, v in zip(weights, grads, ms, vs):\n # Momentum update\n m_t = (self.beta1 * m) + (1.0 - self.beta1) * g\n\n # Velocity update\n v_t = (self.beta2 * v) + (1.0 - self.beta2) * g**2\n\n # Update the weights\n w_t = w - learn_rate_t * m_t / (np.sqrt(v_t) + 1e-8)\n\n new_ms.append(m_t)\n new_vs.append(v_t)\n new_weights.append(w_t)\n\n self.ms = new_ms\n self.vs = new_vs\n return new_weights","def update_params(layers, param_grads, learning_rate):\n for layer, layer_backprop_grads in zip(layers, param_grads):\n for param, grad in itertools.izip(layer.get_params_iter(), layer_backprop_grads):\n # The parameter returned by the iterator point to the memory space of\n # the original layer and can thus be modified inplace.\n param -= learning_rate * grad # Update each parameter","def add_custom_gradients(self, clst_weights, weights):\n override_weights = tf.sign(tf.reshape(weights, shape=(-1,)) + 1e+6)\n z = clst_weights * override_weights\n\n def grad(dz):\n return dz, dz\n\n return z, grad","def update_weights(net, input_values, desired_output, neuron_outputs, r=1):\n raise NotImplementedError","def apply_on_layer(self, layer):\n init_g = Constant(1.)\n\n try:\n weight_tag = 'W' if hasattr(layer, 'W') else 'U'\n except AttributeError:\n raise AttributeError(\"Trying to call weight norm on {} \".format(layer)+\\\n \"without layer.W or layer.U defined\")\n weights = getattr(layer, weight_tag)\n\n Wndim = weights.get_value().ndim\n if Wndim == 4:\n W_axes_to_sum = (1,2,3)\n W_dimshuffle_args = (0,'x','x','x')\n elif Wndim == 5:\n W_axes_to_sum = (1,2,3,4)\n W_dimshuffle_args = (0,'x','x','x','x')\n elif Wndim == 3 :\n raise NotImplementedError(\"What is a weight with 3 dimensions?\")\n else :\n W_axes_to_sum = 0\n W_dimshuffle_args = ('x',0)\n\n if self.train_g is not None:\n g = init_g(layer.output_dims)\n g = theano.shared(g, name=layer.prefix+'_g')\n if self.train_g :\n layer.params += [g]\n\n new_weights = weights * (\n g / T.sqrt(1e-6 + T.sum(T.square(weights),\n axis=W_axes_to_sum))).dimshuffle(*W_dimshuffle_args)\n layer.g = g\n else:\n new_weights = weights / \\\n T.sqrt(1e-6 + T.sum(T.square(weights),\n axis=W_axes_to_sum,keepdims=True))\n\n setattr(layer, weight_tag, new_weights)","def grad(self, w):\n gradient_penalty = np.asarray(self.alpha) * w\n # Insert 0 for bias term.\n return np.insert(gradient_penalty, 0, 0, axis=0)","def grad(self, w):\n gradient_penalty = np.asarray(self.alpha) * w\n # Insert 0 for bias term.\n return np.insert(gradient_penalty, 0, 0, axis=0)","def update_parameters(parameters: Dict,\n grads: Dict, learning_rate: float) -> Dict:\n L = len(parameters)//2 # number of layers\n\n for l in range(1, L+1):\n parameters['W'+str(l)] -= learning_rate * grads['dW'+str(l)]\n parameters['b'+str(l)] -= learning_rate * grads['db'+str(l)]\n\n return parameters","def _compute_func_grad(self, w):\n W = w.reshape((self.X.shape[1], self.Y.shape[1]))\n self.nll_, self.grad_ = calculate_gradient(self.X, self.Y, W, self.prior, self.weighted,0)","def update(self,parameters, grads):\n \n L = len(parameters) // 2 # number of layers in the neural network\n #print(L)\n\n # Update rule for each parameter. Use a for loop.\n for l in range(L):\n \n parameters[\"W\" + str(l+1)] = parameters[\"W\" + str(l+1)] - self.alpha * grads[\"dW\" + str(l+1)]\n \n parameters[\"b\" + str(l+1)] = parameters[\"b\" + str(l+1)] - self.alpha * grads[\"db\" + str(l+1)]\n \n parameters[\"W\" + str(l+1)][np.isnan(parameters[\"W\" + str(l+1)])] = 0\n parameters[\"b\" + str(l+1)][np.isnan(parameters[\"b\" + str(l+1)])] = 0\n \n return parameters","def update_model_parameters(parameters, grads, learning_rate):\n L = len(parameters) /2 # number of layers in the neural network\n\n for l in range(int(L)):\n parameters[\"W\" + str(l + 1)] = parameters[\"W\" + str(l + 1)] - learning_rate * grads[\"dW\" + str(l + 1)]\n parameters[\"b\" + str(l + 1)] = parameters[\"b\" + str(l + 1)] - learning_rate * grads[\"db\" + str(l + 1)]\n return parameters\n # raise NotImplementedError","def update_weights(self, alpha, ind):\n inside = -alpha * self.labels * self.predictions[ind, :]\n new_weights = self.weights * np.exp(inside)\n self.weights = new_weights / np.sum(new_weights)","def grad(self, w):\n gradient_penalty = np.asarray(self.alpha) * w\n\n # Insert 0 for bias term.\n return np.insert(gradient_penalty, 0, 0, axis=0)","def update_w(self, w):\n # Need to update the scaled weights\n if self.scale_weights:\n self._scale_weights_to_degree(w)\n self._generate_weighted_adj_matrices()\n # once we get new DW matrices, multiply by weights\n super().update_w(w)\n self._degree_weight_weighted_matrices()","def update_weights(weights, alpha, y_true, y_pred):\n def change_labels(arr):\n for i,a in enumerate(arr):\n if a == 0:\n arr[i] = -1\n return arr \n \n y_true, y_pred = change_labels(y_true), change_labels(y_pred)\n w_hat = weights * np.exp(-alpha * y_true * y_pred)\n return w_hat / sum(w_hat)","def gradient_descent_step(self, x, y, learning_rate):\n # compute derivative of loss wrt Z\n dZ = self.derivative_loss(y, self.predict(x))\n dW = np.dot(dZ, x)\n # subtract average derivative from weights\n self.w -= learning_rate * 1.0/dW.shape[0] * dW\n if self.fit_b:\n self.b -= learning_rate * (1.0/x.shape[0] * np.sum(dZ))","def update_parameters(parameters, grads, learning_rate = 1.2):\n\t# Retrieve each parameter from the dictionary \"parameters\"\n\tW1 = parameters['W1']\n\tb1 = parameters['b1']\n\tW2 = parameters['W2']\n\tb2 = parameters['b2']\n\n\t# Retrieve each gradient from the dictionary \"grads\"\n\tdW1 = grads['dW1']\n\tdb1 = grads['db1']\n\tdW2 = grads['dW2']\n\tdb2 = grads['db2']\n\n\t# Update rule for each parameter\n\tW1 = W1 - learning_rate*dW1\n\tb1 = b1 - learning_rate*db1\n\tW2 = W2 - learning_rate*dW2\n\tb2 = b2 - learning_rate*db2\n\n\tparameters = {\"W1\": W1,\n\t\t\t\t\t\"b1\": b1,\n\t\t\t\t\t\"W2\": W2,\n\t\t\t\t\t\"b2\": b2}\n\n\treturn parameters","def update_weight(self, x_input: np.ndarray) -> None:\n if self.layers[-1].delta is None:\n raise ValueError(\"No derivative calculated yet\")\n layer_input = x_input.copy()\n if np.ndim(x_input) == 1:\n layer_input = layer_input.reshape(-1, 1)\n for layer in self.layers:\n layer.update_weights(layer_input, self.learning_rate)\n layer_input = layer.output","def learning_by_gradient_descent(y, tx, w, gamma):\n\tgrad = calculate_gradient(y, tx, w)\n\n\tw = w - gamma * grad\n\treturn w","def update_parameters_with_gd(parameters, grads, learning_rate):\n\n L = len(parameters) // 2 # number of layers in the neural networks\n\n # Update rule for each parameter\n for l in range(L):\n parameters[\"W\" + str(l+1)] = parameters[\"W\" + str(l+1)] - learning_rate * grads['dW' + str(l+1)]\n parameters[\"b\" + str(l+1)] = parameters[\"b\" + str(l+1)] - learning_rate * grads['db' + str(l+1)]\n \n return parameters","def delta_w(w_k, x, t, learning_rate):\n return -learning_rate * np.mean(gradient(w_k, x, t))","def grad(self, w):\n l1_grad = self.r * np.sign(w)\n l2_grad = np.asarray(1 - self.r) * w \n\n gradient_penalty = self.alpha * (l1_grad + l2_grad)\n\n # Insert 0 for bias term.\n return np.insert(gradient_penalty, 0, 0, axis=0)","def wasserstein_g_update(loss, optimizer, var_list=None, global_step=None, name='g_update'):\n # grads = optimizer.compute_gradients(loss, var_list=var_list)\n # return optimizer.apply_gradients(grads, global_step=global_step, name=name)\n\n return optimizer.minimize(loss, global_step=global_step, var_list=var_list, name=name)","def _update_parameters(self, loss):\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()","def learning_by_penalized_gradient(y, tx, w, gamma, lambda_):\n\tgrad, H = penalized_logistic_regression(y, tx, w, lambda_)\n\n\thgrad = np.linalg.inv(H).dot(grad)\n\n\tw = w - gamma * hgrad\n\n\treturn w","def update_parameters_with_gd(parameters, grads, learning_rate):\n\n L = len(parameters) // 2 # number of layers in the neural networks\n\n # Update rule for each parameter\n for l in range(L):\n ### START CODE HERE ### (approx. 2 lines)\n parameters[\"W\" + str(l+1)] = parameters[\"W\" + str(l+1)]-learning_rate* grads[\"dW\" + str(l+1)]\n parameters[\"b\" + str(l+1)] = parameters[\"b\" + str(l+1)]-learning_rate* grads[\"db\" + str(l+1)]\n ### END CODE HERE ###\n \n return parameters","def gradient(self, inputs):\n raise NotImplementedError","def update_recurrent_weights_step(self):\n \n # update weights: hebbian term\n self.delta_Wee=self.learn_rate*(self.rr[0:self.N_e]-self.input_mean)*\\\n (self.rr[0:self.N_e].T-self.input_mean)\n \n self.W_ee+=self.dt*self.delta_Wee\n\n # update weights: normalize to fixed mean of incoming and outgoing weights\n self.W_ee-=(self.W_ee.mean(axis=1)-self.W_av_star)[:,np.newaxis]\n self.W_ee-=(self.W_ee.mean(axis=0)-self.W_av_star)[np.newaxis,:]\n \n # clip weights \n self.W_ee=np.clip(self.W_ee,0,self.W_max_ee)\n \n # update excitatory weights in the big weight matrix\n self.W[:self.N_e,:self.N_e]=self.W_ee","def gradient(self, node, output_grad):\r\n raise NotImplementedError","def _apply_gradient_descent(self, gradients):\n updated_sd = {}\n global_model = self._get_global_model()\n \n for name, param, grad in zip(global_model.keys(), global_model.values(), gradients):\n updated_sd[name] = param - self.global_lr * grad\n \n self._load_global_model(updated_sd)","def weight_update_conjugate_gradient(self, network):\n # compute beta: Fletcher-Reeves\n num = 0.0\n for l, layer in enumerate(network.layers):\n num += np.sum(self.dc_db[l] ** 2)\n num += np.sum(self.dc_dq[l] ** 2)\n num += np.sum(self.dc_drx_inp[l] ** 2)\n num += np.sum(self.dc_dry_inp[l] ** 2)\n num += np.sum(self.dc_drx_pos_out[l] ** 2)\n num += np.sum(self.dc_dry_pos_out[l] ** 2)\n num += np.sum(self.dc_drx_neg_out[l] ** 2)\n num += np.sum(self.dc_dry_neg_out[l] ** 2)\n\n # Initialize velocities to zero for momentum\n if self.vel_b is None or self.vel_q is None:\n self.ms_b = []\n self.ms_q = []\n self.ms_rx_inp = []\n self.ms_ry_inp = []\n self.ms_rx_pos_out = []\n self.ms_ry_pos_out = []\n self.ms_rx_neg_out = []\n self.ms_ry_neg_out = []\n for l, layer in enumerate(network.layers):\n self.ms_b.append(np.zeros(layer.b.shape))\n self.ms_q.append(np.zeros(layer.q.shape))\n self.ms_rx_inp.append(np.zeros(layer.input_size))\n self.ms_ry_inp.append(np.zeros(layer.input_size))\n self.ms_rx_pos_out.append(np.zeros(layer.output_size))\n self.ms_ry_pos_out.append(np.zeros(layer.output_size))\n self.ms_rx_neg_out.append(np.zeros(layer.output_size))\n self.ms_ry_neg_out.append(np.zeros(layer.output_size))\n\n # Take steepest descent step\n for l, layer in enumerate(network.layers):\n layer.b -= self.alpha * self.dc_db[l]\n layer.q -= self.alpha * self.dc_dq[l]\n layer.rx_inp -= self.alpha * self.dc_drx_inp[l]\n layer.ry_inp -= self.alpha * self.dc_dry_inp[l]\n layer.rx_pos_out -= self.alpha * self.dc_drx_pos_out[l]\n layer.ry_pos_out -= self.alpha * self.dc_dry_pos_out[l]\n layer.rx_neg_out -= self.alpha * self.dc_drx_neg_out[l]\n layer.ry_neg_out -= self.alpha * self.dc_dry_neg_out[l]\n\n else:\n # compute beta\n beta = num / self.denominator\n\n # compute s_n\n for l, layer in enumerate(network.layers):\n self.ms_b[l] = -self.alpha * self.dc_db[l] + beta * self.ms_b[l]\n self.ms_q[l] = -self.alpha * self.dc_dq[l] + beta * self.ms_q[l]\n self.ms_rx_inp[l] = -self.alpha * self.dc_drx_inp[l] + beta * self.ms_rx_inp[l]\n self.ms_ry_inp[l] = -self.alpha * self.dc_dry_inp[l] + beta * self.ms_ry_inp[l]\n self.ms_rx_pos_out[l] = -self.alpha * self.dc_drx_pos_out[l] + beta * self.ms_rx_pos_out[l]\n self.ms_ry_pos_out[l] = -self.alpha * self.dc_dry_pos_out[l] + beta * self.ms_ry_pos_out[l]\n self.ms_rx_neg_out[l] = -self.alpha * self.dc_drx_neg_out[l] + beta * self.ms_rx_neg_out[l]\n self.ms_ry_neg_out[l] = -self.alpha * self.dc_dry_neg_out[l] + beta * self.ms_ry_neg_out[l]\n\n # Take step\n for l, layer in enumerate(network.layers):\n layer.b += self.alpha * self.ms_b[l]\n layer.q += self.alpha * self.ms_q[l]\n layer.rx_inp += self.alpha * self.ms_rx_inp[l]\n layer.ry_inp += self.alpha * self.ms_ry_inp[l]\n layer.rx_pos_out += self.alpha * self.ms_rx_pos_out[l]\n layer.ry_pos_out += self.alpha * self.ms_ry_pos_out[l]\n layer.rx_neg_out += self.alpha * self.ms_rx_neg_out[l]\n layer.ry_neg_out += self.alpha * self.ms_ry_neg_out[l]\n\n # store num for next iteration to be used as denominator\n self.denominator = num","def update_gradients(self, grads):\n self.variance.gradient = grads[0]","def apply_gradient(self, hyper_params, params, state, grads):\n step = state.step\n # We assume that params, param_states, and grads are all dict-like here.\n params_flat_dict = utils.flatten_dict_string_keys(params)\n params_paths = params_flat_dict.keys()\n params_flat = params_flat_dict.values()\n # extra paranoia to guarantee identical value ordering\n states_flat = utils.flatten_dict_string_keys(state.param_states)\n states_flat = [states_flat[k] for k in params_paths]\n grads_flat = utils.flatten_dict_string_keys(grads)\n grads_flat = [grads_flat[k] for k in params_paths]\n\n if hyper_params.global_norm_clip_threshold:\n # Paper: http://proceedings.mlr.press/v28/pascanu13.pdf\n # TF: https://www.tensorflow.org/api_docs/python/tf/clip_by_global_norm\n squared_l2_norms = [jnp.sum(jnp.square(g)) for g in grads_flat]\n global_norm = jnp.sqrt(jnp.sum(jnp.array(squared_l2_norms)))\n scale = hyper_params.global_norm_clip_threshold * jnp.minimum(\n 1.0 / hyper_params.global_norm_clip_threshold, 1.0 / global_norm)\n grads_flat = [g * scale for g in grads_flat]\n\n out = [\n self.apply_param_gradient(step, hyper_params, param, state, grad, path)\n for param, state, grad, path in zip(params_flat, states_flat,\n grads_flat, params_paths)\n ]\n\n new_params_flat, new_states_flat = list(zip(*out)) if out else ((), ())\n new_params_flat = {k: v for k, v in zip(params_paths, new_params_flat)}\n new_states_flat = {k: v for k, v in zip(params_paths, new_states_flat)}\n new_params = _restore(params, new_params_flat)\n new_param_states = _restore(params, new_states_flat)\n new_state = OptimizerState(step + 1, new_param_states)\n\n return new_params, new_state","def test_multiple_update_parameters(model):\n train_inputs = torch.tensor([[1., 2., 3.]])\n\n train_loss_1 = 0.5 * (model(train_inputs) ** 2)\n params_1 = gradient_update_parameters(model,\n train_loss_1,\n params=None,\n step_size=1.,\n first_order=False)\n\n assert train_loss_1.item() == 264.5\n assert list(params_1.keys()) == ['weight']\n assert torch.all(params_1['weight'].data == torch.tensor([[-21., -43., -64.]]))\n\n \"\"\"\n The new loss function is defined as\n g(w') = 0.5 * (1 * w'_1 + 2 * w'_2 + 3 * w'_3) ** 2\n with w' = [-21, -43, -64].\n\n The gradient of g with respect to w' is:\n dg / dw'_1 = 1 * (1 * w'_1 + 2 * w'_2 + 3 * w'_3) = -299\n dg / dw'_2 = 2 * (1 * w'_1 + 2 * w'_2 + 3 * w'_3) = -598\n dg / dw'_3 = 3 * (1 * w'_1 + 2 * w'_2 + 3 * w'_3) = -897\n\n The updated parameters are given by:\n w''_1 = w'_1 - 1. * dg / dw'_1 = -21 - 1. * -299 = 278\n w''_2 = w'_2 - 1. * dg / dw'_2 = -43 - 1. * -598 = 555\n w''_3 = w'_3 - 1. * dg / dw'_3 = -64 - 1. * -897 = 833\n \"\"\"\n train_loss_2 = 0.5 * (model(train_inputs, params=params_1) ** 2)\n params_2 = gradient_update_parameters(model,\n train_loss_2,\n params=params_1,\n step_size=1.,\n first_order=False)\n\n assert train_loss_2.item() == 44700.5\n assert list(params_2.keys()) == ['weight']\n assert torch.all(params_2['weight'].data == torch.tensor([[278., 555., 833.]]))\n\n \"\"\"\n The new loss function is defined as\n h(w'') = 0.5 * (1 * w''_1 + 2 * w''_2 + 3 * w''_3) ** 2\n with w'' = [278, 555, 833].\n\n The gradient of h with respect to w'' is:\n dh / dw''_1 = 1 * (1 * w''_1 + 2 * w''_2 + 3 * w''_3) = 3887\n dh / dw''_2 = 2 * (1 * w''_1 + 2 * w''_2 + 3 * w''_3) = 7774\n dh / dw''_3 = 3 * (1 * w''_1 + 2 * w''_2 + 3 * w''_3) = 11661\n\n The updated parameters are given by:\n w'''_1 = w''_1 - 1. * dh / dw''_1 = 278 - 1. * 3887 = -3609\n w'''_2 = w''_2 - 1. * dh / dw''_2 = 555 - 1. * 7774 = -7219\n w'''_3 = w''_3 - 1. * dh / dw''_3 = 833 - 1. * 11661 = -10828\n \"\"\"\n train_loss_3 = 0.5 * (model(train_inputs, params=params_2) ** 2)\n params_3 = gradient_update_parameters(model,\n train_loss_3,\n params=params_2,\n step_size=1.,\n first_order=False)\n\n assert train_loss_3.item() == 7554384.5\n assert list(params_3.keys()) == ['weight']\n assert torch.all(params_3['weight'].data == torch.tensor([[-3609., -7219., -10828.]]))\n\n \"\"\"\n The new loss function is defined as\n l(w) = 4 * w'''_1 + 5 * w'''_2 + 6 * w'''_3\n with w = [2, 3, 5] and w''' = [-3609, -7219, -10828].\n\n The gradient of l with respect to w is:\n dl / dw_1 = 4 * dw'''_1 / dw_1 + 5 * dw'''_2 / dw_1 + 6 * dw'''_3 / dw_1\n = ... = -5020\n dl / dw_2 = 4 * dw'''_1 / dw_2 + 5 * dw'''_2 / dw_2 + 6 * dw'''_3 / dw_2\n = ... = -10043\n dl / dw_3 = 4 * dw'''_1 / dw_3 + 5 * dw'''_2 / dw_3 + 6 * dw'''_3 / dw_3\n = ... = -15066\n \"\"\"\n test_inputs = torch.tensor([[4., 5., 6.]])\n test_loss = model(test_inputs, params=params_3)\n grads = torch.autograd.grad(test_loss, model.parameters())\n\n assert test_loss.item() == -115499.\n assert len(grads) == 1\n assert torch.all(grads[0].data == torch.tensor([[-5020., -10043., -15066.]]))","def optimize(layer: Layer, learning_rate: float) -> None:\n layer._weights -= learning_rate * layer._dw\n layer._bias -= learning_rate * layer._db","def check_layer_gradient(layer, x, delta=1e-5, tol=1e-4):\n output = layer.forward(x)\n np.random.seed(10)\n #output_weight = np.random.randn(*output.shape)\n output_weight = np.ones_like(output)\n #print('output_weight',output_weight)\n\n def helper_func(x):\n output = layer.forward(x)\n loss = np.sum(output * output_weight)\n #print('loss',loss)\n d_out = np.ones_like(output) * output_weight\n grad = layer.backward(d_out)\n return loss, grad\n\n return check_gradient(helper_func, x, delta, tol)","def Train(self, input_data: list, target_output_data: list, learning_rate: float) -> float:\n ComputeGradients(input_data, target_output_data)\n self.hidden_layer_biases -= learning_rate * self.hidden_biases_gradient\n self.output_layer_biases -= learning_rate * self.output_biases_gradient\n self.input_to_hidden_weights -= learning_rate * self.input_to_hidden_weights_gradient\n self.hidden_to_output_weights -= learning_rate * self.hidden_to_output_weights_gradient","def gradient(self, theta):\n pass","def gradient(self, theta):\n pass","def _apply_gradient_decay():\n parameter_not_included = ['seg_emb', 'query_key_bias', 'query_emb_bias', 'query_seg_bias']\n num_layers = len(xlnet_base._net.transformer_cells)\n for (i, layer_parameters) in enumerate(xlnet_base._net.transformer_cells):\n layer_params = layer_parameters.collect_params()\n for key, value in layer_params.items():\n skip = False\n for pn in parameter_not_included:\n if pn in key:\n skip = True\n if skip:\n continue\n if value.grad_req != 'null':\n for arr in value.list_grad():\n arr *= args.layerwise_decay**(num_layers - i - 1)","def update_parameters(parameters, grads, learning_rate=0.01):\n # Retrieve each parameter from the dictionary \"parameters\"\n ### START CODE HERE ### (≈ 4 lines of code)\n W1 = parameters[\"W1\"]\n b1 = parameters[\"b1\"]\n W2 = parameters[\"W2\"]\n b2 = parameters[\"b2\"]\n W3 = parameters[\"W3\"]\n b3 = parameters[\"b3\"]\n ### END CODE HERE ###\n\n # Retrieve each gradient from the dictionary \"grads\"\n ### START CODE HERE ### (≈ 4 lines of code)\n dW1 = grads[\"dW1\"]\n db1 = grads[\"db1\"]\n dW2 = grads[\"dW2\"]\n db2 = grads[\"db2\"]\n dW3 = grads[\"dW3\"]\n db3 = grads[\"db3\"]\n ## END CODE HERE ###\n\n # Update rule for each parameter\n ### START CODE HERE ### (≈ 4 lines of code)\n W1 = W1 - (learning_rate * dW1)\n b1 = b1 - (learning_rate * db1)\n W2 = W2 - (learning_rate * dW2)\n b2 = b2 - (learning_rate * db2)\n W3 = W3 - (learning_rate * dW3)\n b3 = b3 - (learning_rate * db3)\n ### END CODE HERE ###\n\n parameters = {\"W1\": W1,\n \"b1\": b1,\n \"W2\": W2,\n \"b2\": b2,\n \"W3\": W3,\n \"b3\": b3}\n\n return parameters"],"string":"[\n \"def perform_update(self, gradient):\\n w = sys.modules[self.shared_mem_name].__dict__[\\\"w\\\"]\\n w -= self.learning_rate * gradient\",\n \"def update_weights(self, X, Y, learning_rate):\\n grads = self.calculate_gradients(X, Y)\\n #update weights and biases\\n self.weights[0] = self.weights[0] - learning_rate * grads[\\\"dW1\\\"]\\n self.weights[1] = self.weights[1] - learning_rate * grads[\\\"dW2\\\"]\\n self.biases[0] = self.biases[0] - learning_rate * grads[\\\"db1\\\"]\\n self.biases[1] = self.biases[1] - learning_rate * grads[\\\"db2\\\"]\",\n \"def __update_weights_grad_desc(self, x_train, y_train):\\n\\n predictions = self.__compute_prediction(x_train)\\n weights_delta = np.dot(x_train.T, y_train - predictions)\\n\\n m = y_train.shape[0]\\n self.__weights += self.__learning_rate / float(m) * weights_delta\",\n \"def update_weights(self):\\n\\n self.weights -= self.loss_grads\\n self.loss_grads = np.zeros(self.weights.shape)\",\n \"def update_weights(self, gradient, n):\\n lr_decay = self.learning_rate*(1/2)*(n/100)\\n self.delta_weights = lr_decay * gradient + self.momentum*self.delta_weights\\n self.weights += self.delta_weights\",\n \"def apply_gradient(self, learning_rate):\\n raise NotImplementedError()\",\n \"def update_weights(architecture,grad_weights,grad_bias,m,v,t,lr,optimizer=\\\"adam\\\"):\\n \\n for layer in range(len(architecture)):\\n if not (grad_weights['layer{}'.format(layer+1)] is None) and grad_bias['layer{}'.format(layer+1)] is not None:\\n grad_weightsi = grad_weights['layer{}'.format(layer+1)]\\n grad_weightsi /= bs\\n grad_biasi = grad_bias['layer{}'.format(layer+1)]\\n grad_biasi /= bs\\n\\n \\n if optimizer.lower()==\\\"sgd\\\":\\n # Mini-Batch SGD\\n qw = lr*grad_weightsi\\n qb = lr*grad_biasi\\n else:\\n # Mini-Batch Adam\\n mw,mb = m['layer{}'.format(layer+1)]\\n vw,vb = v['layer{}'.format(layer+1)]\\n qw,mw,vw = adam(grad_weightsi,beta_1,beta_2,mw,vw,t,lr) # Have obtained dw\\n qb,mb,vb = adam(grad_biasi,beta_1,beta_2,mb,vb,t,lr) # Have obtained db\\n\\n architecture['layer{}'.format(layer+1)][2].requires_grad = False\\n architecture['layer{}'.format(layer+1)][3].requires_grad = False\\n # Updating weights and biases now\\n try:\\n architecture['layer{}'.format(layer+1)][2] -= torch.Tensor(qw)\\n except:\\n architecture['layer{}'.format(layer+1)][2] -= torch.t(torch.Tensor(qw))\\n try:\\n architecture['layer{}'.format(layer+1)][3] -= torch.Tensor(qb)\\n except:\\n architecture['layer{}'.format(layer+1)][3] -= torch.t(torch.Tensor(qb))\\n\\n m['layer{}'.format(layer+1)][0] = torch.Tensor(mw)\\n m['layer{}'.format(layer+1)][1] = torch.Tensor(mb)\\n v['layer{}'.format(layer+1)][0] = torch.Tensor(vw)\\n v['layer{}'.format(layer+1)][1] = torch.Tensor(vb)\\n grad_weights['layer{}'.format(layer+1)] = torch.zeros(grad_weightsi.shape)\\n grad_bias['layer{}'.format(layer+1)] = torch.zeros(grad_biasi.shape)\\n return grad_weights,grad_bias,m,v\",\n \"def update(self, gradient, optimizer=None, relink=None):\\n # Recover the defaults, if missing\\n optimizer = self._resolve_defaults(optimizer=optimizer)[0]\\n # Set the gradient\\n self.set_gradient(gradient, relink=(self._config.relink if relink is None else relink))\\n # Perform the update step\\n optimizer.step()\",\n \"def backward(self, gradient: Tensor) -> Tensor:\\n self.b_grad = np.sum(gradient, axis=0)\\n self.w_grad = self.inputs.T @ gradient\\n return gradient @ self.w.T\",\n \"def _update_params(self, gradients: dict, learning_rate: float):\\n L = len(self.activations)\\n\\n for l in range(L):\\n self.params[\\\"W_\\\" + str(l + 1)] = self.params[\\\"W_\\\" + str(l + 1)] - learning_rate * gradients[\\n \\\"dW\\\" + str(l + 1)]\\n\\n self.params[\\\"b_\\\" + str(l + 1)] = self.params[\\\"b_\\\" + str(l + 1)] - learning_rate * gradients[\\n \\\"db\\\" + str(l + 1)]\",\n \"def update_weights(self):\\n activation, activation_p = self.feedforward()\\n # initialize delta_weights\\n delta_w = np.zeros(2)\\n # simultaneous calculate delta_weights\\n for i, element in enumerate(self.y):\\n delta_w += (activation[i]-element)*(activation_p[i])*self.X[i]\\n # update weight\\n self.weights -= self.alfa*delta_w\",\n \"def update_step(image_batch, label_batch, model, learning_rate):\\n f = model.forward(image_batch)\\n gradient = model.backward(f,label_batch)\\n model.w = model.w - learning_rate*gradient\",\n \"def update_gradients(self, dw, db):\\n self.w = self.w - self.lr * dw\\n self.b = self.b - (self.lr * db)\",\n \"def update(self):\\n # Update the weight matrix: \\n self.W -= self.lr * self.grad_W \\n \\n # Update the bias matrices:\\n self.b -= self.lr * np.array(self.grad_b) \\n self.c -= self.lr * np.array(self.grad_c)\",\n \"def optimize(self,gradients):\\n\\n for k in range(self.size):\\n delta_weight = self.learningRate * gradients[k]\\n full_change = delta_weight + self.momentum*self.last_change[k]\\n self.weights[k] -= full_change\\n self.last_change[k] = 1*gradients[k] #copy gradient mat\",\n \"def update_weights(self):\\n\\n\\n self.w += self.learn_rate * (self.X.T.dot(self.T - self.Y)\\n - self.reg_L1 * np.sign(self.w)\\n - self.reg_L2 * 2*self.w)\",\n \"def update_weights(x_train, y_train, weights, learning_rate):\\r\\n predictions = compute_prediction(x_train, weights)\\r\\n weights_delta = np.dot(x_train.T, y_train - predictions)\\r\\n m = y_train.shape[0]\\r\\n weights += learning_rate / float(m) * weights_delta\\r\\n return weights\",\n \"def __update(self, learning_rate):\\n for layer in self.layers:\\n layer.weights.set_value((layer.weights - learning_rate * layer.dW).eval())\\n layer.biases.set_value((layer.biases - learning_rate * layer.db).eval())\",\n \"def update_weights(self, X: np.ndarray, y: np.ndarray, learning_rate: float, reg_coeff: float):\\n ################################################################################\\n # TODO: Compute the gradient of loss computed above w.r.t the svm weights. #\\n # and then update self.w with the computed gradient. #\\n # (don't forget learning rate and reg_coeff in update rule) #\\n # Don't forget L2-regularization term in your implementation! #\\n ################################################################################\\n\\n # write your code here\\n N = len(X)\\n gradient = ((-1 * np.sum(((X.T * y).T)[np.where((1 - np.matmul(X, self.weights) * y) > 0)], axis=0)) / N) + reg_coeff * self.weights\\n self.weights -= learning_rate * gradient\\n\\n\\n ################################################################################\\n # END OF YOUR CODE #\\n ################################################################################\",\n \"def pull_weights(self, learning_rate):\\n for w in self.weights:\\n w.value += learning_rate * w.gradient\\n # Reset all the weights' gradient to 0\\n # We will not reset all other units' gradient, because all other units should be initialized in next training\\n # round, and the init value of gradient is 0\\n for w in self.weights:\\n w.gradient = 0\",\n \"def gradient_update(self, states, Q_target):\\n params = [self.w1, self.w2, self.w3, self.b1, self.b2, self.b3]\\n loss = self.get_loss(states, Q_target)\\n gradients = nn.gradients(loss, params)\\n self.w1.update(gradients[0], -self.learning_rate)\\n self.w2.update(gradients[1], -self.learning_rate)\\n self.w3.update(gradients[2], -self.learning_rate)\\n self.b1.update(gradients[3], -self.learning_rate)\\n self.b2.update(gradients[4], -self.learning_rate)\\n self.b3.update(gradients[5], -self.learning_rate)\",\n \"def update_weights(self):\\n\\t\\tpass\",\n \"def update_weights(self, weight_delta):\\n\\n self._weights = math_util.vector_sum(self._weights, weight_delta)\",\n \"def _UpdateGradient(self):\\n self.mol.GetGradient('analytic')\",\n \"def add_grad_updates(self):\\n \\n gradients = T.grad(self.cost, self.theta)\\n \\n for target_param, grad in zip(self.theta, gradients):\\n \\n if target_param.name ==\\\"W\\\" and self.num_hidden ==0\\\\\\n and self.zero_diag:\\n \\n grad = grad - T.diag(T.diag(grad)) # no x i - xi connections\\n # for all i = 1, ..., D\\n ##############################################################\\n if target_param.name ==\\\"b\\\" and self.learn_biases == False:\\n print(\\\"Will not learn bias terms\\\")\\n pass\\n \\n elif target_param.name ==\\\"bhid\\\" and self.learn_biases == False:\\n print(\\\"Will not learn bias terms\\\")\\n pass\\n \\n else:\\n \\n if self.use_momentum:\\n \\n # alternative definition (mostly seen):\\n #g_tilda = self.momentum*self.grad_vec[target_param.name] - \\\\\\n #T.cast(self.learning_rate, dtype = theano.config.floatX)*grad\\n #self.updates[target_param] = target_param + g_tilda\\n \\n g_tilda = self.momentum*self.grad_vec[target_param.name] - \\\\\\n (1-self.momentum)*grad\\n \\n self.updates[target_param] = target_param +\\\\\\n T.cast(self.learning_rate, dtype = theano.config.floatX)*g_tilda\\n \\n # store g_tilda for next iteration:\\n self.updates[self.grad_vec[target_param.name]] = g_tilda\\n \\n else:\\n \\n self.updates[target_param] = target_param -\\\\\\n T.cast(self.learning_rate, dtype = theano.config.floatX)*grad\\n \\n if (\\\"PCD\\\" in self.algorithm) and self.num_hidden > 0:\\n \\n self.updates[self.persistent_gibbs] = self.hid_samples\",\n \"def updateWeights(self, LR, M):\\n assert self._batch\\n for i,(dws,odws) in enumerate(zip(self._wDeltas, self._oldWDeltas)):\\n ws = self._layer.weightsAt(i)\\n for j, (dw, odw) in enumerate(zip(dws, odws)):\\n dw = LR*dw + M*odw\\n ws[j] += dw\\n odws[j] = dw\\n dws[j] = 0.0\",\n \"def gradient_weight(X, Y, model):\\n W = model['weight']\\n b = model['bias']\\n weight_decay = model['weight_decay']\\n\\n # YOUR CODE HERE\\n # Write the gradient with respect to the weights.\\n return np.add(np.subtract(np.dot(np.transpose(predict(X, model)), X), np.dot(np.transpose(Y), X)), 2 * LAMBDA * np.transpose(model['weight'])) #np.zeros((X.shape[1], Y.shape[1]))\",\n \"def test_update_parameters(model):\\n train_inputs = torch.tensor([[1., 2., 3.]])\\n train_loss = 0.5 * (model(train_inputs) ** 2)\\n\\n params = gradient_update_parameters(model,\\n train_loss,\\n params=None,\\n step_size=0.5,\\n first_order=False)\\n\\n assert train_loss.item() == 264.5\\n assert list(params.keys()) == ['weight']\\n assert torch.all(params['weight'].data == torch.tensor([[-9.5, -20., -29.5]]))\\n\\n \\\"\\\"\\\"\\n The new loss function (still with respect to the weights of the model w) is\\n defined as:\\n g(w) = 0.5 * (4 * w'_1 + 5 * w'_2 + 6 * w'_3) ** 2\\n = 0.5 * (4 * (w_1 - 0.5 * df / dw_1)\\n + 5 * (w_2 - 0.5 * df / dw_2)\\n + 6 * (w_3 - 0.5 * df / dw_3)) ** 2\\n = 0.5 * (4 * (w_1 - 0.5 * 1 * (1 * w_1 + 2 * w_2 + 3 * w_3))\\n + 5 * (w_2 - 0.5 * 2 * (1 * w_1 + 2 * w_2 + 3 * w_3))\\n + 6 * (w_3 - 0.5 * 3 * (1 * w_1 + 2 * w_2 + 3 * w_3))) ** 2\\n = 0.5 * ((4 - 4 * 0.5 - 5 * 1.0 - 6 * 1.5) * w_1\\n + (5 - 4 * 1.0 - 5 * 2.0 - 6 * 3.0) * w_2\\n + (6 - 4 * 1.5 - 5 * 3.0 - 6 * 4.5) * w_3) ** 2\\n = 0.5 * (-12 * w_1 - 27 * w_2 - 42 * w_3) ** 2\\n\\n Therefore the gradient of the function g with respect to w (and evaluated\\n at w = [2, 3, 5]) is:\\n dg / dw_1 = -12 * (-12 * w_1 - 27 * w_2 - 42 * w_3) = 3780\\n dg / dw_2 = -27 * (-12 * w_1 - 27 * w_2 - 42 * w_3) = 8505\\n dg / dw_3 = -42 * (-12 * w_1 - 27 * w_2 - 42 * w_3) = 13230\\n \\\"\\\"\\\"\\n test_inputs = torch.tensor([[4., 5., 6.]])\\n test_loss = 0.5 * (model(test_inputs, params=params) ** 2)\\n\\n grads = torch.autograd.grad(test_loss, model.parameters())\\n\\n assert test_loss.item() == 49612.5\\n assert len(grads) == 1\\n assert torch.all(grads[0].data == torch.tensor([[3780., 8505., 13230.]]))\",\n \"def weight_update(u_ff, u_wc, alpha, beta, w, fan_all):\\r\\n mult_wc = np.matmul(np.reshape(hard_sigmoid_array(u_wc), (fan_all, 1)),\\r\\n np.reshape(hard_sigmoid_array(u_wc), (1, fan_all)))\\r\\n mult_ff = np.matmul(np.reshape(hard_sigmoid_array(u_ff), (fan_all, 1)),\\r\\n np.reshape(hard_sigmoid_array(u_ff), (1, fan_all)))\\r\\n delta_w = alpha * (1 / beta) * (mult_wc - mult_ff)\\r\\n delta_w[np.diag_indices(fan_all)] = 0\\r\\n w = w + delta_w\\r\\n return w\",\n \"def update_weights(self):\\n self._weights = self._weights + self.update_weights_value\\n self.weights_clipping()\",\n \"def backward(self, inGradient, lr=0.001): # batchSize = 1\\n wGradient = np.dot(inGradient.T, self.data)\\n bGradient = np.sum(inGradient, axis=0)\\n outGradient = np.dot(inGradient, self.weights)\\n\\n self.weights = self.weights - lr * wGradient\\n self.bias = self.bias - lr * bGradient\\n self.wGradient = wGradient\\n self.bGradient = bGradient\\n\\n #print \\\"weight gradient \\\", wGradient\\n #print \\\"bias gradient \\\", bGradient\\n\\n return outGradient\",\n \"def update_params(self, learning_rate):\\n\\t\\t#######################################################################\\n\\t\\t# ** START OF YOUR CODE **\\n\\t\\t#######################################################################\\n\\t\\tself._W = self._W - learning_rate * self._grad_W_current\\n\\t\\tself._b = self._b - learning_rate * self._grad_b_current\\n\\t\\t#######################################################################\\n\\t\\t# ** END OF YOUR CODE **\\n\\t\\t#######################################################################\",\n \"def update(self, weights, grads):\\n learn_rate_t = self.learn_rate\\n\\n new_weights = []\\n for w, g in zip(weights, grads):\\n\\n # Apply weight decay\\n if w.shape[1] > 1:\\n # Weight matrix\\n g_t = learn_rate_t * (g + self.weight_decay * w)\\n else:\\n # Bias matrix\\n g_t = learn_rate_t * g\\n w_t = w - g_t\\n new_weights.append(w_t)\\n return new_weights\",\n \"def update_weights(self):\\r\\n\\r\\n inedges=self.in_edges\\r\\n for edge in inedges:\\r\\n weight=edge.weight+self.learning_rate*self.delta*(edge.source.activation)\\r\\n edge.change_weight(weight)\",\n \"def update(self, X, y):\\n proba = self.predict_proba(X)\\n top_loss = proba - y\\n bias_gradient = np.sum(top_loss)\\n weight_gradient = (top_loss).T.dot(X)\\n\\n # the gradient update\\n self.b = self.b - self.lrate * bias_gradient\\n self.W = self.W - self.lrate * weight_gradient\",\n \"def update_params(self, learning_rate=0.1):\\n\\n self.params['W'] = self.params['W'] - learning_rate * self.dW # update weights\\n self.params['b'] = self.params['b'] - learning_rate * self.db # update bias(es)\",\n \"def weights_update(self, previous_layer_output, learning_rate, l2_lambda, batch_size):\\n theta, b, delta, alpha = self.theta, self.b, self.delta, learning_rate\\n dc_dtheta = np.dot(previous_layer_output, delta.T).transpose()\\n dc_dtheta = np.divide(1, batch_size) * dc_dtheta\\n new_theta = theta*(1 - l2_lambda * alpha) - alpha * dc_dtheta\\n b_prime = np.sum(delta, axis=1).reshape(b.shape)\\n b_prime = b_prime * np.divide(1, batch_size)\\n new_b = b - alpha * b_prime\\n self.theta, self.b = new_theta, new_b\",\n \"def update_weights_sum(self):\\n vals = self.nn.get_param_values()\\n # only use the last layer for summation (w, b)\\n self.w_sum = np.sum(vals[-2]) + np.sum(vals[-1])\",\n \"def update_param(self, lr):\\n\\n\\n self.W=self.W-lr*self.W_grad\\n self.b = self.b - lr*self.b_grad\",\n \"def handle_gradient(self):\\n self._optimizer.sync_grad()\",\n \"def update_weights(self):\\n self._weights = self._weights + self.update_weights_value\",\n \"def update_layers(self):\\n\\n # Para cada layer atualiza utilizando o gradiente descendente e o learning rate\\n for layer in self.layers:\\n layer.update_layer(self.learning_rate)\",\n \"def update_network(self, loss_dict):\\r\\n loss = sum(loss_dict.values())\\r\\n self.optimizer.zero_grad()\\r\\n loss.backward()\\r\\n self.optimizer.step()\",\n \"def step(self, layers, d_weights, d_biases, lr):\\n for layer, d_W, d_b in zip(layers, d_weights, d_biases):\\n layer.update(-lr * d_W, -lr * d_b)\",\n \"def backward(self, gradient):\\n raise NotImplementedError()\",\n \"def updateParams(self,gradients):\\n for i in xrange(len(self.params)):\\n self.params[i].set_value(self.params[i].get_value()-gradients[i]/(1/self.learning_rate+self.iterations))\",\n \"def update_weights(self, gradient_steps):\\n for gradient_step in range(int(gradient_steps)):\\n states, actions, rewards, dones, new_states = tf.numpy_function(\\n self.concat_buffer_samples, [], self.batch_dtypes\\n )\\n self.update_critic_weights(states, actions, new_states, dones, rewards)\\n if gradient_step % self.policy_delay == 0:\\n self.update_actor_weights(states)\\n self.sync_target_models()\",\n \"def update_parameters(self, learning_rate):\\n for i in range(self.L - 1):\\n self.W[i] -= learning_rate * self.dW[i]\\n self.b[i] -= learning_rate * self.db[i]\",\n \"def update(self, loss=None, inputs=None, targets=None, outputs=None):\\n\\n # TODO: add gradient accumulation\\n\\n self.optimizer.zero_grad(set_to_none=self.none_grad)\\n\\n if self.grad_scaler:\\n self.grad_scaler.scale(loss).backward()\\n self.grad_scaler.step(self.optimizer)\\n\\n if self.clip_grad:\\n self.grad_scaler.unscale_(self.optimizer)\\n self.clip_grad(self.model.parameters())\\n self.grad_scaler.update()\\n else:\\n loss.backward()\\n\\n if self.clip_grad:\\n self.clip_grad(self.model.parameters())\\n\\n self.optimizer.step()\",\n \"def gradients_to_updates(self, params, grads):\\n return NotImplementedError('Abstract class method')\",\n \"def adjust_weights(self, weights_deltas):\\n for layer_index in xrange(len(self.w)):\\n self.w[layer_index] = np.add(self.w[layer_index], weights_deltas[layer_index])\",\n \"def apply_gradient(params: torch.Tensor, grads: torch.Tensor, lr: float) -> torch.Tensor:\\n params_prime = params + lr * grads\\n return params_prime\",\n \"def updateWeights(inputs, outputs, learning_rate, y, weights):\\n for i in range(len(weights)):\\n weights[i] = weights[i] + learning_rate * (outputs - y) * inputs[i]\\n return weights\",\n \"def update(params: hk.Params, opt_state: OptState, batch, labels, xent_weight=self.weights, l1_coeff=self.l1_coef, l2_coeff=self.l2_coef) -> Tuple[hk.Params, OptState]:\\n grads = jax.grad(loss)(params, batch, labels, xent_weight, l1_coeff, l2_coeff)\\n updates, opt_state = opt.update(grads, opt_state)\\n new_params = optax.apply_updates(params, updates)\",\n \"def learning_by_gradient_descent(y, tx, w, gamma):\\n loss = calculate_loss(y,tx,w)\\n grad = calculate_gradient(y,tx,w)\\n w_new = w - gamma*grad\\n #grad is for debugging purpose\\n return loss, w_new,grad\",\n \"def backward(self, gradient):\\n #TODO\\n pass\",\n \"def backward(self, gradient):\\n #TODO\\n pass\",\n \"def update_network(self, tr_d, lr, relz=\\\"\\\", lmbda=0.0, mu=0.0):\\n trlen = float(len(tr_d))\\n delta_b = [np.zeros(b.shape) for b in self.biases]\\n delta_w = [np.zeros(w.shape) for w in self.weights]\\n for x,y in tr_d:\\n delta_b_single, delta_w_single = self.backppg_ce(x,y)\\n delta_b = [db+dbs for db,dbs in zip(delta_b, delta_b_single)]\\n delta_w = [dw+dws for dw,dws in zip(delta_w, delta_w_single)]\\n #update the parameters in network\\n if(relz==\\\"\\\"):\\n mu=0.0\\n elif(relz[0:2] == \\\"MO\\\"):\\n relz = relz[2:]\\n self.velw = [mu*vw-(lr/trlen)*dw for vw,dw in zip(self.velw, delta_w)]\\n self.velb = [mu*vb-(lr/trlen)*db for vb,db in zip(self.velb, delta_b)]\\n self.biases = [b + vb for b,vb in zip(self.biases, self.velb)]\\n if(relz == \\\"L2\\\"):\\n self.weights = [w + vw - (lr/trlen/100)*lmbda*w for w,vw in zip(self.weights, self.velw)]\\n elif(relz == \\\"L1\\\"):\\n self.weights = [w + vw - (lr/trlen/100)*lmbda*np.sign(w) for w,vw in zip(self.weights, self.velw)]\\n else:\\n self.weights = [w + vw for w,vw in zip(self.weights, self.velw)]\",\n \"def update_params(layers, param_grads, learning_rate):\\n for layer, layer_backprop_grads in zip(layers, param_grads):\\n for param, grad in zip(layer.get_params_iter(), layer_backprop_grads):\\n # The parameter returned by the iterator point to the memory space of\\n # the original layer and can thus be modified inplace.\\n param -= learning_rate * grad # Update each parameter\",\n \"def update(self, weights, grads):\\n\\n learn_rate = self.learn_rate\\n\\n # Scale the learning rate by the iteration number\\n t = self.iters + 1\\n learn_rate_t = learn_rate * (np.sqrt(1 - self.beta2**t) /\\n (1 - self.beta1**t))\\n\\n # Store the momentum and velocities for each node\\n if self.ms is None:\\n self.ms = [np.zeros(w.shape) for w in weights]\\n if self.vs is None:\\n self.vs = [np.zeros(w.shape) for w in weights]\\n ms, vs = self.ms, self.vs\\n\\n # Make sure everything has the right length\\n assert len(weights) == len(grads)\\n assert len(weights) == len(ms)\\n assert len(weights) == len(vs)\\n\\n # Now, for each weight stack, update momentum, velocity, weights\\n new_ms = []\\n new_vs = []\\n new_weights = []\\n for w, g, m, v in zip(weights, grads, ms, vs):\\n # Momentum update\\n m_t = (self.beta1 * m) + (1.0 - self.beta1) * g\\n\\n # Velocity update\\n v_t = (self.beta2 * v) + (1.0 - self.beta2) * g**2\\n\\n # Update the weights\\n w_t = w - learn_rate_t * m_t / (np.sqrt(v_t) + 1e-8)\\n\\n new_ms.append(m_t)\\n new_vs.append(v_t)\\n new_weights.append(w_t)\\n\\n self.ms = new_ms\\n self.vs = new_vs\\n return new_weights\",\n \"def update_params(layers, param_grads, learning_rate):\\n for layer, layer_backprop_grads in zip(layers, param_grads):\\n for param, grad in itertools.izip(layer.get_params_iter(), layer_backprop_grads):\\n # The parameter returned by the iterator point to the memory space of\\n # the original layer and can thus be modified inplace.\\n param -= learning_rate * grad # Update each parameter\",\n \"def add_custom_gradients(self, clst_weights, weights):\\n override_weights = tf.sign(tf.reshape(weights, shape=(-1,)) + 1e+6)\\n z = clst_weights * override_weights\\n\\n def grad(dz):\\n return dz, dz\\n\\n return z, grad\",\n \"def update_weights(net, input_values, desired_output, neuron_outputs, r=1):\\n raise NotImplementedError\",\n \"def apply_on_layer(self, layer):\\n init_g = Constant(1.)\\n\\n try:\\n weight_tag = 'W' if hasattr(layer, 'W') else 'U'\\n except AttributeError:\\n raise AttributeError(\\\"Trying to call weight norm on {} \\\".format(layer)+\\\\\\n \\\"without layer.W or layer.U defined\\\")\\n weights = getattr(layer, weight_tag)\\n\\n Wndim = weights.get_value().ndim\\n if Wndim == 4:\\n W_axes_to_sum = (1,2,3)\\n W_dimshuffle_args = (0,'x','x','x')\\n elif Wndim == 5:\\n W_axes_to_sum = (1,2,3,4)\\n W_dimshuffle_args = (0,'x','x','x','x')\\n elif Wndim == 3 :\\n raise NotImplementedError(\\\"What is a weight with 3 dimensions?\\\")\\n else :\\n W_axes_to_sum = 0\\n W_dimshuffle_args = ('x',0)\\n\\n if self.train_g is not None:\\n g = init_g(layer.output_dims)\\n g = theano.shared(g, name=layer.prefix+'_g')\\n if self.train_g :\\n layer.params += [g]\\n\\n new_weights = weights * (\\n g / T.sqrt(1e-6 + T.sum(T.square(weights),\\n axis=W_axes_to_sum))).dimshuffle(*W_dimshuffle_args)\\n layer.g = g\\n else:\\n new_weights = weights / \\\\\\n T.sqrt(1e-6 + T.sum(T.square(weights),\\n axis=W_axes_to_sum,keepdims=True))\\n\\n setattr(layer, weight_tag, new_weights)\",\n \"def grad(self, w):\\n gradient_penalty = np.asarray(self.alpha) * w\\n # Insert 0 for bias term.\\n return np.insert(gradient_penalty, 0, 0, axis=0)\",\n \"def grad(self, w):\\n gradient_penalty = np.asarray(self.alpha) * w\\n # Insert 0 for bias term.\\n return np.insert(gradient_penalty, 0, 0, axis=0)\",\n \"def update_parameters(parameters: Dict,\\n grads: Dict, learning_rate: float) -> Dict:\\n L = len(parameters)//2 # number of layers\\n\\n for l in range(1, L+1):\\n parameters['W'+str(l)] -= learning_rate * grads['dW'+str(l)]\\n parameters['b'+str(l)] -= learning_rate * grads['db'+str(l)]\\n\\n return parameters\",\n \"def _compute_func_grad(self, w):\\n W = w.reshape((self.X.shape[1], self.Y.shape[1]))\\n self.nll_, self.grad_ = calculate_gradient(self.X, self.Y, W, self.prior, self.weighted,0)\",\n \"def update(self,parameters, grads):\\n \\n L = len(parameters) // 2 # number of layers in the neural network\\n #print(L)\\n\\n # Update rule for each parameter. Use a for loop.\\n for l in range(L):\\n \\n parameters[\\\"W\\\" + str(l+1)] = parameters[\\\"W\\\" + str(l+1)] - self.alpha * grads[\\\"dW\\\" + str(l+1)]\\n \\n parameters[\\\"b\\\" + str(l+1)] = parameters[\\\"b\\\" + str(l+1)] - self.alpha * grads[\\\"db\\\" + str(l+1)]\\n \\n parameters[\\\"W\\\" + str(l+1)][np.isnan(parameters[\\\"W\\\" + str(l+1)])] = 0\\n parameters[\\\"b\\\" + str(l+1)][np.isnan(parameters[\\\"b\\\" + str(l+1)])] = 0\\n \\n return parameters\",\n \"def update_model_parameters(parameters, grads, learning_rate):\\n L = len(parameters) /2 # number of layers in the neural network\\n\\n for l in range(int(L)):\\n parameters[\\\"W\\\" + str(l + 1)] = parameters[\\\"W\\\" + str(l + 1)] - learning_rate * grads[\\\"dW\\\" + str(l + 1)]\\n parameters[\\\"b\\\" + str(l + 1)] = parameters[\\\"b\\\" + str(l + 1)] - learning_rate * grads[\\\"db\\\" + str(l + 1)]\\n return parameters\\n # raise NotImplementedError\",\n \"def update_weights(self, alpha, ind):\\n inside = -alpha * self.labels * self.predictions[ind, :]\\n new_weights = self.weights * np.exp(inside)\\n self.weights = new_weights / np.sum(new_weights)\",\n \"def grad(self, w):\\n gradient_penalty = np.asarray(self.alpha) * w\\n\\n # Insert 0 for bias term.\\n return np.insert(gradient_penalty, 0, 0, axis=0)\",\n \"def update_w(self, w):\\n # Need to update the scaled weights\\n if self.scale_weights:\\n self._scale_weights_to_degree(w)\\n self._generate_weighted_adj_matrices()\\n # once we get new DW matrices, multiply by weights\\n super().update_w(w)\\n self._degree_weight_weighted_matrices()\",\n \"def update_weights(weights, alpha, y_true, y_pred):\\n def change_labels(arr):\\n for i,a in enumerate(arr):\\n if a == 0:\\n arr[i] = -1\\n return arr \\n \\n y_true, y_pred = change_labels(y_true), change_labels(y_pred)\\n w_hat = weights * np.exp(-alpha * y_true * y_pred)\\n return w_hat / sum(w_hat)\",\n \"def gradient_descent_step(self, x, y, learning_rate):\\n # compute derivative of loss wrt Z\\n dZ = self.derivative_loss(y, self.predict(x))\\n dW = np.dot(dZ, x)\\n # subtract average derivative from weights\\n self.w -= learning_rate * 1.0/dW.shape[0] * dW\\n if self.fit_b:\\n self.b -= learning_rate * (1.0/x.shape[0] * np.sum(dZ))\",\n \"def update_parameters(parameters, grads, learning_rate = 1.2):\\n\\t# Retrieve each parameter from the dictionary \\\"parameters\\\"\\n\\tW1 = parameters['W1']\\n\\tb1 = parameters['b1']\\n\\tW2 = parameters['W2']\\n\\tb2 = parameters['b2']\\n\\n\\t# Retrieve each gradient from the dictionary \\\"grads\\\"\\n\\tdW1 = grads['dW1']\\n\\tdb1 = grads['db1']\\n\\tdW2 = grads['dW2']\\n\\tdb2 = grads['db2']\\n\\n\\t# Update rule for each parameter\\n\\tW1 = W1 - learning_rate*dW1\\n\\tb1 = b1 - learning_rate*db1\\n\\tW2 = W2 - learning_rate*dW2\\n\\tb2 = b2 - learning_rate*db2\\n\\n\\tparameters = {\\\"W1\\\": W1,\\n\\t\\t\\t\\t\\t\\\"b1\\\": b1,\\n\\t\\t\\t\\t\\t\\\"W2\\\": W2,\\n\\t\\t\\t\\t\\t\\\"b2\\\": b2}\\n\\n\\treturn parameters\",\n \"def update_weight(self, x_input: np.ndarray) -> None:\\n if self.layers[-1].delta is None:\\n raise ValueError(\\\"No derivative calculated yet\\\")\\n layer_input = x_input.copy()\\n if np.ndim(x_input) == 1:\\n layer_input = layer_input.reshape(-1, 1)\\n for layer in self.layers:\\n layer.update_weights(layer_input, self.learning_rate)\\n layer_input = layer.output\",\n \"def learning_by_gradient_descent(y, tx, w, gamma):\\n\\tgrad = calculate_gradient(y, tx, w)\\n\\n\\tw = w - gamma * grad\\n\\treturn w\",\n \"def update_parameters_with_gd(parameters, grads, learning_rate):\\n\\n L = len(parameters) // 2 # number of layers in the neural networks\\n\\n # Update rule for each parameter\\n for l in range(L):\\n parameters[\\\"W\\\" + str(l+1)] = parameters[\\\"W\\\" + str(l+1)] - learning_rate * grads['dW' + str(l+1)]\\n parameters[\\\"b\\\" + str(l+1)] = parameters[\\\"b\\\" + str(l+1)] - learning_rate * grads['db' + str(l+1)]\\n \\n return parameters\",\n \"def delta_w(w_k, x, t, learning_rate):\\n return -learning_rate * np.mean(gradient(w_k, x, t))\",\n \"def grad(self, w):\\n l1_grad = self.r * np.sign(w)\\n l2_grad = np.asarray(1 - self.r) * w \\n\\n gradient_penalty = self.alpha * (l1_grad + l2_grad)\\n\\n # Insert 0 for bias term.\\n return np.insert(gradient_penalty, 0, 0, axis=0)\",\n \"def wasserstein_g_update(loss, optimizer, var_list=None, global_step=None, name='g_update'):\\n # grads = optimizer.compute_gradients(loss, var_list=var_list)\\n # return optimizer.apply_gradients(grads, global_step=global_step, name=name)\\n\\n return optimizer.minimize(loss, global_step=global_step, var_list=var_list, name=name)\",\n \"def _update_parameters(self, loss):\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\",\n \"def learning_by_penalized_gradient(y, tx, w, gamma, lambda_):\\n\\tgrad, H = penalized_logistic_regression(y, tx, w, lambda_)\\n\\n\\thgrad = np.linalg.inv(H).dot(grad)\\n\\n\\tw = w - gamma * hgrad\\n\\n\\treturn w\",\n \"def update_parameters_with_gd(parameters, grads, learning_rate):\\n\\n L = len(parameters) // 2 # number of layers in the neural networks\\n\\n # Update rule for each parameter\\n for l in range(L):\\n ### START CODE HERE ### (approx. 2 lines)\\n parameters[\\\"W\\\" + str(l+1)] = parameters[\\\"W\\\" + str(l+1)]-learning_rate* grads[\\\"dW\\\" + str(l+1)]\\n parameters[\\\"b\\\" + str(l+1)] = parameters[\\\"b\\\" + str(l+1)]-learning_rate* grads[\\\"db\\\" + str(l+1)]\\n ### END CODE HERE ###\\n \\n return parameters\",\n \"def gradient(self, inputs):\\n raise NotImplementedError\",\n \"def update_recurrent_weights_step(self):\\n \\n # update weights: hebbian term\\n self.delta_Wee=self.learn_rate*(self.rr[0:self.N_e]-self.input_mean)*\\\\\\n (self.rr[0:self.N_e].T-self.input_mean)\\n \\n self.W_ee+=self.dt*self.delta_Wee\\n\\n # update weights: normalize to fixed mean of incoming and outgoing weights\\n self.W_ee-=(self.W_ee.mean(axis=1)-self.W_av_star)[:,np.newaxis]\\n self.W_ee-=(self.W_ee.mean(axis=0)-self.W_av_star)[np.newaxis,:]\\n \\n # clip weights \\n self.W_ee=np.clip(self.W_ee,0,self.W_max_ee)\\n \\n # update excitatory weights in the big weight matrix\\n self.W[:self.N_e,:self.N_e]=self.W_ee\",\n \"def gradient(self, node, output_grad):\\r\\n raise NotImplementedError\",\n \"def _apply_gradient_descent(self, gradients):\\n updated_sd = {}\\n global_model = self._get_global_model()\\n \\n for name, param, grad in zip(global_model.keys(), global_model.values(), gradients):\\n updated_sd[name] = param - self.global_lr * grad\\n \\n self._load_global_model(updated_sd)\",\n \"def weight_update_conjugate_gradient(self, network):\\n # compute beta: Fletcher-Reeves\\n num = 0.0\\n for l, layer in enumerate(network.layers):\\n num += np.sum(self.dc_db[l] ** 2)\\n num += np.sum(self.dc_dq[l] ** 2)\\n num += np.sum(self.dc_drx_inp[l] ** 2)\\n num += np.sum(self.dc_dry_inp[l] ** 2)\\n num += np.sum(self.dc_drx_pos_out[l] ** 2)\\n num += np.sum(self.dc_dry_pos_out[l] ** 2)\\n num += np.sum(self.dc_drx_neg_out[l] ** 2)\\n num += np.sum(self.dc_dry_neg_out[l] ** 2)\\n\\n # Initialize velocities to zero for momentum\\n if self.vel_b is None or self.vel_q is None:\\n self.ms_b = []\\n self.ms_q = []\\n self.ms_rx_inp = []\\n self.ms_ry_inp = []\\n self.ms_rx_pos_out = []\\n self.ms_ry_pos_out = []\\n self.ms_rx_neg_out = []\\n self.ms_ry_neg_out = []\\n for l, layer in enumerate(network.layers):\\n self.ms_b.append(np.zeros(layer.b.shape))\\n self.ms_q.append(np.zeros(layer.q.shape))\\n self.ms_rx_inp.append(np.zeros(layer.input_size))\\n self.ms_ry_inp.append(np.zeros(layer.input_size))\\n self.ms_rx_pos_out.append(np.zeros(layer.output_size))\\n self.ms_ry_pos_out.append(np.zeros(layer.output_size))\\n self.ms_rx_neg_out.append(np.zeros(layer.output_size))\\n self.ms_ry_neg_out.append(np.zeros(layer.output_size))\\n\\n # Take steepest descent step\\n for l, layer in enumerate(network.layers):\\n layer.b -= self.alpha * self.dc_db[l]\\n layer.q -= self.alpha * self.dc_dq[l]\\n layer.rx_inp -= self.alpha * self.dc_drx_inp[l]\\n layer.ry_inp -= self.alpha * self.dc_dry_inp[l]\\n layer.rx_pos_out -= self.alpha * self.dc_drx_pos_out[l]\\n layer.ry_pos_out -= self.alpha * self.dc_dry_pos_out[l]\\n layer.rx_neg_out -= self.alpha * self.dc_drx_neg_out[l]\\n layer.ry_neg_out -= self.alpha * self.dc_dry_neg_out[l]\\n\\n else:\\n # compute beta\\n beta = num / self.denominator\\n\\n # compute s_n\\n for l, layer in enumerate(network.layers):\\n self.ms_b[l] = -self.alpha * self.dc_db[l] + beta * self.ms_b[l]\\n self.ms_q[l] = -self.alpha * self.dc_dq[l] + beta * self.ms_q[l]\\n self.ms_rx_inp[l] = -self.alpha * self.dc_drx_inp[l] + beta * self.ms_rx_inp[l]\\n self.ms_ry_inp[l] = -self.alpha * self.dc_dry_inp[l] + beta * self.ms_ry_inp[l]\\n self.ms_rx_pos_out[l] = -self.alpha * self.dc_drx_pos_out[l] + beta * self.ms_rx_pos_out[l]\\n self.ms_ry_pos_out[l] = -self.alpha * self.dc_dry_pos_out[l] + beta * self.ms_ry_pos_out[l]\\n self.ms_rx_neg_out[l] = -self.alpha * self.dc_drx_neg_out[l] + beta * self.ms_rx_neg_out[l]\\n self.ms_ry_neg_out[l] = -self.alpha * self.dc_dry_neg_out[l] + beta * self.ms_ry_neg_out[l]\\n\\n # Take step\\n for l, layer in enumerate(network.layers):\\n layer.b += self.alpha * self.ms_b[l]\\n layer.q += self.alpha * self.ms_q[l]\\n layer.rx_inp += self.alpha * self.ms_rx_inp[l]\\n layer.ry_inp += self.alpha * self.ms_ry_inp[l]\\n layer.rx_pos_out += self.alpha * self.ms_rx_pos_out[l]\\n layer.ry_pos_out += self.alpha * self.ms_ry_pos_out[l]\\n layer.rx_neg_out += self.alpha * self.ms_rx_neg_out[l]\\n layer.ry_neg_out += self.alpha * self.ms_ry_neg_out[l]\\n\\n # store num for next iteration to be used as denominator\\n self.denominator = num\",\n \"def update_gradients(self, grads):\\n self.variance.gradient = grads[0]\",\n \"def apply_gradient(self, hyper_params, params, state, grads):\\n step = state.step\\n # We assume that params, param_states, and grads are all dict-like here.\\n params_flat_dict = utils.flatten_dict_string_keys(params)\\n params_paths = params_flat_dict.keys()\\n params_flat = params_flat_dict.values()\\n # extra paranoia to guarantee identical value ordering\\n states_flat = utils.flatten_dict_string_keys(state.param_states)\\n states_flat = [states_flat[k] for k in params_paths]\\n grads_flat = utils.flatten_dict_string_keys(grads)\\n grads_flat = [grads_flat[k] for k in params_paths]\\n\\n if hyper_params.global_norm_clip_threshold:\\n # Paper: http://proceedings.mlr.press/v28/pascanu13.pdf\\n # TF: https://www.tensorflow.org/api_docs/python/tf/clip_by_global_norm\\n squared_l2_norms = [jnp.sum(jnp.square(g)) for g in grads_flat]\\n global_norm = jnp.sqrt(jnp.sum(jnp.array(squared_l2_norms)))\\n scale = hyper_params.global_norm_clip_threshold * jnp.minimum(\\n 1.0 / hyper_params.global_norm_clip_threshold, 1.0 / global_norm)\\n grads_flat = [g * scale for g in grads_flat]\\n\\n out = [\\n self.apply_param_gradient(step, hyper_params, param, state, grad, path)\\n for param, state, grad, path in zip(params_flat, states_flat,\\n grads_flat, params_paths)\\n ]\\n\\n new_params_flat, new_states_flat = list(zip(*out)) if out else ((), ())\\n new_params_flat = {k: v for k, v in zip(params_paths, new_params_flat)}\\n new_states_flat = {k: v for k, v in zip(params_paths, new_states_flat)}\\n new_params = _restore(params, new_params_flat)\\n new_param_states = _restore(params, new_states_flat)\\n new_state = OptimizerState(step + 1, new_param_states)\\n\\n return new_params, new_state\",\n \"def test_multiple_update_parameters(model):\\n train_inputs = torch.tensor([[1., 2., 3.]])\\n\\n train_loss_1 = 0.5 * (model(train_inputs) ** 2)\\n params_1 = gradient_update_parameters(model,\\n train_loss_1,\\n params=None,\\n step_size=1.,\\n first_order=False)\\n\\n assert train_loss_1.item() == 264.5\\n assert list(params_1.keys()) == ['weight']\\n assert torch.all(params_1['weight'].data == torch.tensor([[-21., -43., -64.]]))\\n\\n \\\"\\\"\\\"\\n The new loss function is defined as\\n g(w') = 0.5 * (1 * w'_1 + 2 * w'_2 + 3 * w'_3) ** 2\\n with w' = [-21, -43, -64].\\n\\n The gradient of g with respect to w' is:\\n dg / dw'_1 = 1 * (1 * w'_1 + 2 * w'_2 + 3 * w'_3) = -299\\n dg / dw'_2 = 2 * (1 * w'_1 + 2 * w'_2 + 3 * w'_3) = -598\\n dg / dw'_3 = 3 * (1 * w'_1 + 2 * w'_2 + 3 * w'_3) = -897\\n\\n The updated parameters are given by:\\n w''_1 = w'_1 - 1. * dg / dw'_1 = -21 - 1. * -299 = 278\\n w''_2 = w'_2 - 1. * dg / dw'_2 = -43 - 1. * -598 = 555\\n w''_3 = w'_3 - 1. * dg / dw'_3 = -64 - 1. * -897 = 833\\n \\\"\\\"\\\"\\n train_loss_2 = 0.5 * (model(train_inputs, params=params_1) ** 2)\\n params_2 = gradient_update_parameters(model,\\n train_loss_2,\\n params=params_1,\\n step_size=1.,\\n first_order=False)\\n\\n assert train_loss_2.item() == 44700.5\\n assert list(params_2.keys()) == ['weight']\\n assert torch.all(params_2['weight'].data == torch.tensor([[278., 555., 833.]]))\\n\\n \\\"\\\"\\\"\\n The new loss function is defined as\\n h(w'') = 0.5 * (1 * w''_1 + 2 * w''_2 + 3 * w''_3) ** 2\\n with w'' = [278, 555, 833].\\n\\n The gradient of h with respect to w'' is:\\n dh / dw''_1 = 1 * (1 * w''_1 + 2 * w''_2 + 3 * w''_3) = 3887\\n dh / dw''_2 = 2 * (1 * w''_1 + 2 * w''_2 + 3 * w''_3) = 7774\\n dh / dw''_3 = 3 * (1 * w''_1 + 2 * w''_2 + 3 * w''_3) = 11661\\n\\n The updated parameters are given by:\\n w'''_1 = w''_1 - 1. * dh / dw''_1 = 278 - 1. * 3887 = -3609\\n w'''_2 = w''_2 - 1. * dh / dw''_2 = 555 - 1. * 7774 = -7219\\n w'''_3 = w''_3 - 1. * dh / dw''_3 = 833 - 1. * 11661 = -10828\\n \\\"\\\"\\\"\\n train_loss_3 = 0.5 * (model(train_inputs, params=params_2) ** 2)\\n params_3 = gradient_update_parameters(model,\\n train_loss_3,\\n params=params_2,\\n step_size=1.,\\n first_order=False)\\n\\n assert train_loss_3.item() == 7554384.5\\n assert list(params_3.keys()) == ['weight']\\n assert torch.all(params_3['weight'].data == torch.tensor([[-3609., -7219., -10828.]]))\\n\\n \\\"\\\"\\\"\\n The new loss function is defined as\\n l(w) = 4 * w'''_1 + 5 * w'''_2 + 6 * w'''_3\\n with w = [2, 3, 5] and w''' = [-3609, -7219, -10828].\\n\\n The gradient of l with respect to w is:\\n dl / dw_1 = 4 * dw'''_1 / dw_1 + 5 * dw'''_2 / dw_1 + 6 * dw'''_3 / dw_1\\n = ... = -5020\\n dl / dw_2 = 4 * dw'''_1 / dw_2 + 5 * dw'''_2 / dw_2 + 6 * dw'''_3 / dw_2\\n = ... = -10043\\n dl / dw_3 = 4 * dw'''_1 / dw_3 + 5 * dw'''_2 / dw_3 + 6 * dw'''_3 / dw_3\\n = ... = -15066\\n \\\"\\\"\\\"\\n test_inputs = torch.tensor([[4., 5., 6.]])\\n test_loss = model(test_inputs, params=params_3)\\n grads = torch.autograd.grad(test_loss, model.parameters())\\n\\n assert test_loss.item() == -115499.\\n assert len(grads) == 1\\n assert torch.all(grads[0].data == torch.tensor([[-5020., -10043., -15066.]]))\",\n \"def optimize(layer: Layer, learning_rate: float) -> None:\\n layer._weights -= learning_rate * layer._dw\\n layer._bias -= learning_rate * layer._db\",\n \"def check_layer_gradient(layer, x, delta=1e-5, tol=1e-4):\\n output = layer.forward(x)\\n np.random.seed(10)\\n #output_weight = np.random.randn(*output.shape)\\n output_weight = np.ones_like(output)\\n #print('output_weight',output_weight)\\n\\n def helper_func(x):\\n output = layer.forward(x)\\n loss = np.sum(output * output_weight)\\n #print('loss',loss)\\n d_out = np.ones_like(output) * output_weight\\n grad = layer.backward(d_out)\\n return loss, grad\\n\\n return check_gradient(helper_func, x, delta, tol)\",\n \"def Train(self, input_data: list, target_output_data: list, learning_rate: float) -> float:\\n ComputeGradients(input_data, target_output_data)\\n self.hidden_layer_biases -= learning_rate * self.hidden_biases_gradient\\n self.output_layer_biases -= learning_rate * self.output_biases_gradient\\n self.input_to_hidden_weights -= learning_rate * self.input_to_hidden_weights_gradient\\n self.hidden_to_output_weights -= learning_rate * self.hidden_to_output_weights_gradient\",\n \"def gradient(self, theta):\\n pass\",\n \"def gradient(self, theta):\\n pass\",\n \"def _apply_gradient_decay():\\n parameter_not_included = ['seg_emb', 'query_key_bias', 'query_emb_bias', 'query_seg_bias']\\n num_layers = len(xlnet_base._net.transformer_cells)\\n for (i, layer_parameters) in enumerate(xlnet_base._net.transformer_cells):\\n layer_params = layer_parameters.collect_params()\\n for key, value in layer_params.items():\\n skip = False\\n for pn in parameter_not_included:\\n if pn in key:\\n skip = True\\n if skip:\\n continue\\n if value.grad_req != 'null':\\n for arr in value.list_grad():\\n arr *= args.layerwise_decay**(num_layers - i - 1)\",\n \"def update_parameters(parameters, grads, learning_rate=0.01):\\n # Retrieve each parameter from the dictionary \\\"parameters\\\"\\n ### START CODE HERE ### (≈ 4 lines of code)\\n W1 = parameters[\\\"W1\\\"]\\n b1 = parameters[\\\"b1\\\"]\\n W2 = parameters[\\\"W2\\\"]\\n b2 = parameters[\\\"b2\\\"]\\n W3 = parameters[\\\"W3\\\"]\\n b3 = parameters[\\\"b3\\\"]\\n ### END CODE HERE ###\\n\\n # Retrieve each gradient from the dictionary \\\"grads\\\"\\n ### START CODE HERE ### (≈ 4 lines of code)\\n dW1 = grads[\\\"dW1\\\"]\\n db1 = grads[\\\"db1\\\"]\\n dW2 = grads[\\\"dW2\\\"]\\n db2 = grads[\\\"db2\\\"]\\n dW3 = grads[\\\"dW3\\\"]\\n db3 = grads[\\\"db3\\\"]\\n ## END CODE HERE ###\\n\\n # Update rule for each parameter\\n ### START CODE HERE ### (≈ 4 lines of code)\\n W1 = W1 - (learning_rate * dW1)\\n b1 = b1 - (learning_rate * db1)\\n W2 = W2 - (learning_rate * dW2)\\n b2 = b2 - (learning_rate * db2)\\n W3 = W3 - (learning_rate * dW3)\\n b3 = b3 - (learning_rate * db3)\\n ### END CODE HERE ###\\n\\n parameters = {\\\"W1\\\": W1,\\n \\\"b1\\\": b1,\\n \\\"W2\\\": W2,\\n \\\"b2\\\": b2,\\n \\\"W3\\\": W3,\\n \\\"b3\\\": b3}\\n\\n return parameters\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7662058","0.756946","0.7527331","0.73841107","0.7367387","0.72501403","0.7238229","0.7204643","0.71658003","0.7152769","0.71068096","0.7099971","0.70949143","0.7080805","0.70684385","0.70570195","0.70487124","0.70160997","0.6927363","0.6914079","0.6877797","0.68578047","0.6823812","0.6804104","0.67936313","0.6781396","0.6769178","0.67667955","0.6754731","0.67514163","0.6747371","0.6743608","0.6731942","0.67317116","0.6720342","0.6708572","0.6708139","0.6700571","0.66995883","0.66798073","0.6653741","0.6628245","0.66217494","0.6606312","0.65789944","0.65749747","0.65654457","0.65650773","0.6543727","0.6531122","0.65287703","0.64963305","0.6481387","0.6475163","0.6463007","0.64595205","0.64595205","0.64498276","0.6442753","0.6442469","0.64227074","0.64206254","0.6418873","0.6408028","0.6405719","0.6405719","0.64049053","0.64043987","0.6393899","0.638692","0.63577986","0.63573474","0.63541615","0.6346112","0.63410544","0.6334624","0.6329194","0.6311223","0.6299517","0.6294702","0.62941444","0.6290862","0.62794685","0.6272816","0.626336","0.62611437","0.6256201","0.62536","0.62495863","0.62472993","0.6240971","0.62389904","0.62362117","0.62350714","0.622937","0.6229018","0.62168574","0.62168574","0.6215925","0.62038106"],"string":"[\n \"0.7662058\",\n \"0.756946\",\n \"0.7527331\",\n \"0.73841107\",\n \"0.7367387\",\n \"0.72501403\",\n \"0.7238229\",\n \"0.7204643\",\n \"0.71658003\",\n \"0.7152769\",\n \"0.71068096\",\n \"0.7099971\",\n \"0.70949143\",\n \"0.7080805\",\n \"0.70684385\",\n \"0.70570195\",\n \"0.70487124\",\n \"0.70160997\",\n \"0.6927363\",\n \"0.6914079\",\n \"0.6877797\",\n \"0.68578047\",\n \"0.6823812\",\n \"0.6804104\",\n \"0.67936313\",\n \"0.6781396\",\n \"0.6769178\",\n \"0.67667955\",\n \"0.6754731\",\n \"0.67514163\",\n \"0.6747371\",\n \"0.6743608\",\n \"0.6731942\",\n \"0.67317116\",\n \"0.6720342\",\n \"0.6708572\",\n \"0.6708139\",\n \"0.6700571\",\n \"0.66995883\",\n \"0.66798073\",\n \"0.6653741\",\n \"0.6628245\",\n \"0.66217494\",\n \"0.6606312\",\n \"0.65789944\",\n \"0.65749747\",\n \"0.65654457\",\n \"0.65650773\",\n \"0.6543727\",\n \"0.6531122\",\n \"0.65287703\",\n \"0.64963305\",\n \"0.6481387\",\n \"0.6475163\",\n \"0.6463007\",\n \"0.64595205\",\n \"0.64595205\",\n \"0.64498276\",\n \"0.6442753\",\n \"0.6442469\",\n \"0.64227074\",\n \"0.64206254\",\n \"0.6418873\",\n \"0.6408028\",\n \"0.6405719\",\n \"0.6405719\",\n \"0.64049053\",\n \"0.64043987\",\n \"0.6393899\",\n \"0.638692\",\n \"0.63577986\",\n \"0.63573474\",\n \"0.63541615\",\n \"0.6346112\",\n \"0.63410544\",\n \"0.6334624\",\n \"0.6329194\",\n \"0.6311223\",\n \"0.6299517\",\n \"0.6294702\",\n \"0.62941444\",\n \"0.6290862\",\n \"0.62794685\",\n \"0.6272816\",\n \"0.626336\",\n \"0.62611437\",\n \"0.6256201\",\n \"0.62536\",\n \"0.62495863\",\n \"0.62472993\",\n \"0.6240971\",\n \"0.62389904\",\n \"0.62362117\",\n \"0.62350714\",\n \"0.622937\",\n \"0.6229018\",\n \"0.62168574\",\n \"0.62168574\",\n \"0.6215925\",\n \"0.62038106\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6196009"},"document_rank":{"kind":"string","value":"100"}}},{"rowIdx":12199,"cells":{"query":{"kind":"string","value":"Save input to the function, and output f(x)"},"document":{"kind":"string","value":"def output(self, inputs):\n\n # if max pool we need to save the indices for backproping\n if self.max_pool:\n self.indices = self.f(inputs)\n out = np.take(inputs, self.indices)\n else:\n out = self.f(inputs)\n\n # save input\n self.current_input = inputs\n\n return out"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def saveall(self, f):\n if not self.enabled:\n return f\n @wraps(f)\n def wrapper(*args, **kwargs):\n func_name = f.__name__\n\n # save parameters\n params = dict(zip(f.__code__.co_varnames, args))\n params.update(kwargs)\n\n for param, v in params.items():\n self.save(v, f\"{func_name}.{param}\")\n\n # save random state\n randomstate = [random.getstate(), np.random.get_state(), torch.random.get_rng_state()]\n try:\n randomstate.append(torch.cuda.get_rng_state())\n torch.backends.cudnn.deterministic = True\n except:\n pass\n save(randomstate, f\"{func_name}.randomstates\")\n\n # run\n out = f(*args, **kwargs)\n\n # save return values\n out = listify(out)\n for i, ret in enumerate(out):\n self.save(ret, f\"results/{func_name}.{i}\")\n\n # revert from list to single return\n out = unlistify(out)\n return out\n\n return wrapper","def data_out(f):\n @functools.wraps(f)\n def dec(*args, **kwargs):\n rtn, dout = f(*args, **kwargs)\n _stash_set_data(dout)\n return rtn\n return dec","def f(x):\n return x**2","def _feval( # noqa\r\n self,\r\n func_name,\r\n func_args=(),\r\n dname=\"\",\r\n nout=0,\r\n timeout=None,\r\n stream_handler=None,\r\n store_as=\"\",\r\n plot_dir=None,\r\n ):\r\n engine = self._engine\r\n if engine is None:\r\n msg = \"Session is closed\"\r\n raise Oct2PyError(msg)\r\n\r\n # Set up our mat file paths.\r\n out_file = osp.join(self.temp_dir, \"writer.mat\")\r\n out_file = out_file.replace(osp.sep, \"/\")\r\n in_file = osp.join(self.temp_dir, \"reader.mat\")\r\n in_file = in_file.replace(osp.sep, \"/\")\r\n\r\n func_args = list(func_args)\r\n ref_indices = []\r\n for i, value in enumerate(func_args):\r\n if isinstance(value, OctavePtr):\r\n ref_indices.append(i + 1)\r\n func_args[i] = value.address\r\n ref_arr = np.array(ref_indices)\r\n\r\n # Save the request data to the output file.\r\n req = dict(\r\n func_name=func_name,\r\n func_args=tuple(func_args),\r\n dname=dname or \"\",\r\n nout=nout,\r\n store_as=store_as or \"\",\r\n ref_indices=ref_arr,\r\n )\r\n\r\n write_file(req, out_file, oned_as=self._oned_as, convert_to_float=self.convert_to_float)\r\n\r\n # Set up the engine and evaluate the `_pyeval()` function.\r\n engine.line_handler = stream_handler or self.logger.info\r\n if timeout is None:\r\n timeout = self.timeout\r\n\r\n try:\r\n engine.eval(f'_pyeval(\"{out_file}\", \"{in_file}\");', timeout=timeout)\r\n except KeyboardInterrupt:\r\n stream_handler(engine.repl.interrupt())\r\n raise\r\n except TIMEOUT:\r\n stream_handler(engine.repl.interrupt())\r\n msg = \"Timed out, interrupting\"\r\n raise Oct2PyError(msg) from None\r\n except EOF:\r\n if not self._engine:\r\n return\r\n stream_handler(engine.repl.child.before)\r\n self.restart()\r\n msg = \"Session died, restarting\"\r\n raise Oct2PyError(msg) from None\r\n\r\n # Read in the output.\r\n resp = read_file(in_file, self)\r\n if resp[\"err\"]:\r\n msg = self._parse_error(resp[\"err\"])\r\n raise Oct2PyError(msg)\r\n\r\n result = resp[\"result\"].ravel().tolist()\r\n if isinstance(result, list) and len(result) == 1:\r\n result = result[0]\r\n\r\n # Check for sentinel value.\r\n if (\r\n isinstance(result, Cell)\r\n and result.size == 1\r\n and isinstance(result[0], str)\r\n and result[0] == \"__no_value__\"\r\n ):\r\n result = None\r\n\r\n if plot_dir:\r\n engine.make_figures(plot_dir)\r\n\r\n return result","def checkpoint(func, inputs, params, flag):\n return func(*inputs)","def run(function, inp):\r\n sys.argv = inp.split() # input by command line parameters\r\n default_stdin, default_stdout, mystdout = set_stdio(inp) # input by input()\r\n function()\r\n reset_stdio(default_stdin, default_stdout)\r\n out = mystdout.getvalue()[:-1] # ignore the final newline\r\n return out","def f():","def f():","def fun(self, x):\n\n raise NotImplementedError","def data_io(f):\n @functools.wraps(f)\n def dec(*args, **kwargs):\n din = _stash_get_data()\n rtn, dout = f(din, *args, **kwargs)\n _stash_set_data(dout)\n return rtn\n return dec","def orig_function(inputs, outputs, mode=None, accept_inplace=False,\r\n name=None, profile=None, on_unused_input=None):\r\n\r\n # Every element of the input list will be upgraded to an `In` instance if\r\n # necessary, using the rules implemented by the `convert_function_input`\r\n # function.\r\n\r\n # Similarly, every element of the output list will be upgraded to an `Out`\r\n # instance if necessary:\r\n\r\n t1 = time.time()\r\n mode = theano.compile.mode.get_mode(mode)\r\n\r\n inputs = map(convert_function_input, inputs)\r\n if outputs is not None:\r\n if isinstance(outputs, (list, tuple)):\r\n outputs = map(FunctionMaker.wrap_out, outputs)\r\n else:\r\n outputs = FunctionMaker.wrap_out(outputs)\r\n\r\n defaults = [getattr(input, 'value', None) for input in inputs]\r\n\r\n if isinstance(mode, (list, tuple)): # \"mode comparison\" semantics\r\n raise Exception(\"We do not support the passing of multiple modes\")\r\n else:\r\n Maker = getattr(mode, 'function_maker', FunctionMaker)\r\n fn = Maker(inputs,\r\n outputs,\r\n mode,\r\n accept_inplace=accept_inplace,\r\n profile=profile,\r\n on_unused_input=on_unused_input).create(\r\n defaults)\r\n\r\n t2 = time.time()\r\n if profile:\r\n profile.compile_time += t2 - t1\r\n\r\n fn.name = name\r\n fn.maker.fgraph.name = name\r\n return fn","def fn():","def output_func(x):\n return np.cos(x) + 0.5*x","def my_original(x):\n return x + x * x","def evaluate(self, x):\n return self.function(x)","def f(x):\n raise NotImplementedError","def _generate_and_save_function(self, filename, expression, parameters):\n\n # check for / create the save folder for this expression\n folder = self.config_folder + '/' + filename\n abr_control.utils.os_utils.makedirs(folder)\n\n if self.use_cython is True:\n # binaries saved by specifying tempdir parameter\n function = autowrap(expression, backend=\"cython\",\n args=parameters, tempdir=folder)\n function = sp.lambdify(parameters, expression, \"numpy\")\n\n return function","def f(x):\n return x * np.sin(x)","def f(x):\n return x * np.sin(x)","def f(x):\n return x * np.sin(x)","def f(x):\n return x * np.sin(x)","def save_funcs(self, *args):\r\n for func in args:\r\n # save all of the functions input\r\n self.outfile.write(func, self.t)","def hook_fn(self, module, input, output):\n self.output = output","def hook_fn(self, module, input, output):\n self.output = output","def f(x):\r\n return x * np.sin(x)","def show_func(self, x):\n\n if (self._flag == 1):\n g = self.modelfun(x, *self._gf)\n elif (self._flag == 2):\n g = self.modelfun1(x, *self._gf)\n elif ((self._flag == 0) & (self._load != '0')):\n pass\n else:\n # pass\n sys.exit(\"Wrong flag in do_fit\")\n\n return g","def write_function(output_file, function_name, n_vars, curr_function):\n curr_function[0] = function_name\n output_file.write(\"(\" + function_name + \")\" + \"\\n\")\n for i in range(int(n_vars)):\n write_push_constant(output_file, \"0\")","def func():","def transform(self, X):\n X = self.function(X)\n return X","def save_q_functions(self, q_value, iteration):\n path = os.path.join(self.predicted_q_func_dir,\n '%06d.%s.qfunc' % (iteration, 'shovel'))\n np.save(path, q_value)","def convert_function_input(input):\r\n if isinstance(input, (SymbolicInput, SymbolicInputKit)):\r\n return input\r\n elif isinstance(input, gof.Constant):\r\n raise TypeError('A Constant instance is not a legal function input',\r\n input)\r\n elif isinstance(input, gof.Variable):\r\n return In(input)\r\n elif isinstance(input, (list, tuple)):\r\n orig = input\r\n if not input:\r\n raise TypeError(\"Nonsensical input specification: %s\" % input)\r\n if isinstance(input[0], basestring):\r\n name = input[0]\r\n input = input[1:]\r\n else:\r\n name = None\r\n if isinstance(input[0], (list, tuple)):\r\n if len(input[0]) != 2 or len(input) != 2:\r\n raise TypeError(\"Invalid input syntax: %s (check \"\r\n \"documentation or use an In instance)\" % orig)\r\n (variable, update), value = input\r\n elif isinstance(input[0], gof.Variable):\r\n if len(input) == 1:\r\n variable, update, value = input[0], None, None\r\n elif len(input) == 2:\r\n (variable, value), update = input, None\r\n else:\r\n raise TypeError(\"Invalid input syntax: %s (check \"\r\n \"documentation or use an In instance)\" % orig)\r\n elif isinstance(input[0], (SymbolicInput, SymbolicInputKit)):\r\n if len(input) == 1:\r\n return input[0]\r\n elif len(input) == 2:\r\n input, value = input\r\n if name is not None:\r\n input.name = name\r\n input.value = value\r\n return input\r\n else:\r\n raise TypeError(\"The input specification is not valid: %s\" % input)\r\n\r\n if not isinstance(variable, gof.Variable):\r\n raise TypeError(\"Unknown input type: %s, expected Variable \"\r\n \"instance\" % type(variable), variable)\r\n if update is not None and not isinstance(update, gof.Variable):\r\n raise TypeError(\"Unknown update type: %s, expected Variable \"\r\n \"instance\" % type(update), update)\r\n if (value is not None and\r\n isinstance(value, (gof.Variable, SymbolicInput))):\r\n raise TypeError(\"The value for input %s should not be a Variable \"\r\n \"or SymbolicInput instance (got: %s)\" %\r\n (variable, value))\r\n\r\n return In(variable, name=name, value=value, update=update)\r\n else:\r\n raise TypeError(\"Unknown input type: %s, expected Variable instance\" %\r\n type(input), input)","def data_in(f):\n # Cannot use @functools.wraps(f)\n def dec(ain, args, **kwargs):\n din = _stash_get_data()\n rtn = f(din, ain, args, **kwargs)\n return rtn\n return dec","def f(x):\r\n\treturn np.sin(x)","def evaluate_random_function(f, x, y):\n\n # your code goes here","def wrap_function(self, fn):\n\n @functools.wraps(fn)\n def wrapper(*args):\n fname = fn.__name__\n if len(args) > len(self._insigs):\n raise TypeError(\n (\"{}() takes {} positional arguments but {} were \" \"given\").format(\n fname, len(self._insigs), len(args)\n )\n )\n try:\n newargs = [self._input(self._insigs[i], arg) for i, arg in enumerate(args)]\n except Exception as e:\n message = \"{}: converting input arguments for function '{}\".format(e, fname)\n raise type(e)(message) from None\n try:\n result = fn(*newargs)\n except Exception as e:\n message = \"{}: raised by {}()\".format(e, fname)\n raise type(e)(message) from e\n try:\n return self._output(self._outsig, result)\n except Exception as e:\n raise type(e)(\"{} for output of {}()\".format(e, fname)) from None\n\n return wrapper","def my_fn(x):\n return 0.4*(0.5*(np.exp(x*4) - np.exp(-x*4)) - 8*x + 0.3*x**2 - 2*x**3 + 0.8)","def __call__(self, x, debug = False):\n x = {'output': [x]}\n return x","def steffensen ( fun , x , fx = None , args = () ) :\n \n if fx is None : fx = float ( fun ( x , *args ) ) ## reuse if already calculated\n if fx : \n gx = ( fun ( x + fx , *args ) - fx ) / fx\n if gx : return x - fx / gx","def forward(self, x):\n x = self.main(x)\n return x","def forward(self, x):\n x = self.main(x)\n return x","def _serialize_function(self, fn_path, parsl_fn, parsl_fn_args, parsl_fn_kwargs):\n\n # Either build a dictionary with the source of the function, or pickle\n # the function directly:\n if self.source:\n function_info = {\"source code\": inspect.getsource(parsl_fn),\n \"name\": parsl_fn.__name__,\n \"args\": parsl_fn_args,\n \"kwargs\": parsl_fn_kwargs}\n else:\n function_info = {\"byte code\": pack_apply_message(parsl_fn, parsl_fn_args, parsl_fn_kwargs,\n buffer_threshold=1024 * 1024,\n item_threshold=1024)}\n with open(fn_path, \"wb\") as f_out:\n pickle.dump(function_info, f_out)","def apply(cls, x):\n return x","def save_function_to_disk(self):\n write_to_disk(\n to_pickle(self._fn), os.path.join(self.location, FNCT_NM)\n )","def f1(x):\n return x**3 - 2*x + 2","def forward(self, x):\n\n out = self.model(x)\n\n return out","def forward(self, x):\n out = self.regress(x)\n \n return out","def store_output(output):\n\n pass","def exercise_4(inputs): # DO NOT CHANGE THIS LINE\n output = inputs\n\n return output # DO NOT CHANGE THIS LINE","def modify_stored_fn():\r\n fn = get_check_fn()\r\n store_fn(fn)","def save_at_specified_path_dec(f, full_path):\n def decorated_f(*args, **kwargs):\n x = f(*args, **kwargs)\n f.print_handler_f(x, full_path)\n return x\n\n return decorated_f","def f(x, a, b):\n return f_raw(x, a, b)","def call(self, input, func, output):\n # we want to run the same splitting function on the lineage array as well.\n # so we do want to reduce randomness? -> at the same time, it should work for any randomness\n outputs = func(input)\n self.data_split = copy.deepcopy(outputs) # we don't want to do this for every function or we would save too many copies?\n return outputs","def process_input_in_python(inputf, outputf):\n value=-1\n with open(inputf, 'r') as f:\n value = int(f.readline().strip())\n print(outputf)\n time.sleep(5)\n with open(outputf, 'w') as f:\n f.write(str(value**2))","def save(self, output, data):","def __call__(self, _x: np.ndarray) -> np.ndarray:\n return self.function(_x)","def hook_output(self, name: str, func: Callable[[\"self.value_type\"], None]):\n self.write_hooks[name] = func","def transform(self, f):\n\n return f(self)","def forward(self, x):\n return x","def save(self, x):\n self.print_handler_f(x, x.get_full_path())","def f(self,x,*params):\n raise NotImplementedError","def save_object(o, fn):\n return dump_object(o, fn)","def eval_fn(dummy_state, batch):\n model.forward_pass(batch, training=False)\n return dummy_state","def k1(self, f, t, u, usereverse=False):\n\n if usereverse:\n output, storagez, storagew = f(t, u)\n\n self.storagez.append(storagez)\n self.storagew.append(storagew)\n\n return output\n else:\n return f(t, u)","def _f(self, x: torch.Tensor, params: Scenario):\n # Extract batch size and set up a tensor for holding the result\n batch_size = x.shape[0]\n\n # memoize the tensor\n if not hasattr(self, \"f_tensor\"):\n self.f_tensor = torch.zeros(self.n_dims, 1)\n\n return self.f_tensor.expand(batch_size, -1, -1).type_as(x)","def f(self, x, theta):\n raise NotImplementedError(\n \"f has not been implemented for this Experiment\")","def f(x):\n\treturn np.sin(x / 5.0) * np.exp(x / 10.0) + 5 * np.exp(-x / 2.0)","def transf(self,f):\r\n raise NotImplementedError","def out(self, inputs):","def _save_input(self, mod, i):\n if mod.training:\n self.state[mod][\"x\"] = i[0]","def monitor(f, input='print', output='print'):\n if not input:\n input = lambda v: None\n elif input == 'print':\n incount = [0]\n def input(value):\n args, kwargs = value\n print(\"in %s %r %r\" % (incount[0], args, kwargs))\n incount[0] += 1\n if not output:\n output = lambda v: None\n elif output == 'print':\n outcount = [0]\n def output(value):\n print(\"out %s %r\" % (outcount[0], value))\n outcount[0] += 1\n def f_monitored(*args, **kwargs):\n input((args, kwargs))\n v = f(*args, **kwargs)\n output(v)\n return v\n return f_monitored","def sumfunc(x):\n\n x = x + 1\n return x","def func(x, f, fp):\n\n return np.sqrt((1+fp(x)**2) / (2 * g * f(x)))","def test_dfunction_saveable(self):\n \n wa = FrequencyAxis(0.0, 1000, 0.1)\n \n fw = numpy.exp(-wa.data)\n \n fce = DFunction(wa,fw)\n \n #fce.plot()\n\n #with h5py.File(\"test_file_1\",driver=\"core\", \n # backing_store=False) as f:\n with tempfile.TemporaryFile() as f:\n \n fce.save(f, test=True)\n \n fce2 = DFunction()\n fce2 = fce2.load(f, test=True)\n \n #fce2.plot()\n \n numpy.testing.assert_array_equal(fce.data, fce2.data)","def fn(x):\n\n # coefficients\n A = 728.0\n B = 0.317\n C = 0.486\n D = -8.99 * 1.6\n\n # function\n fx = - D / x**2 - A / B * math.exp(- x / B) + 6 * C / x**7\n\n return fx","def __call__(self, x):\n return self.y(x)","def __init__(self, f, save_directory=None, function_name=None, version=None, input_name=None):\n self.f = f \n self.save_directory = save_directory\n self.function_name = function_name if function_name else f.__name__\n self.version = version if version else ''\n self.input_name = input_name\n \n if save_directory is None:\n self.save_directory = self.save_directory_default\n \n if not exists(self.save_directory):\n makedirs(self.save_directory)\n \n suf_len = len(self._suffix)\n self.cache = [f[:-suf_len] for f in listdir(self.save_directory) if isfile(f) and f[-suf_len:] == self._suffix]","def doFunc(self):\n val = self.func(self.value())\n if val:\n self.setValue(val)","def f(self):\n return self._f","def apply_to_file(f):\n @wraps(f)\n def f_in_file(fname):\n with open(fname, 'rb') as inf:\n data = inf.read()\n data = f(data)\n with open(fname, 'wb+') as outf:\n outf.write(data)\n\n return f_in_file","def __call__(self):\n loads = self._load()\n log.newline(lines=2)\n results = self._func(*loads)\n log.newline(lines=2)\n self._save(results)","def forward(self, x, **kwargs):\n\n\t\toutput = self.lin1(x)\n\t\toutput = self.lin2(output)\n\t\toutput = self.lin3(output)\n\t\toutput = self.lin_out(output)\n\n\t\treturn output","def __call__(self, a):\n self.x = a\n return self.forward(a)","def with_save(func):\n @wraps(func)\n def saving_func(*args, **kwargs):\n save = kwargs.pop('save', False)\n ret = func(*args, **kwargs)\n if save:\n ret.save()\n return ret\n\n return saving_func","def f(x, y=1):\r\n return x ** 2 + y","def eval_func(f, x, y, t):\n if f[0] == 'x':\n return x\n if f[0] == 'y':\n return y\n if f[0] == 't':\n return y-t\n if f[0] == 'prod':\n return eval_func(f[1],x,y,t)*eval_func(f[2],x,y,t)\n if f[0] == 'avg':\n return (eval_func(f[1],x,y,t)+eval_func(f[2],x,y,t))/2.0\n if f[0] == 'cos_pi':\n return math.cos(math.pi*eval_func(f[1],x,y,t))\n if f[0] == 'sin_pi':\n return math.sin(math.pi*eval_func(f[1],x,y,t))\n if f[0] == 'subtract':\n return eval_func(f[1],x,y,t)-eval_func(f[2],x,y,t)\n if f[0] == 'add':\n return eval_func(f[1],x,y,t)+eval_func(f[2],x,y,t)","def save_functions(self, a, func_name):\n logging.debug(\"in function save\")\n if self.need_func_start and (self.cur_char != self.func_start):\n pass\n else:\n logging.debug(\"current char \" + self.cur_char)\n self.produce(\"func_name\", func_name)\n self.functions.append(func_name)\n self.begin('')","def __call__(self, f):\r\n return self.apply(f, None)","def main(fn_input, fn_output):\n # read file\n inter = Interpolator()\n inter.read_file(fn_input)\n inter.write_interpolated(fn_output)","def savefile(self, x, o):\n self.sep('save')\n with open(o, 'w') as f:\n f.write(x)\n sys.exit('all done (%s bytes).. saved as %s' % (len(x), o))","def f(x):\n return (2.0*math.sin(10.0*x+1.0)+1.0)","def f(x, y=1):\n return x ** 2 + y","def forward(self, x):\n x = self.arch(x)\n x = self.swish(x)\n x_out = self.arch._fcOut(x)\n return x_out","def wrapper_func(input):\n assert len(input.shape) == 1\n\n params[i].data = torch.Tensor(input.reshape((shape)))\n\n if(len(keywords.keys()) > 1):\n outputVar = func(*params, **keywords)\n else:\n outputVar = func(*params)\n\n output = outputVar.data.numpy()\n\n return output","def evaluate():\n\t\t\t\tif not hasattr(evaluate, 'value'):\n\t\t\t\t\tevaluate.value = func()\n\t\t\t\treturn evaluate.value","def __call__(self, x, **kwargs):\n del kwargs\n for f in self._functions:\n x = f(x)\n return x","def transform(self, x):","def _fit_function(self,x,a,b):\n return b + a*x","def f2(x):\n return x**2 + 2 * x + 1","def F(x):\n return math.exp(-0.5 * (x ** 2))","def f(x, y=0, z=0):\r\n return x ** 2 + y + z","def __call__ (self, x) :\n fx = fixed_q_exp (x)\n result = fx (self)\n return result"],"string":"[\n \"def saveall(self, f):\\n if not self.enabled:\\n return f\\n @wraps(f)\\n def wrapper(*args, **kwargs):\\n func_name = f.__name__\\n\\n # save parameters\\n params = dict(zip(f.__code__.co_varnames, args))\\n params.update(kwargs)\\n\\n for param, v in params.items():\\n self.save(v, f\\\"{func_name}.{param}\\\")\\n\\n # save random state\\n randomstate = [random.getstate(), np.random.get_state(), torch.random.get_rng_state()]\\n try:\\n randomstate.append(torch.cuda.get_rng_state())\\n torch.backends.cudnn.deterministic = True\\n except:\\n pass\\n save(randomstate, f\\\"{func_name}.randomstates\\\")\\n\\n # run\\n out = f(*args, **kwargs)\\n\\n # save return values\\n out = listify(out)\\n for i, ret in enumerate(out):\\n self.save(ret, f\\\"results/{func_name}.{i}\\\")\\n\\n # revert from list to single return\\n out = unlistify(out)\\n return out\\n\\n return wrapper\",\n \"def data_out(f):\\n @functools.wraps(f)\\n def dec(*args, **kwargs):\\n rtn, dout = f(*args, **kwargs)\\n _stash_set_data(dout)\\n return rtn\\n return dec\",\n \"def f(x):\\n return x**2\",\n \"def _feval( # noqa\\r\\n self,\\r\\n func_name,\\r\\n func_args=(),\\r\\n dname=\\\"\\\",\\r\\n nout=0,\\r\\n timeout=None,\\r\\n stream_handler=None,\\r\\n store_as=\\\"\\\",\\r\\n plot_dir=None,\\r\\n ):\\r\\n engine = self._engine\\r\\n if engine is None:\\r\\n msg = \\\"Session is closed\\\"\\r\\n raise Oct2PyError(msg)\\r\\n\\r\\n # Set up our mat file paths.\\r\\n out_file = osp.join(self.temp_dir, \\\"writer.mat\\\")\\r\\n out_file = out_file.replace(osp.sep, \\\"/\\\")\\r\\n in_file = osp.join(self.temp_dir, \\\"reader.mat\\\")\\r\\n in_file = in_file.replace(osp.sep, \\\"/\\\")\\r\\n\\r\\n func_args = list(func_args)\\r\\n ref_indices = []\\r\\n for i, value in enumerate(func_args):\\r\\n if isinstance(value, OctavePtr):\\r\\n ref_indices.append(i + 1)\\r\\n func_args[i] = value.address\\r\\n ref_arr = np.array(ref_indices)\\r\\n\\r\\n # Save the request data to the output file.\\r\\n req = dict(\\r\\n func_name=func_name,\\r\\n func_args=tuple(func_args),\\r\\n dname=dname or \\\"\\\",\\r\\n nout=nout,\\r\\n store_as=store_as or \\\"\\\",\\r\\n ref_indices=ref_arr,\\r\\n )\\r\\n\\r\\n write_file(req, out_file, oned_as=self._oned_as, convert_to_float=self.convert_to_float)\\r\\n\\r\\n # Set up the engine and evaluate the `_pyeval()` function.\\r\\n engine.line_handler = stream_handler or self.logger.info\\r\\n if timeout is None:\\r\\n timeout = self.timeout\\r\\n\\r\\n try:\\r\\n engine.eval(f'_pyeval(\\\"{out_file}\\\", \\\"{in_file}\\\");', timeout=timeout)\\r\\n except KeyboardInterrupt:\\r\\n stream_handler(engine.repl.interrupt())\\r\\n raise\\r\\n except TIMEOUT:\\r\\n stream_handler(engine.repl.interrupt())\\r\\n msg = \\\"Timed out, interrupting\\\"\\r\\n raise Oct2PyError(msg) from None\\r\\n except EOF:\\r\\n if not self._engine:\\r\\n return\\r\\n stream_handler(engine.repl.child.before)\\r\\n self.restart()\\r\\n msg = \\\"Session died, restarting\\\"\\r\\n raise Oct2PyError(msg) from None\\r\\n\\r\\n # Read in the output.\\r\\n resp = read_file(in_file, self)\\r\\n if resp[\\\"err\\\"]:\\r\\n msg = self._parse_error(resp[\\\"err\\\"])\\r\\n raise Oct2PyError(msg)\\r\\n\\r\\n result = resp[\\\"result\\\"].ravel().tolist()\\r\\n if isinstance(result, list) and len(result) == 1:\\r\\n result = result[0]\\r\\n\\r\\n # Check for sentinel value.\\r\\n if (\\r\\n isinstance(result, Cell)\\r\\n and result.size == 1\\r\\n and isinstance(result[0], str)\\r\\n and result[0] == \\\"__no_value__\\\"\\r\\n ):\\r\\n result = None\\r\\n\\r\\n if plot_dir:\\r\\n engine.make_figures(plot_dir)\\r\\n\\r\\n return result\",\n \"def checkpoint(func, inputs, params, flag):\\n return func(*inputs)\",\n \"def run(function, inp):\\r\\n sys.argv = inp.split() # input by command line parameters\\r\\n default_stdin, default_stdout, mystdout = set_stdio(inp) # input by input()\\r\\n function()\\r\\n reset_stdio(default_stdin, default_stdout)\\r\\n out = mystdout.getvalue()[:-1] # ignore the final newline\\r\\n return out\",\n \"def f():\",\n \"def f():\",\n \"def fun(self, x):\\n\\n raise NotImplementedError\",\n \"def data_io(f):\\n @functools.wraps(f)\\n def dec(*args, **kwargs):\\n din = _stash_get_data()\\n rtn, dout = f(din, *args, **kwargs)\\n _stash_set_data(dout)\\n return rtn\\n return dec\",\n \"def orig_function(inputs, outputs, mode=None, accept_inplace=False,\\r\\n name=None, profile=None, on_unused_input=None):\\r\\n\\r\\n # Every element of the input list will be upgraded to an `In` instance if\\r\\n # necessary, using the rules implemented by the `convert_function_input`\\r\\n # function.\\r\\n\\r\\n # Similarly, every element of the output list will be upgraded to an `Out`\\r\\n # instance if necessary:\\r\\n\\r\\n t1 = time.time()\\r\\n mode = theano.compile.mode.get_mode(mode)\\r\\n\\r\\n inputs = map(convert_function_input, inputs)\\r\\n if outputs is not None:\\r\\n if isinstance(outputs, (list, tuple)):\\r\\n outputs = map(FunctionMaker.wrap_out, outputs)\\r\\n else:\\r\\n outputs = FunctionMaker.wrap_out(outputs)\\r\\n\\r\\n defaults = [getattr(input, 'value', None) for input in inputs]\\r\\n\\r\\n if isinstance(mode, (list, tuple)): # \\\"mode comparison\\\" semantics\\r\\n raise Exception(\\\"We do not support the passing of multiple modes\\\")\\r\\n else:\\r\\n Maker = getattr(mode, 'function_maker', FunctionMaker)\\r\\n fn = Maker(inputs,\\r\\n outputs,\\r\\n mode,\\r\\n accept_inplace=accept_inplace,\\r\\n profile=profile,\\r\\n on_unused_input=on_unused_input).create(\\r\\n defaults)\\r\\n\\r\\n t2 = time.time()\\r\\n if profile:\\r\\n profile.compile_time += t2 - t1\\r\\n\\r\\n fn.name = name\\r\\n fn.maker.fgraph.name = name\\r\\n return fn\",\n \"def fn():\",\n \"def output_func(x):\\n return np.cos(x) + 0.5*x\",\n \"def my_original(x):\\n return x + x * x\",\n \"def evaluate(self, x):\\n return self.function(x)\",\n \"def f(x):\\n raise NotImplementedError\",\n \"def _generate_and_save_function(self, filename, expression, parameters):\\n\\n # check for / create the save folder for this expression\\n folder = self.config_folder + '/' + filename\\n abr_control.utils.os_utils.makedirs(folder)\\n\\n if self.use_cython is True:\\n # binaries saved by specifying tempdir parameter\\n function = autowrap(expression, backend=\\\"cython\\\",\\n args=parameters, tempdir=folder)\\n function = sp.lambdify(parameters, expression, \\\"numpy\\\")\\n\\n return function\",\n \"def f(x):\\n return x * np.sin(x)\",\n \"def f(x):\\n return x * np.sin(x)\",\n \"def f(x):\\n return x * np.sin(x)\",\n \"def f(x):\\n return x * np.sin(x)\",\n \"def save_funcs(self, *args):\\r\\n for func in args:\\r\\n # save all of the functions input\\r\\n self.outfile.write(func, self.t)\",\n \"def hook_fn(self, module, input, output):\\n self.output = output\",\n \"def hook_fn(self, module, input, output):\\n self.output = output\",\n \"def f(x):\\r\\n return x * np.sin(x)\",\n \"def show_func(self, x):\\n\\n if (self._flag == 1):\\n g = self.modelfun(x, *self._gf)\\n elif (self._flag == 2):\\n g = self.modelfun1(x, *self._gf)\\n elif ((self._flag == 0) & (self._load != '0')):\\n pass\\n else:\\n # pass\\n sys.exit(\\\"Wrong flag in do_fit\\\")\\n\\n return g\",\n \"def write_function(output_file, function_name, n_vars, curr_function):\\n curr_function[0] = function_name\\n output_file.write(\\\"(\\\" + function_name + \\\")\\\" + \\\"\\\\n\\\")\\n for i in range(int(n_vars)):\\n write_push_constant(output_file, \\\"0\\\")\",\n \"def func():\",\n \"def transform(self, X):\\n X = self.function(X)\\n return X\",\n \"def save_q_functions(self, q_value, iteration):\\n path = os.path.join(self.predicted_q_func_dir,\\n '%06d.%s.qfunc' % (iteration, 'shovel'))\\n np.save(path, q_value)\",\n \"def convert_function_input(input):\\r\\n if isinstance(input, (SymbolicInput, SymbolicInputKit)):\\r\\n return input\\r\\n elif isinstance(input, gof.Constant):\\r\\n raise TypeError('A Constant instance is not a legal function input',\\r\\n input)\\r\\n elif isinstance(input, gof.Variable):\\r\\n return In(input)\\r\\n elif isinstance(input, (list, tuple)):\\r\\n orig = input\\r\\n if not input:\\r\\n raise TypeError(\\\"Nonsensical input specification: %s\\\" % input)\\r\\n if isinstance(input[0], basestring):\\r\\n name = input[0]\\r\\n input = input[1:]\\r\\n else:\\r\\n name = None\\r\\n if isinstance(input[0], (list, tuple)):\\r\\n if len(input[0]) != 2 or len(input) != 2:\\r\\n raise TypeError(\\\"Invalid input syntax: %s (check \\\"\\r\\n \\\"documentation or use an In instance)\\\" % orig)\\r\\n (variable, update), value = input\\r\\n elif isinstance(input[0], gof.Variable):\\r\\n if len(input) == 1:\\r\\n variable, update, value = input[0], None, None\\r\\n elif len(input) == 2:\\r\\n (variable, value), update = input, None\\r\\n else:\\r\\n raise TypeError(\\\"Invalid input syntax: %s (check \\\"\\r\\n \\\"documentation or use an In instance)\\\" % orig)\\r\\n elif isinstance(input[0], (SymbolicInput, SymbolicInputKit)):\\r\\n if len(input) == 1:\\r\\n return input[0]\\r\\n elif len(input) == 2:\\r\\n input, value = input\\r\\n if name is not None:\\r\\n input.name = name\\r\\n input.value = value\\r\\n return input\\r\\n else:\\r\\n raise TypeError(\\\"The input specification is not valid: %s\\\" % input)\\r\\n\\r\\n if not isinstance(variable, gof.Variable):\\r\\n raise TypeError(\\\"Unknown input type: %s, expected Variable \\\"\\r\\n \\\"instance\\\" % type(variable), variable)\\r\\n if update is not None and not isinstance(update, gof.Variable):\\r\\n raise TypeError(\\\"Unknown update type: %s, expected Variable \\\"\\r\\n \\\"instance\\\" % type(update), update)\\r\\n if (value is not None and\\r\\n isinstance(value, (gof.Variable, SymbolicInput))):\\r\\n raise TypeError(\\\"The value for input %s should not be a Variable \\\"\\r\\n \\\"or SymbolicInput instance (got: %s)\\\" %\\r\\n (variable, value))\\r\\n\\r\\n return In(variable, name=name, value=value, update=update)\\r\\n else:\\r\\n raise TypeError(\\\"Unknown input type: %s, expected Variable instance\\\" %\\r\\n type(input), input)\",\n \"def data_in(f):\\n # Cannot use @functools.wraps(f)\\n def dec(ain, args, **kwargs):\\n din = _stash_get_data()\\n rtn = f(din, ain, args, **kwargs)\\n return rtn\\n return dec\",\n \"def f(x):\\r\\n\\treturn np.sin(x)\",\n \"def evaluate_random_function(f, x, y):\\n\\n # your code goes here\",\n \"def wrap_function(self, fn):\\n\\n @functools.wraps(fn)\\n def wrapper(*args):\\n fname = fn.__name__\\n if len(args) > len(self._insigs):\\n raise TypeError(\\n (\\\"{}() takes {} positional arguments but {} were \\\" \\\"given\\\").format(\\n fname, len(self._insigs), len(args)\\n )\\n )\\n try:\\n newargs = [self._input(self._insigs[i], arg) for i, arg in enumerate(args)]\\n except Exception as e:\\n message = \\\"{}: converting input arguments for function '{}\\\".format(e, fname)\\n raise type(e)(message) from None\\n try:\\n result = fn(*newargs)\\n except Exception as e:\\n message = \\\"{}: raised by {}()\\\".format(e, fname)\\n raise type(e)(message) from e\\n try:\\n return self._output(self._outsig, result)\\n except Exception as e:\\n raise type(e)(\\\"{} for output of {}()\\\".format(e, fname)) from None\\n\\n return wrapper\",\n \"def my_fn(x):\\n return 0.4*(0.5*(np.exp(x*4) - np.exp(-x*4)) - 8*x + 0.3*x**2 - 2*x**3 + 0.8)\",\n \"def __call__(self, x, debug = False):\\n x = {'output': [x]}\\n return x\",\n \"def steffensen ( fun , x , fx = None , args = () ) :\\n \\n if fx is None : fx = float ( fun ( x , *args ) ) ## reuse if already calculated\\n if fx : \\n gx = ( fun ( x + fx , *args ) - fx ) / fx\\n if gx : return x - fx / gx\",\n \"def forward(self, x):\\n x = self.main(x)\\n return x\",\n \"def forward(self, x):\\n x = self.main(x)\\n return x\",\n \"def _serialize_function(self, fn_path, parsl_fn, parsl_fn_args, parsl_fn_kwargs):\\n\\n # Either build a dictionary with the source of the function, or pickle\\n # the function directly:\\n if self.source:\\n function_info = {\\\"source code\\\": inspect.getsource(parsl_fn),\\n \\\"name\\\": parsl_fn.__name__,\\n \\\"args\\\": parsl_fn_args,\\n \\\"kwargs\\\": parsl_fn_kwargs}\\n else:\\n function_info = {\\\"byte code\\\": pack_apply_message(parsl_fn, parsl_fn_args, parsl_fn_kwargs,\\n buffer_threshold=1024 * 1024,\\n item_threshold=1024)}\\n with open(fn_path, \\\"wb\\\") as f_out:\\n pickle.dump(function_info, f_out)\",\n \"def apply(cls, x):\\n return x\",\n \"def save_function_to_disk(self):\\n write_to_disk(\\n to_pickle(self._fn), os.path.join(self.location, FNCT_NM)\\n )\",\n \"def f1(x):\\n return x**3 - 2*x + 2\",\n \"def forward(self, x):\\n\\n out = self.model(x)\\n\\n return out\",\n \"def forward(self, x):\\n out = self.regress(x)\\n \\n return out\",\n \"def store_output(output):\\n\\n pass\",\n \"def exercise_4(inputs): # DO NOT CHANGE THIS LINE\\n output = inputs\\n\\n return output # DO NOT CHANGE THIS LINE\",\n \"def modify_stored_fn():\\r\\n fn = get_check_fn()\\r\\n store_fn(fn)\",\n \"def save_at_specified_path_dec(f, full_path):\\n def decorated_f(*args, **kwargs):\\n x = f(*args, **kwargs)\\n f.print_handler_f(x, full_path)\\n return x\\n\\n return decorated_f\",\n \"def f(x, a, b):\\n return f_raw(x, a, b)\",\n \"def call(self, input, func, output):\\n # we want to run the same splitting function on the lineage array as well.\\n # so we do want to reduce randomness? -> at the same time, it should work for any randomness\\n outputs = func(input)\\n self.data_split = copy.deepcopy(outputs) # we don't want to do this for every function or we would save too many copies?\\n return outputs\",\n \"def process_input_in_python(inputf, outputf):\\n value=-1\\n with open(inputf, 'r') as f:\\n value = int(f.readline().strip())\\n print(outputf)\\n time.sleep(5)\\n with open(outputf, 'w') as f:\\n f.write(str(value**2))\",\n \"def save(self, output, data):\",\n \"def __call__(self, _x: np.ndarray) -> np.ndarray:\\n return self.function(_x)\",\n \"def hook_output(self, name: str, func: Callable[[\\\"self.value_type\\\"], None]):\\n self.write_hooks[name] = func\",\n \"def transform(self, f):\\n\\n return f(self)\",\n \"def forward(self, x):\\n return x\",\n \"def save(self, x):\\n self.print_handler_f(x, x.get_full_path())\",\n \"def f(self,x,*params):\\n raise NotImplementedError\",\n \"def save_object(o, fn):\\n return dump_object(o, fn)\",\n \"def eval_fn(dummy_state, batch):\\n model.forward_pass(batch, training=False)\\n return dummy_state\",\n \"def k1(self, f, t, u, usereverse=False):\\n\\n if usereverse:\\n output, storagez, storagew = f(t, u)\\n\\n self.storagez.append(storagez)\\n self.storagew.append(storagew)\\n\\n return output\\n else:\\n return f(t, u)\",\n \"def _f(self, x: torch.Tensor, params: Scenario):\\n # Extract batch size and set up a tensor for holding the result\\n batch_size = x.shape[0]\\n\\n # memoize the tensor\\n if not hasattr(self, \\\"f_tensor\\\"):\\n self.f_tensor = torch.zeros(self.n_dims, 1)\\n\\n return self.f_tensor.expand(batch_size, -1, -1).type_as(x)\",\n \"def f(self, x, theta):\\n raise NotImplementedError(\\n \\\"f has not been implemented for this Experiment\\\")\",\n \"def f(x):\\n\\treturn np.sin(x / 5.0) * np.exp(x / 10.0) + 5 * np.exp(-x / 2.0)\",\n \"def transf(self,f):\\r\\n raise NotImplementedError\",\n \"def out(self, inputs):\",\n \"def _save_input(self, mod, i):\\n if mod.training:\\n self.state[mod][\\\"x\\\"] = i[0]\",\n \"def monitor(f, input='print', output='print'):\\n if not input:\\n input = lambda v: None\\n elif input == 'print':\\n incount = [0]\\n def input(value):\\n args, kwargs = value\\n print(\\\"in %s %r %r\\\" % (incount[0], args, kwargs))\\n incount[0] += 1\\n if not output:\\n output = lambda v: None\\n elif output == 'print':\\n outcount = [0]\\n def output(value):\\n print(\\\"out %s %r\\\" % (outcount[0], value))\\n outcount[0] += 1\\n def f_monitored(*args, **kwargs):\\n input((args, kwargs))\\n v = f(*args, **kwargs)\\n output(v)\\n return v\\n return f_monitored\",\n \"def sumfunc(x):\\n\\n x = x + 1\\n return x\",\n \"def func(x, f, fp):\\n\\n return np.sqrt((1+fp(x)**2) / (2 * g * f(x)))\",\n \"def test_dfunction_saveable(self):\\n \\n wa = FrequencyAxis(0.0, 1000, 0.1)\\n \\n fw = numpy.exp(-wa.data)\\n \\n fce = DFunction(wa,fw)\\n \\n #fce.plot()\\n\\n #with h5py.File(\\\"test_file_1\\\",driver=\\\"core\\\", \\n # backing_store=False) as f:\\n with tempfile.TemporaryFile() as f:\\n \\n fce.save(f, test=True)\\n \\n fce2 = DFunction()\\n fce2 = fce2.load(f, test=True)\\n \\n #fce2.plot()\\n \\n numpy.testing.assert_array_equal(fce.data, fce2.data)\",\n \"def fn(x):\\n\\n # coefficients\\n A = 728.0\\n B = 0.317\\n C = 0.486\\n D = -8.99 * 1.6\\n\\n # function\\n fx = - D / x**2 - A / B * math.exp(- x / B) + 6 * C / x**7\\n\\n return fx\",\n \"def __call__(self, x):\\n return self.y(x)\",\n \"def __init__(self, f, save_directory=None, function_name=None, version=None, input_name=None):\\n self.f = f \\n self.save_directory = save_directory\\n self.function_name = function_name if function_name else f.__name__\\n self.version = version if version else ''\\n self.input_name = input_name\\n \\n if save_directory is None:\\n self.save_directory = self.save_directory_default\\n \\n if not exists(self.save_directory):\\n makedirs(self.save_directory)\\n \\n suf_len = len(self._suffix)\\n self.cache = [f[:-suf_len] for f in listdir(self.save_directory) if isfile(f) and f[-suf_len:] == self._suffix]\",\n \"def doFunc(self):\\n val = self.func(self.value())\\n if val:\\n self.setValue(val)\",\n \"def f(self):\\n return self._f\",\n \"def apply_to_file(f):\\n @wraps(f)\\n def f_in_file(fname):\\n with open(fname, 'rb') as inf:\\n data = inf.read()\\n data = f(data)\\n with open(fname, 'wb+') as outf:\\n outf.write(data)\\n\\n return f_in_file\",\n \"def __call__(self):\\n loads = self._load()\\n log.newline(lines=2)\\n results = self._func(*loads)\\n log.newline(lines=2)\\n self._save(results)\",\n \"def forward(self, x, **kwargs):\\n\\n\\t\\toutput = self.lin1(x)\\n\\t\\toutput = self.lin2(output)\\n\\t\\toutput = self.lin3(output)\\n\\t\\toutput = self.lin_out(output)\\n\\n\\t\\treturn output\",\n \"def __call__(self, a):\\n self.x = a\\n return self.forward(a)\",\n \"def with_save(func):\\n @wraps(func)\\n def saving_func(*args, **kwargs):\\n save = kwargs.pop('save', False)\\n ret = func(*args, **kwargs)\\n if save:\\n ret.save()\\n return ret\\n\\n return saving_func\",\n \"def f(x, y=1):\\r\\n return x ** 2 + y\",\n \"def eval_func(f, x, y, t):\\n if f[0] == 'x':\\n return x\\n if f[0] == 'y':\\n return y\\n if f[0] == 't':\\n return y-t\\n if f[0] == 'prod':\\n return eval_func(f[1],x,y,t)*eval_func(f[2],x,y,t)\\n if f[0] == 'avg':\\n return (eval_func(f[1],x,y,t)+eval_func(f[2],x,y,t))/2.0\\n if f[0] == 'cos_pi':\\n return math.cos(math.pi*eval_func(f[1],x,y,t))\\n if f[0] == 'sin_pi':\\n return math.sin(math.pi*eval_func(f[1],x,y,t))\\n if f[0] == 'subtract':\\n return eval_func(f[1],x,y,t)-eval_func(f[2],x,y,t)\\n if f[0] == 'add':\\n return eval_func(f[1],x,y,t)+eval_func(f[2],x,y,t)\",\n \"def save_functions(self, a, func_name):\\n logging.debug(\\\"in function save\\\")\\n if self.need_func_start and (self.cur_char != self.func_start):\\n pass\\n else:\\n logging.debug(\\\"current char \\\" + self.cur_char)\\n self.produce(\\\"func_name\\\", func_name)\\n self.functions.append(func_name)\\n self.begin('')\",\n \"def __call__(self, f):\\r\\n return self.apply(f, None)\",\n \"def main(fn_input, fn_output):\\n # read file\\n inter = Interpolator()\\n inter.read_file(fn_input)\\n inter.write_interpolated(fn_output)\",\n \"def savefile(self, x, o):\\n self.sep('save')\\n with open(o, 'w') as f:\\n f.write(x)\\n sys.exit('all done (%s bytes).. saved as %s' % (len(x), o))\",\n \"def f(x):\\n return (2.0*math.sin(10.0*x+1.0)+1.0)\",\n \"def f(x, y=1):\\n return x ** 2 + y\",\n \"def forward(self, x):\\n x = self.arch(x)\\n x = self.swish(x)\\n x_out = self.arch._fcOut(x)\\n return x_out\",\n \"def wrapper_func(input):\\n assert len(input.shape) == 1\\n\\n params[i].data = torch.Tensor(input.reshape((shape)))\\n\\n if(len(keywords.keys()) > 1):\\n outputVar = func(*params, **keywords)\\n else:\\n outputVar = func(*params)\\n\\n output = outputVar.data.numpy()\\n\\n return output\",\n \"def evaluate():\\n\\t\\t\\t\\tif not hasattr(evaluate, 'value'):\\n\\t\\t\\t\\t\\tevaluate.value = func()\\n\\t\\t\\t\\treturn evaluate.value\",\n \"def __call__(self, x, **kwargs):\\n del kwargs\\n for f in self._functions:\\n x = f(x)\\n return x\",\n \"def transform(self, x):\",\n \"def _fit_function(self,x,a,b):\\n return b + a*x\",\n \"def f2(x):\\n return x**2 + 2 * x + 1\",\n \"def F(x):\\n return math.exp(-0.5 * (x ** 2))\",\n \"def f(x, y=0, z=0):\\r\\n return x ** 2 + y + z\",\n \"def __call__ (self, x) :\\n fx = fixed_q_exp (x)\\n result = fx (self)\\n return result\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61477196","0.60924035","0.60078835","0.5988158","0.5940525","0.58522373","0.57708055","0.57708055","0.5726363","0.5718889","0.57045394","0.56582165","0.56162596","0.55415493","0.5506286","0.5488552","0.54811376","0.5469306","0.5469306","0.5469306","0.5469306","0.5465544","0.5453858","0.5453858","0.54527205","0.54368305","0.5430909","0.54085845","0.5406657","0.5400497","0.5397264","0.5372765","0.5372715","0.5316105","0.5292379","0.52696306","0.5263931","0.524856","0.52460885","0.52460885","0.5230241","0.52286446","0.52099615","0.52069867","0.52059364","0.5198556","0.5198328","0.51971436","0.5195722","0.5191654","0.51874137","0.51873446","0.51754576","0.5161234","0.51566875","0.5156568","0.5153856","0.5146283","0.5144479","0.5143537","0.5131152","0.5125749","0.5122918","0.51153344","0.5114914","0.51126903","0.51097596","0.51079214","0.5095285","0.5088754","0.5080279","0.50779986","0.50766724","0.5065571","0.5065373","0.50642043","0.5056258","0.5055129","0.5051223","0.50495356","0.50495183","0.50404453","0.5038045","0.5032638","0.5023075","0.50086296","0.5001794","0.50007474","0.49882826","0.4986653","0.49859005","0.4975474","0.49718788","0.49678582","0.49657735","0.4964148","0.49598262","0.49586332","0.495438","0.49542502","0.494624"],"string":"[\n \"0.61477196\",\n \"0.60924035\",\n \"0.60078835\",\n \"0.5988158\",\n \"0.5940525\",\n \"0.58522373\",\n \"0.57708055\",\n \"0.57708055\",\n \"0.5726363\",\n \"0.5718889\",\n \"0.57045394\",\n \"0.56582165\",\n \"0.56162596\",\n \"0.55415493\",\n \"0.5506286\",\n \"0.5488552\",\n \"0.54811376\",\n \"0.5469306\",\n \"0.5469306\",\n \"0.5469306\",\n \"0.5469306\",\n \"0.5465544\",\n \"0.5453858\",\n \"0.5453858\",\n \"0.54527205\",\n \"0.54368305\",\n \"0.5430909\",\n \"0.54085845\",\n \"0.5406657\",\n \"0.5400497\",\n \"0.5397264\",\n \"0.5372765\",\n \"0.5372715\",\n \"0.5316105\",\n \"0.5292379\",\n \"0.52696306\",\n \"0.5263931\",\n \"0.524856\",\n \"0.52460885\",\n \"0.52460885\",\n \"0.5230241\",\n \"0.52286446\",\n \"0.52099615\",\n \"0.52069867\",\n \"0.52059364\",\n \"0.5198556\",\n \"0.5198328\",\n \"0.51971436\",\n \"0.5195722\",\n \"0.5191654\",\n \"0.51874137\",\n \"0.51873446\",\n \"0.51754576\",\n \"0.5161234\",\n \"0.51566875\",\n \"0.5156568\",\n \"0.5153856\",\n \"0.5146283\",\n \"0.5144479\",\n \"0.5143537\",\n \"0.5131152\",\n \"0.5125749\",\n \"0.5122918\",\n \"0.51153344\",\n \"0.5114914\",\n \"0.51126903\",\n \"0.51097596\",\n \"0.51079214\",\n \"0.5095285\",\n \"0.5088754\",\n \"0.5080279\",\n \"0.50779986\",\n \"0.50766724\",\n \"0.5065571\",\n \"0.5065373\",\n \"0.50642043\",\n \"0.5056258\",\n \"0.5055129\",\n \"0.5051223\",\n \"0.50495356\",\n \"0.50495183\",\n \"0.50404453\",\n \"0.5038045\",\n \"0.5032638\",\n \"0.5023075\",\n \"0.50086296\",\n \"0.5001794\",\n \"0.50007474\",\n \"0.49882826\",\n \"0.4986653\",\n \"0.49859005\",\n \"0.4975474\",\n \"0.49718788\",\n \"0.49678582\",\n \"0.49657735\",\n \"0.4964148\",\n \"0.49598262\",\n \"0.49586332\",\n \"0.495438\",\n \"0.49542502\",\n \"0.494624\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":121,"numItemsPerPage":100,"numTotalItems":95772,"offset":12100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTk0MDYwMiwianRpIjoiYWEyNGJkY2MtNzVhMy00ZjgyLWIwMzItNzg5NTZjNDEyNzQxIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU5NDQyMDIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.GJ4JCDyOYsG214kZ_2fiUKqaJLnAaoI2imyDmOMJ-tqbG83isKF3CyXMFAJR0-Nd84ABz-18m5h9ORi7RXWjAw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
If there is a negative gradient, change it to zero | def relu_backward_hook_function(module, grad_in, grad_out):
# Get last forward output
corresponding_forward_output = self.forward_relu_outputs[-1]
corresponding_forward_output[corresponding_forward_output > 0] = 1
modified_grad_out = corresponding_forward_output * torch.c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def zero_grad(self):\n self.grad.zero_()",
"def grad_zero(self):\r\n pass",
"def grad_zero(self):\r\n pass",
"def negative_gradient(self, y, y_pred, **kargs):",
"def zero_grad(self):\n self.grad = Tensor(data=np.zeros_like(self.data, dtype=np.float))",
"def zero_grad(x):\n ... | [
"0.76615775",
"0.76399404",
"0.76399404",
"0.76242167",
"0.7470609",
"0.74599236",
"0.7242895",
"0.7150094",
"0.71176636",
"0.7107646",
"0.70826745",
"0.7034797",
"0.7034797",
"0.7016988",
"0.7001879",
"0.69932896",
"0.69932896",
"0.6954989",
"0.69188714",
"0.68847275",
"0.68... | 0.0 | -1 |
Store results of forward pass | def relu_forward_hook_function(module, ten_in, ten_out):
self.forward_relu_outputs.append(ten_out) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward_pass(self):",
"def forward_pass(self):\n # Compute the support set's mean and var and use these as the moments for\n # batch norm on the query set.\n train_embeddings = self.embedding_fn(self.episode.train_images,\n self.is_training)\n self.train_em... | [
"0.65868884",
"0.6509388",
"0.6396395",
"0.6384102",
"0.6342878",
"0.6342878",
"0.6329432",
"0.6291918",
"0.6291918",
"0.62083226",
"0.6193587",
"0.6159851",
"0.61594737",
"0.61594737",
"0.61594737",
"0.6113193",
"0.60944366",
"0.60923964",
"0.6091803",
"0.60865366",
"0.60748... | 0.0 | -1 |
generate the next state | def _nextObservation(self):
frame = np.array(self.df.loc[(self.currentStep - (self.time_lag - 1)):self.currentStep,['return_Low','return_Volume']].values)
obs = (frame,np.array([self.balance/10000,self.buy_amount/10000,self.sell_amount/10000])) # standardize the value
return obs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_next_state(self, action) :\n raise NotImplementedError",
"def next_state(self):\n \n self.state = np.random.choice(['checkout', 'dairy', 'drinks', 'fruit', 'spices'], p=self.tr_array_dict[f'{self.state}'])",
"def next(self):\n self.state += 1\n if self.state > 1:\n... | [
"0.8228073",
"0.76831114",
"0.7611324",
"0.7524008",
"0.744573",
"0.7322066",
"0.73127764",
"0.73049396",
"0.7203904",
"0.7172242",
"0.7148373",
"0.7090857",
"0.7040154",
"0.7002292",
"0.697542",
"0.6929242",
"0.6918649",
"0.6869711",
"0.6867532",
"0.6853744",
"0.67200696",
... | 0.0 | -1 |
upate the balance, sell acount, buy acount, based on returan rate | def _balance_update(self):
return_rate = self.df.loc[self.currentStep, "return_Close"]
self.buy_amount += return_rate * self.buy_amount
self.sell_amount -= return_rate * self.sell_amount | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_earning(self, data=None):\n result = Result()\n if data is None:\n data = self.security\n self.calcDecision()\n first_purchase_method = self.check_first_purchase_method()\n for i in np.arange(len(data['Close'])):\n if data['FinalDecision'].iloc[i] i... | [
"0.6785312",
"0.6220181",
"0.6175861",
"0.6114552",
"0.6088199",
"0.60283774",
"0.6012482",
"0.59921443",
"0.5976123",
"0.5962097",
"0.59508103",
"0.5949215",
"0.5946042",
"0.5930534",
"0.5910977",
"0.59003735",
"0.5884636",
"0.58771354",
"0.5839308",
"0.58320624",
"0.5797567... | 0.72528595 | 0 |
given action, return new state and reward | def step(self, action):
self.currentStep += 1 # add current step by 1
self._takeAction(action) # update buy/sell account
self._balance_update() # update balance account
obs = self._nextObservation()
newnetWorth = self.balance + self.buy_amount + self.sell_amount # calculate... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def step(self, action):\n res = self.reward_table.get(self.curr_state, action)\n\n self.curr_state = res['result']\n\n return res",
"def state_update(self, last_action, action):\n s_t = self._get_state(last_action)\n r= self._get_reward(last_action,action)\n self._move_user()\n s_t1 ... | [
"0.82155526",
"0.76120025",
"0.75517076",
"0.75496775",
"0.7516878",
"0.7515607",
"0.74979776",
"0.74631685",
"0.738725",
"0.73777217",
"0.7361667",
"0.73603576",
"0.73077524",
"0.7297692",
"0.72945803",
"0.7272934",
"0.72710866",
"0.72631186",
"0.72499824",
"0.7240149",
"0.7... | 0.701414 | 51 |
Prepare the dict of values to create the new invoice for a sale order. This method may be overridden to implement custom invoice generation (making sure to call super() to establish a clean extension chain). | def _prepare_invoice(self, cr, uid, order, lines, context=None):
invoice_vals = super(my_sale_order, self)._prepare_invoice(cr, uid, order,
lines, context)
invoice_vals.update({
'partner_shipping_id': order.partner_shipping_id.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _prepare_invoice(self):\n # get current logged in user's timezone\n local = pytz.timezone(self.env['res.users'].browse(self._uid).tz) or pytz.utc\n\n self.ensure_one()\n journal_id = self.env['account.journal'].search([('type', '=', 'purchase')], limit=1).id\n if not journal_... | [
"0.74100953",
"0.73465693",
"0.73403376",
"0.7328195",
"0.7002523",
"0.69652605",
"0.68501127",
"0.67724967",
"0.6712132",
"0.665417",
"0.6562301",
"0.6495313",
"0.6490809",
"0.6431741",
"0.6104436",
"0.6072918",
"0.59833795",
"0.59129834",
"0.5863059",
"0.5860928",
"0.578695... | 0.76020634 | 0 |
r"""Smooth (and optionally differentiate) data with a SavitzkyGolay filter. The SavitzkyGolay filter removes high frequency noise from data. It has the advantage of preserving the original shape and features of the signal better than other types of filtering approaches, such as moving averages techniques. | def savitzky_golay(y, window_size, order, deriv=0, rate=1):
import numpy as np
from math import factorial
if type(y) != np.ndarray:
y = np.array(y)
try:
window_size = np.abs(np.int(window_size))
order = np.abs(np.int(order))
except ValueError, msg:
raise ValueError("w... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def savitzky_golay(data, kernel = 11, order = 4):\n try:\n kernel = abs(int(kernel))\n order = abs(int(order))\n except ValueError as msg:\n raise ValueError(\"kernel and order have to be of type int (floats will be converted).\")\n if kernel % 2 != 1 or kernel < 1:\n r... | [
"0.6111886",
"0.59920794",
"0.5924583",
"0.59181935",
"0.5907186",
"0.5907186",
"0.58241117",
"0.5821847",
"0.57398474",
"0.568444",
"0.56125593",
"0.55897284",
"0.55865884",
"0.5586021",
"0.5577094",
"0.556779",
"0.5545501",
"0.554301",
"0.554301",
"0.5539812",
"0.5532512",
... | 0.55577457 | 16 |
Defines a new factor of the variables in 'variables'. | def __init__(self, variables=[], values=[], probabilities=[]):
self.variables = variables
self.values = values
self.probabilities = probabilities | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def changeVars(self, vars):\n v = VarSet(vars)\n newOrder = map(lambda x:v.index(x), vars)\n return Factor(v, self.t.transpose(newOrder))\n #return NotImplemented",
"def add_factor(self, variables, table):\n unknown_vars = set(variables) - set(self.vs.keys())\n if unknown_vars != set():... | [
"0.70088005",
"0.6836307",
"0.67915875",
"0.65298533",
"0.6334977",
"0.63198227",
"0.599025",
"0.59119016",
"0.58628434",
"0.5843477",
"0.57352024",
"0.5614046",
"0.55369943",
"0.55199915",
"0.54717815",
"0.54656976",
"0.5433968",
"0.5418116",
"0.5400235",
"0.5386884",
"0.533... | 0.5186049 | 27 |
Multiplies 'self' with 'other'. | def multiply(self, other):
#we create the set of variables in the new factor
new_variables = list(set(self.variables).union(set(other.variables)))
new_values = []
new_probabilities = []
if len(self.variables) == 0:
for i,values in enumerate(other.values):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _multiply(self, other):\n raise NotImplementedError(\n \"{} does not support scalar multiplication\".format(type(self)))",
"def __mul__(self, other):\n\n return self._mul_div(other, div=False)",
"def _mul(self, other):\n return None",
"def __mul__(self, other):\n tr... | [
"0.8064776",
"0.7970657",
"0.796114",
"0.79249585",
"0.7889723",
"0.78663045",
"0.7815562",
"0.7790138",
"0.77565044",
"0.7755494",
"0.76342523",
"0.76095176",
"0.7581025",
"0.75805557",
"0.7572927",
"0.7551614",
"0.75353855",
"0.7507408",
"0.7506214",
"0.7499792",
"0.7464834... | 0.0 | -1 |
Sums out 'variable' from the factor. | def sum_out(self, variable):
variable_index = self.variables.index(variable)
new_values = []
new_probabilities = []
#we take the value of the variable that we are summing out
#in the first row of 'self.values' and then sum the probability of this row
#with the probabilit... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eliminate_variable(variable, factors):\r\n containing_var = []\r\n not_containing_var = []\r\n for fac in factors:\r\n if variable in fac.get_variables():\r\n containing_var.append(fac)\r\n else:\r\n not_containing_var.append(fac)\r\n\r\n... | [
"0.5763951",
"0.5669693",
"0.55726874",
"0.55263823",
"0.5515817",
"0.5482787",
"0.542001",
"0.5418609",
"0.53602505",
"0.53336567",
"0.531933",
"0.5285622",
"0.5236265",
"0.5204135",
"0.5204135",
"0.51979774",
"0.51931953",
"0.5181711",
"0.5155577",
"0.5143785",
"0.5126949",... | 0.550545 | 5 |
Compute FFT either using pyfftw (default) or scipy | def fft_wrap(iq_buffer, mode = 'pyfftw'):
if mode == 'pyfftw':
return pyfftw.interfaces.numpy_fft.fft(iq_buffer, threads=4)
elif mode == 'scipy':
return fft(iq_buffer) #### TODO CLEAN | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Forvard(Fin, z, usepyFFTW = False):\n _using_pyfftw = False # determined if loading is successful\n if usepyFFTW or _USE_PYFFTW:\n try:\n import pyfftw as _pyfftw\n from pyfftw.interfaces.numpy_fft import fft2 as _fft2\n from pyfftw.interfaces.numpy_fft import ifft... | [
"0.7427441",
"0.73273164",
"0.71920234",
"0.70279694",
"0.6929818",
"0.6861905",
"0.6849192",
"0.67657036",
"0.672953",
"0.6695925",
"0.66232765",
"0.65545744",
"0.6535014",
"0.6516699",
"0.65082127",
"0.6489493",
"0.64837605",
"0.6350328",
"0.6346015",
"0.62473303",
"0.62402... | 0.7184091 | 3 |
Function to parse user argument | def parse_args() -> str:
ap = ArgumentParser(description='Create camera_pose files.')
ap.add_argument('--workspace_path', required=True)
args = vars(ap.parse_args())
return args['workspace_path'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def parseInputArgs():\n parser = argparse.ArgumentParser(description=\"Unix cut analog\", usage='%(prog)s [arguments]')\n\n # pos arg\n parser.add_argument('filename', type=str, help='input file name')\n\n # req arg\n requiredNamed = parser.add_argument_group('require... | [
"0.70487463",
"0.66665703",
"0.6544067",
"0.65317565",
"0.6513973",
"0.651204",
"0.6479623",
"0.6431322",
"0.642296",
"0.64047027",
"0.63884735",
"0.63625544",
"0.63537353",
"0.6340073",
"0.6334934",
"0.6334471",
"0.6314911",
"0.6312969",
"0.6304386",
"0.62819535",
"0.6276047... | 0.0 | -1 |
The function removes all the extra images created in the images folder | def remove_extra_images(path_to_images: str, number_of_images: int) -> None:
last_image = 'image' + str(number_of_images) + '.jpg'
while last_image in listdir(path_to_images):
last_image_path = path.join(path_to_images, last_image)
remove(last_image_path)
print(f"remove {last_image}")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def space_cleaning():\n for file in os.listdir(\".\"):\n if file.endswith(\".png\"):\n os.remove(file)",
"def delete_AllImgs(self):\n self.listImages.remove_all_imgs()",
"def clearAllPictures(self):\n shutil.rmtree(PNG_OUTPUT_PATH)\n os.makedirs(PNG_OUTPUT_PATH)",
"d... | [
"0.772399",
"0.7678155",
"0.762436",
"0.7403201",
"0.7364772",
"0.7342737",
"0.7281264",
"0.72779584",
"0.7222312",
"0.719953",
"0.7062136",
"0.69628257",
"0.6952707",
"0.6949376",
"0.6933136",
"0.6925044",
"0.692482",
"0.692419",
"0.6918678",
"0.6897421",
"0.6856652",
"0.6... | 0.7538987 | 3 |
The function prepares the images for our model based on a given video | def prepare_video(path_to_video: str, number_of_images=87) -> None:
temp_video = path.join(path_to_video, 'temp_outpy.mp4')
video = path.join(path_to_video, 'outpy.h264')
# create mp4 video for metadata and compute video duration
subprocess.run(['ffmpeg', '-i', video, '-c', 'copy', temp_video])
re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_train_video(opt, frame_path, Total_frames):\n clip = []\n i = 0\n loop = 0\n\n # choosing a random frame\n if Total_frames <= opt.sample_duration: \n loop = 1\n start_frame = 0\n else:\n start_frame = np.random.randint(0, Total_frames - opt.sample_duration)\n \n ... | [
"0.6378548",
"0.6341571",
"0.6268886",
"0.6267411",
"0.62665486",
"0.62576735",
"0.61747694",
"0.6135613",
"0.61193234",
"0.6107251",
"0.607215",
"0.6004102",
"0.59735906",
"0.5962933",
"0.5939074",
"0.59383684",
"0.59096986",
"0.5904158",
"0.58933836",
"0.5886941",
"0.588352... | 0.6345232 | 1 |
The function prepares the images for our model based on a given video | def create_temp_model(temp_dir_path: str) -> str:
# create temp images folder
path_to_temp_model = path.join(temp_dir_path, 'temp_model')
path_to_temp_images = path.join(path_to_temp_model, 'temp_images')
# remove old temporary folder if exists
if path.exists(path_to_temp_model) and path.isdir(pat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_train_video(opt, frame_path, Total_frames):\n clip = []\n i = 0\n loop = 0\n\n # choosing a random frame\n if Total_frames <= opt.sample_duration: \n loop = 1\n start_frame = 0\n else:\n start_frame = np.random.randint(0, Total_frames - opt.sample_duration)\n \n ... | [
"0.63750154",
"0.63425624",
"0.6340762",
"0.62680477",
"0.6264588",
"0.62635916",
"0.625837",
"0.6173872",
"0.613284",
"0.61168224",
"0.6105058",
"0.6069448",
"0.60025144",
"0.59694576",
"0.59601396",
"0.59386766",
"0.5936131",
"0.59105086",
"0.5900934",
"0.5891576",
"0.58850... | 0.0 | -1 |
The function converts the quaternion vector to a rotation matrix | def quaternion_to_rotation_matrix(q0, q1, q2, q3) -> np:
# First row of the rotation matrix
r00 = 2 * (q0 * q0 + q1 * q1) - 1
r01 = 2 * (q1 * q2 - q0 * q3)
r02 = 2 * (q1 * q3 + q0 * q2)
# Second row of the rotation matrix
r10 = 2 * (q1 * q2 + q0 * q3)
r11 = 2 * (q0 * q0 + q2 * q2) - 1
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def quaternion_to_rotation_matrix(quaternion):\n\n q_w, q_x, q_y, q_z = quaternion\n sqw, sqx, sqy, sqz = np.square(quaternion)\n norm = (sqx + sqy + sqz + sqw)\n rotation_matrix = np.zeros((3, 3))\n\n # division of square length if quaternion is not already normalized\n rotation_matrix[0, 0] = (... | [
"0.75867957",
"0.74146473",
"0.73953855",
"0.72882676",
"0.7253188",
"0.72290003",
"0.71538144",
"0.71532506",
"0.7126588",
"0.7108177",
"0.7099389",
"0.70787674",
"0.7061855",
"0.7034862",
"0.7003994",
"0.70023286",
"0.6997477",
"0.697881",
"0.69561833",
"0.69520205",
"0.693... | 0.683938 | 25 |
The function converts rotation matrix to quaternion vector | def rotation_matrix_to_quaternion(rotation_matrix: np) -> object:
cosine_for_pitch = math.sqrt(rotation_matrix[0][0] ** 2 + rotation_matrix[1][0] ** 2)
is_singular = cosine_for_pitch < 10 ** -6
if not is_singular:
yaw = math.atan2(rotation_matrix[1][0], rotation_matrix[0][0])
pitch = math.a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rotation_matrix_to_quaternion(rotation_matrix):\n trace = np.trace(rotation_matrix)\n\n if trace > 0:\n S = np.sqrt(trace + 1) * 2\n q_w = 0.25 * S\n q_x = (rotation_matrix[2, 1] - rotation_matrix[1, 2]) / S\n q_y = (rotation_matrix[0, 2] - rotation_matrix[2, 0]) / S\n ... | [
"0.76806",
"0.75808585",
"0.757304",
"0.7515583",
"0.7400028",
"0.7371076",
"0.72685283",
"0.72596556",
"0.722488",
"0.71143645",
"0.70881724",
"0.7081711",
"0.70517707",
"0.7031683",
"0.70243925",
"0.7013156",
"0.70124847",
"0.7006788",
"0.69838303",
"0.69710416",
"0.6961587... | 0.7486031 | 4 |
The function convert Euler angle to quaternion object | def euler_to_quaternion(euler: tuple) -> object:
(yaw, pitch, roll) = (euler[0], euler[1], euler[2])
qy = np.sin(roll / 2) * np.cos(pitch / 2) * np.cos(yaw / 2) - np.cos(roll / 2) * np.sin(pitch / 2) * np.sin(yaw / 2)
qx = np.cos(roll / 2) * np.sin(pitch / 2) * np.cos(yaw / 2) + np.sin(roll / 2) * np.cos(p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def euler_to_quaternion(psi, theta, phi):\n # Abbreviations for the various angular functions\n cy = np.cos(psi * 0.5)\n sy = np.sin(psi * 0.5)\n cp = np.cos(theta * 0.5)\n sp = np.sin(theta * 0.5)\n cr = np.cos(phi * 0.5)\n sr = np.sin(phi * 0.5)\n\n q = np.zeros(4)\n q[0] = cy * cp * c... | [
"0.7751907",
"0.7692476",
"0.7672758",
"0.7591342",
"0.7487414",
"0.74774384",
"0.7452368",
"0.742516",
"0.74124753",
"0.7385367",
"0.7384482",
"0.73697144",
"0.7299849",
"0.72180927",
"0.7195682",
"0.71946454",
"0.7185801",
"0.71458083",
"0.7089422",
"0.70486486",
"0.7017161... | 0.805849 | 0 |
The function return the absolut R & T for the first image in temp model | def get_first_image_pose(image_src: str) -> list:
# read images file
with open(image_src, 'r') as file:
lines = file.readlines()[4::2]
# create absolut camera pose dictionary
for line in lines:
columns = line.split()
image_name = columns[9].split('.')[0]
image_id = int(i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTEMP(self):\r\n\t\ttemp_H = self.read(0x41)\r\n\t\ttemp_L = self.read(0x42)\r\n\t\ttemp = self.twos_comp(val = (temp_H*256 + temp_L),bits=16)\r\n\t\ttempC = (temp/340.0)+36.53\r\n\t\ttempF = tempC*(9.0/5) + 32\r\n\t\treturn tempC,tempF ,temp",
"def get_temp():\n\n\tall_temp = scipy.io.loadmat('../files/AL... | [
"0.5835618",
"0.56531143",
"0.55923015",
"0.5438354",
"0.5347717",
"0.5341041",
"0.5332741",
"0.5300689",
"0.52883106",
"0.5286375",
"0.5286375",
"0.52680224",
"0.5263778",
"0.5262911",
"0.5252384",
"0.5249313",
"0.52401304",
"0.52320766",
"0.5204717",
"0.51733774",
"0.516107... | 0.0 | -1 |
Debug function for plotting the relative camera poses | def draw_rel_camera_pose(image: int, origin: list, camera_pose: list, plot_dir_path: str) -> None:
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.view_init(elev=10.)
ax.set_title('camera pose image: %d' % image)
scale = 7
ax.set_xlim3d(-scale, scale)
ax.set_ylim3d(-scale, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _plot_camera_view(self):\n fig, axs = plt.subplots()\n fig.show()\n axs.cla()\n axs.axis([-0.003, 0.003, -0.003, 0.003])\n axs.grid()\n axs.plot([0], [0], 'r+')\n for t_step in range(0, int(self._t_sim / self._dt) + 1, 250):\n axs.plot(\n ... | [
"0.73460865",
"0.66647047",
"0.6283057",
"0.6272126",
"0.6184981",
"0.6083503",
"0.6081631",
"0.60760427",
"0.60532206",
"0.5971392",
"0.59111524",
"0.5910716",
"0.590532",
"0.59003586",
"0.58845973",
"0.58664477",
"0.5849812",
"0.5844196",
"0.58399713",
"0.58338684",
"0.5831... | 0.62216526 | 4 |
The function return a dictionary with recovered R&T for each image | def compute_absolut_camera_pose(camera_pose_rel_dict: dict, first_image_pose: list,
workspace_path: str, do_plot=False) -> dict:
# create directory for reference plots
ref_pose_images_path = path.join(workspace_path, 'ref_images')
if do_plot:
makedirs(ref_pose_images... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_images_and_labels(tampered_path, authentic_path):\n tampered_dir = tampered_path\n authentic_dir = authentic_path\n images = {}\n for im in glob.glob(authentic_dir):\n images[im] = {}\n images[im]['mat'] = cv2.imread(im)\n images[im]['label'] = 0\n for im in glob.glob(ta... | [
"0.59811085",
"0.5820795",
"0.58199984",
"0.57714254",
"0.5704318",
"0.5689812",
"0.56580365",
"0.5642151",
"0.5625003",
"0.56211644",
"0.5559603",
"0.55574334",
"0.5546614",
"0.5507273",
"0.5501269",
"0.5493681",
"0.5486779",
"0.5481917",
"0.546224",
"0.5449304",
"0.54414034... | 0.0 | -1 |
The function write the recovered camera poses according to COLMAP documentation | def write_camera_pose_to_file(camera_pose_abs_dict: dict, pose_dir_path: str) -> None:
image_dst = path.join(pose_dir_path, 'images.txt')
with open(image_dst, 'w+') as file:
file.write('# Image list with two lines of data per image:\n')
file.write('# IMAGE_ID, QW, QX, QY, QZ, TX, TY, TZ, CAMER... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_poses():\n get_marshmallow_pose(should_remember=True)\n get_mouth_pose(should_remember=True)\n rospy.sleep(1)\n print \"Finished saving poses\"",
"def write(self, pathname='wind.png'):\r\n cv2.imwrite(pathname, self.matrix * 255)",
"def writeCameraSettings(self):\n pass",
"... | [
"0.6014014",
"0.5977247",
"0.5700586",
"0.56356347",
"0.56256527",
"0.5615104",
"0.560124",
"0.55990064",
"0.55756223",
"0.5424815",
"0.54085475",
"0.5403678",
"0.5390949",
"0.5362901",
"0.53255045",
"0.53230655",
"0.5303748",
"0.5303022",
"0.5295456",
"0.52894944",
"0.528787... | 0.6023144 | 0 |
The function deletes all the files in the workspace folder except the input video | def clear_workspace(workspace_path: str) -> None:
# make sure the workspace in empty
for filename in listdir(workspace_path):
if filename.endswith('.h264'):
continue
path_to_node = path.join(workspace_path, filename)
if path.isdir(path_to_node):
shutil.rmtree(path... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_video(video_path):\n print()\n message : str = \"removing folder\"\n pretty_print_value(video_path,message,Fore.YELLOW)\n print()\n\n\n command = \"rm \\\"\" + video_path + \"\\\"\"\n print(command)\n os.system(command)\n ...",
"def delete(self):\n os.remove(self.file_pa... | [
"0.71255624",
"0.6622876",
"0.654681",
"0.64084095",
"0.6397945",
"0.6377839",
"0.6360218",
"0.6339522",
"0.6309185",
"0.62984246",
"0.6296886",
"0.62502575",
"0.6248952",
"0.62447387",
"0.62233245",
"0.6200896",
"0.620054",
"0.6183128",
"0.6178877",
"0.6172909",
"0.6167118",... | 0.6389304 | 5 |
Draw an n x n grid with edges / nodes from X in red | def draw_grid(n,X):
G = nx.grid_2d_graph(n+1,n+1)
set_node_colors(G,G.nodes(),'k')
set_edge_colors(G,G.edges(),'k')
set_edge_weights(G,G.edges(),0.5)
set_node_colors(G,edge_subgraph_nodes(X),'r')
set_edge_colors(G,X,'r')
set_edge_weights(G,X,1)
nc = [G.node[n]['color'] for... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_grid(self):\n plt.imshow(py.array(\n map(lambda x: map(lambda y: mplc.colorConverter.to_rgb(colord[y]), x), self.create_grid(self.graph))),\n interpolation='nearest')\n plt.show()",
"def draw_grid(self):\n for i in range(N * N + 1):\n color = \"blue\... | [
"0.6630089",
"0.647417",
"0.6226133",
"0.6224112",
"0.6188585",
"0.6169128",
"0.61569834",
"0.6127831",
"0.61215925",
"0.6074973",
"0.6070254",
"0.606452",
"0.60638255",
"0.6051185",
"0.60291207",
"0.6009064",
"0.600086",
"0.5957386",
"0.59433025",
"0.59421194",
"0.59329593",... | 0.7901583 | 0 |
Turns a numpy array into an integer array corresponding to its unique values. | def encode_column(col: np.ndarray) -> Tuple[np.ndarray, EmbedMapping]:
assert len(col.shape) == 1, "only embedding 1D arrays"
_, indices, encoded_col = np.unique(
col, return_index=True, return_inverse=True, return_counts=False
)
n_uniques = indices.shape[0]
mapping = {col[indice]: idx for (... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cat2int(x):\n s = set(x)\n v2int = {}\n for i, v in enumerate(unique):\n v2int[v] = i\n assert len(s) >= 2, 'Kind of values is smaller than 2'\n return np.array([v2int[e] for e in x], dtype=np.int32), v2int",
"def unique_of_an_array(an_array):\n temp_array=an_array.copy()\n u=[]\n... | [
"0.7057783",
"0.6852139",
"0.6836868",
"0.68208766",
"0.6546067",
"0.6433152",
"0.62101084",
"0.6201899",
"0.6189905",
"0.6157561",
"0.6144629",
"0.6132668",
"0.60799134",
"0.60772425",
"0.6070786",
"0.60621244",
"0.6054846",
"0.6054343",
"0.6051386",
"0.60384727",
"0.6030941... | 0.0 | -1 |
Embeds a columns from an existing mapping from floats to codes. | def encode_from_mapping(col: np.ndarray, mapping: EmbedMapping) -> np.ndarray:
assert "UNK_TOKEN" in mapping
encoded = np.empty_like(col)
for (ix, val) in enumerate(col):
try:
encoded[ix] = mapping[val]
except KeyError:
encoded[ix] = mapping["UNK_TOKEN"]
return en... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _transform_map_data(self):\n WARD_FMT = '%s-%s'\n self.map_data_trans = []\n lookup = {i.column: ''.join(filter(lambda x: x.isdigit(), i.value)) for i in self.sht[1]}\n\n #skip over header\n rs = iter(self.sht.rows)\n next(rs)\n next(rs)\n for r in rs:\n ... | [
"0.57176745",
"0.5700983",
"0.54500836",
"0.5328572",
"0.52717036",
"0.526309",
"0.5219423",
"0.5202589",
"0.51164263",
"0.5103581",
"0.5081847",
"0.50752693",
"0.50520027",
"0.5045185",
"0.5021839",
"0.4988317",
"0.49841195",
"0.49638763",
"0.49529734",
"0.492426",
"0.491906... | 0.50825346 | 10 |
Scale entries in the input to the range [1, 1]. | def scale_column(
col: np.ndarray,
) -> Tuple[np.ndarray, Optional[Tuple[float, float]]]:
assert len(col.shape) == 1
assert not np.any(np.isnan(col)), "NaN values in array to rescale"
min_, max_ = col.min(), col.max()
if (max_ - min_) < FLOAT_TOL:
return np.zeros_like(col), None
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scale(input):\n return (input - np.min(input)) / ((np.max(input) - np.min(input)))",
"def rescale(x):\n if x.min() != 0:\n raise ValueError('input should have min zero.')\n\n x /= x.max() # max 1\n x *= 2 # max 2\n x -= 1 # range -1, 1\n\n if x.min() != -1 and x.max() != 1:\n ... | [
"0.80568105",
"0.7588538",
"0.73361796",
"0.73288435",
"0.72421265",
"0.7234204",
"0.721903",
"0.7195681",
"0.718205",
"0.7181776",
"0.71636903",
"0.7139774",
"0.71332127",
"0.7055854",
"0.70536315",
"0.70240897",
"0.6988062",
"0.6939791",
"0.6935333",
"0.6903189",
"0.6825208... | 0.0 | -1 |
Scale entries in the input using existing min max values | def scale_from_minmax(
col: np.ndarray, minmax: Optional[Tuple[float, float]]
) -> np.ndarray:
if minmax is None:
return np.zeros_like(col)
else:
min_, max_ = minmax
assert max_ - min_ >= FLOAT_TOL
return 2 * (col - min_) / (max_ - min_) - 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scale(input):\n return (input - np.min(input)) / ((np.max(input) - np.min(input)))",
"def __scale(data, max_value_list, min_value_list, scale_value_list, process_cols_list):\n features = np.array(data.features, dtype=float)\n for i in process_cols_list:\n value = features[i]\n... | [
"0.7884871",
"0.7450257",
"0.74433905",
"0.74255383",
"0.72756886",
"0.7246593",
"0.7236667",
"0.72221416",
"0.71644276",
"0.71283484",
"0.71039796",
"0.7097882",
"0.7069458",
"0.7058498",
"0.70544004",
"0.70540905",
"0.70508415",
"0.7047351",
"0.69412607",
"0.6932006",
"0.69... | 0.6487516 | 50 |
Normalize inputs using a log, then standardize them | def log_std(col: np.ndarray) -> Tuple[np.ndarray, Tuple[float, float]]:
assert col.min() > 0.0
log_transformed = np.log(col)
mean_, std_ = log_transformed.mean(), log_transformed.std()
return (log_transformed - mean_) / (std_ + FLOAT_TOL), (mean_, std_) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lognormalize(x, temp = 1):\n if type(x) is list: x = np.array(x)\n\n x = x - np.max(x)\n # anneal\n xp = np.power(np.exp(x), temp)\n return xp / xp.sum()",
"def normalise(self,data,take_logs:bool=False):\n\n # Normalise vector to sum up to 1\n normalised_vector = data/np.sum(data... | [
"0.7340787",
"0.69749516",
"0.6919301",
"0.68766457",
"0.6748069",
"0.67386186",
"0.67236066",
"0.66689205",
"0.6596321",
"0.65622526",
"0.65040284",
"0.64725643",
"0.6462739",
"0.6441923",
"0.6431693",
"0.6418261",
"0.6301656",
"0.62992144",
"0.6297648",
"0.6270137",
"0.6267... | 0.0 | -1 |
Normalize inputs using a log, a mean offset and a std scale. | def log_std_from_stats(
col: np.ndarray, mean_std: Tuple[float, float]
) -> np.ndarray:
mean_, std_ = mean_std
assert std_ >= 0.0
assert col.min() > 0.0
return (np.log(col) - mean_) / (std_ + FLOAT_TOL) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize(dataset):\n return normalize_standard_deviation(normalize_mean(dataset))",
"def normalize(X, mu, sigma):\n return (X - mu) / sigma",
"def normalize(values):\n return (values - np.mean(values)) / np.std(values)",
"def normalize(adata, log_transform=True, **kwargs):\n sc.pp.normalize_to... | [
"0.6575835",
"0.65729403",
"0.6567097",
"0.6540712",
"0.6431638",
"0.6410498",
"0.6410498",
"0.63853174",
"0.63853174",
"0.63391674",
"0.632828",
"0.63230276",
"0.6322845",
"0.6322552",
"0.6310987",
"0.62713665",
"0.62632674",
"0.6249568",
"0.6233811",
"0.62288135",
"0.622552... | 0.0 | -1 |
This function handles command line parameters. Run the server using python server.py Show the help text using python server.py help | def run(debug, threaded, host, port):
HOST, PORT = host, port
print "running on %s:%d" % (HOST, PORT)
app.run(host=HOST, port=PORT, debug=debug, threaded=threaded) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n parser = create_arg_parser()\n\n # If script run without arguments, print syntax\n if len(sys.argv) == 1:\n parser.print_help()\n sys.exit(1)\n\n # Parse arguments\n args = parser.parse_args()\n host = args.h\n mode = args.m\n port = args.p\n debug_mode = args... | [
"0.81759226",
"0.8050697",
"0.80427533",
"0.78978634",
"0.7878987",
"0.7878987",
"0.7590224",
"0.7564658",
"0.7556798",
"0.7555605",
"0.7452737",
"0.7312544",
"0.73076516",
"0.7255843",
"0.71107197",
"0.71107197",
"0.7087304",
"0.6971827",
"0.6925472",
"0.68589836",
"0.684500... | 0.0 | -1 |
Only show the debug toolbar to users with the superuser flag. | def _custom_show_toolbar(request: 'HttpRequest') -> bool:
return DEBUG and request.user.is_superuser | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _custom_show_toolbar(request):\n return DEBUG and request.user.is_superuser",
"def show_toolbar(request: HttpRequest) -> bool:\n conditions = (\n settings.DEBUG\n and request.META.get('REMOTE_ADDR', None) in settings.INTERNAL_IPS,\n request.user.is_superuser,\n )\n disqualifi... | [
"0.817702",
"0.67734593",
"0.61041766",
"0.6046557",
"0.5890961",
"0.5890961",
"0.5883483",
"0.5869873",
"0.58142656",
"0.58089703",
"0.5765674",
"0.57116914",
"0.57055",
"0.56569725",
"0.5652845",
"0.5607011",
"0.5505614",
"0.5483127",
"0.5456996",
"0.5456996",
"0.5435421",
... | 0.8088223 | 1 |
Formats the location values separating keys, values and k/v pairs >>> l = Location(42.1, 23.5, "test") | def format_geocommit(self, keyval_separator, entry_separator):
end = entry_separator
sep = keyval_separator
msg = "lat" + sep + str(self.lat) + end
msg += "long" + sep + str(self.long) + end
for attr in self.optional_keys:
if hasattr(self, attr):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def format_pair(self, k, v):\n if isinstance(v, int):\n data_width = len(str(v)) + 1\n header_width = len(str(k))\n w = max(data_width, header_width)\n h = ('%% %us'%w)%k\n return ' '*len(h), h, '%%%ud'%w\n elif k=='dt':\n fmt = '%6.3... | [
"0.59635484",
"0.5520702",
"0.5457944",
"0.54207",
"0.5350413",
"0.5347729",
"0.5347187",
"0.5327935",
"0.53164715",
"0.53077406",
"0.5262094",
"0.5207229",
"0.5207229",
"0.51810014",
"0.5175114",
"0.51656723",
"0.5141616",
"0.51369876",
"0.51341087",
"0.51255035",
"0.5115307... | 0.568076 | 1 |
Formats the location using the long geocommit format >>> l = Location(42.1, 23.5, "test") >>> l.format_long_geocommit() | def format_long_geocommit(self):
geocommit = "geocommit (1.0)\n"
geocommit += self.format_geocommit(": ", "\n")
geocommit += "\n\n"
return geocommit | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def format_short_geocommit(self):\r\n geocommit = \"geocommit(1.0): \"\r\n geocommit += self.format_geocommit(\" \", \", \")\r\n geocommit += \";\"\r\n\r\n return geocommit",
"def format_latlon(lat: float, lon: float) -> str:\n if lat < 0:\n latdir = \"S\"\n e... | [
"0.6449494",
"0.5818637",
"0.57956123",
"0.57563007",
"0.5687247",
"0.55729204",
"0.55175114",
"0.5450161",
"0.5328889",
"0.53174734",
"0.5223536",
"0.52226293",
"0.51880616",
"0.5184553",
"0.51536745",
"0.51523906",
"0.5143899",
"0.513625",
"0.5133939",
"0.51274645",
"0.5106... | 0.7905342 | 0 |
Formats the location using the long geocommit format >>> l = Location(42.1, 23.5, "test") >>> l.format_short_geocommit() | def format_short_geocommit(self):
geocommit = "geocommit(1.0): "
geocommit += self.format_geocommit(" ", ", ")
geocommit += ";"
return geocommit | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def format_long_geocommit(self):\r\n geocommit = \"geocommit (1.0)\\n\"\r\n geocommit += self.format_geocommit(\": \", \"\\n\")\r\n geocommit += \"\\n\\n\"\r\n\r\n return geocommit",
"def short_def(self):\r\n return f\"{self.lat}, {self.lon}\"",
"def from_short_format(data):\... | [
"0.78306407",
"0.64534444",
"0.62554103",
"0.61308855",
"0.60158163",
"0.5945876",
"0.5859429",
"0.57603073",
"0.5721214",
"0.55733645",
"0.55531913",
"0.55373216",
"0.55149174",
"0.54258066",
"0.54249513",
"0.54163617",
"0.53930986",
"0.5350871",
"0.5336369",
"0.5322799",
"0... | 0.7280461 | 1 |
Parses a string in short format to create an instance of the class. >>> l = Location.from_short_format( | def from_short_format(data):
m = re.search("geocommit\(1\.0\): ((?:[a-zA-Z0-9_-]+ [^,;]+, )*)([a-zA-Z0-9_-]+ [^,;]+);", data)
if m is None:
return None
values = m.group(1) + m.group(2)
data = dict()
for keyval in re.split(",\s+", values):
ke... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_location(location):\n city, state = location.strip().split(',')\n return f\"{city.strip().replace(' ', '-')}-{state.strip().replace(' ', '-')}\"",
"def from_str(cls, string):",
"def parse_location(location_str):\n def floatify(latlon):\n \"\"\" Turns a latlon string into a flo... | [
"0.5796067",
"0.57846785",
"0.5758145",
"0.5640593",
"0.5627394",
"0.5549736",
"0.53233117",
"0.5281842",
"0.526684",
"0.52663153",
"0.5237364",
"0.51908535",
"0.51495135",
"0.5133941",
"0.511369",
"0.5065242",
"0.5057992",
"0.50402415",
"0.5021159",
"0.5001185",
"0.49983492"... | 0.6709516 | 0 |
Retrieves a location using this LocationProvider. Should be overwritten in specialisations of this class. | def get_location(self):
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_location(self) -> models.Location:\n return models.Location.get(region=self, name=self.name, deleted=False)",
"def get_location(self):\n return self.location",
"def get_location(self):\n\t\treturn self.location",
"def get_location(self):\r\n return self.__location",
"def _get_l... | [
"0.7753154",
"0.76495415",
"0.7630321",
"0.7557997",
"0.75226474",
"0.74665785",
"0.7435566",
"0.74313676",
"0.73154056",
"0.7309289",
"0.72279537",
"0.7225498",
"0.7192612",
"0.7192612",
"0.71177167",
"0.7008181",
"0.69932073",
"0.69932073",
"0.6984769",
"0.69491065",
"0.693... | 0.68752146 | 23 |
Retrieves all nearby access points. Should be overwritten in specialisations of this class. | def get_access_points(self):
return {"invalid mac": {"mac": "invalid mac", "ssid": "none"}} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def near(self, meters):\n lng = self.position['coordinates'][0]\n lat = self.position['coordinates'][1]\n\n return Location.objects(position__near=[lng, lat], position__max_distance=meters)",
"async def get_all_accesspoints(self) -> list[NetworkWirelessAP]:\n accesspoints_data = await... | [
"0.61669075",
"0.6093544",
"0.604198",
"0.5997114",
"0.59545606",
"0.59494096",
"0.5789342",
"0.57684696",
"0.57039857",
"0.5678461",
"0.5651898",
"0.5641419",
"0.5637641",
"0.5613552",
"0.5607629",
"0.56046563",
"0.56018794",
"0.55903774",
"0.55815107",
"0.5577816",
"0.55617... | 0.0 | -1 |
Creates a JSON request string for location information from google. The access points are a map from mac addresses to access point information dicts. >>> wlp = WifiLocationProvider() >>> wlp.request_dict()["wifi_towers"] | def request_dict(self):
ap_map = self.get_access_points()
if not ap_map:
return None
request = dict()
request["version"] = "1.1.0"
request["host"] = "localhost"
request["request_address"] = True
request["address_language"] = "en_GB"
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def google(self):\r\n prefix ='https://maps.googleapis.com/maps/api/staticmap?center='\r\n middle = '&zoom=14&size=400x400&markers='\r\n suffix = '&key=AIzaSyD5nqmDGFH1SUZxJAYVtFHP7RNjjFE9CHg'\r\n marker = '+'.join(self.placeToSearch) # marker in google format, no space but + separator\... | [
"0.54804015",
"0.53161436",
"0.5291573",
"0.5062097",
"0.50081235",
"0.49757034",
"0.49650696",
"0.49560982",
"0.49435157",
"0.49330306",
"0.49222854",
"0.48264238",
"0.4785291",
"0.4694317",
"0.46646068",
"0.4656133",
"0.46497852",
"0.4645924",
"0.46358958",
"0.46351212",
"0... | 0.70129 | 0 |
Converts a Google JSON response into a location object >>> wlp = WifiLocationProvider() | def location_from_dict(self, data):
if not data.has_key("location"):
return None
ldata = data["location"]
location = Location(ldata["latitude"], ldata["longitude"], self.name)
optional_keys = {
"altitude": "alt",
"accuracy": "hacc",
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_location_details(self, location):\n resp = requests.get(\n self.base_url,\n params = {\n 'address': ''.join(location.split(' ')),\n 'key': GOOGLE_API_KEY,\n }\n )\n return resp.json()",
"def getLocation(self):\n s... | [
"0.5974814",
"0.59591895",
"0.5927976",
"0.58715785",
"0.58531946",
"0.5832747",
"0.580127",
"0.580127",
"0.57854533",
"0.5756534",
"0.5724387",
"0.57035905",
"0.5642393",
"0.5549555",
"0.5529168",
"0.5524611",
"0.5499603",
"0.5488703",
"0.54848623",
"0.548114",
"0.5437042",
... | 0.56601113 | 12 |
Sends a JSON request to google geolocation and parses the response >>> wlp = WifiLocationProvider() | def json_request(self, data):
json_request = json.dumps(data, indent=4)
try:
result = urllib2.urlopen(self.webservice, json_request).read()
except urllib2.URLError, e:
return None
try:
response = json.loads(result)
except ValueError... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getLocation(self):\n send_url = 'https://ipinfo.io'\n r = requests.get(send_url)\n resp = json.loads(r.text)\n logging.info(\"GeoLoc: {}\".format(resp))\n return resp",
"def getGeo(self):\n command = f'curl -s -m 5 http://ip-api.com/json/' + self.ip\n result =... | [
"0.6605563",
"0.6393113",
"0.6295248",
"0.622101",
"0.606464",
"0.6008153",
"0.57522696",
"0.5721718",
"0.57157815",
"0.5683287",
"0.56634706",
"0.5638915",
"0.56357163",
"0.5595905",
"0.55884135",
"0.55500716",
"0.5509407",
"0.5507103",
"0.55044156",
"0.5499998",
"0.54815227... | 0.0 | -1 |
Retrieves a location from Google Geolocation API based on Wifi APs. | def get_location(self):
request = self.request_dict()
if not request:
return None
location = self.json_request(request)
if not location:
return None
if location.has_key("access_token"):
self.access_token = location["access_token... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_rogueap_location(self, conn, macaddr: str, offset=0, limit=100, units=\"FEET\"):\n path = urlJoin(urls.ROGUE_LOCATION[\"GET_AP_LOC\"], macaddr)\n params = {\n \"offset\": offset,\n \"limit\": limit,\n \"units\": units\n }\n resp = conn.command(ap... | [
"0.63196516",
"0.61935186",
"0.61679256",
"0.5916524",
"0.5898339",
"0.58925164",
"0.57678634",
"0.57564193",
"0.57287663",
"0.56398714",
"0.56225747",
"0.5619764",
"0.55834264",
"0.55488384",
"0.5495334",
"0.54464465",
"0.5441897",
"0.5391288",
"0.53513193",
"0.53510875",
"0... | 0.5033922 | 41 |
Extract features from points. | def extract_feat(self, points, img_metas=None):
voxels, num_points, coors = self.voxelize(points)
voxel_features = self.voxel_encoder(voxels, num_points, coors)
batch_size = coors[-1, 0].item() + 1
x = self.middle_encoder(voxel_features, coors, batch_size)
x = self.backbone(x)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_feat(self, points, img, img_metas):\n img_feats = self.extract_img_feat(img, img_metas)\n pts_feats = self.extract_pts_feat(points, img_feats, img_metas)\n return (img_feats, pts_feats)",
"def extract_features(input_feature_map, points=conv43Points):\n arr = []\n for y,x in... | [
"0.76258445",
"0.75479424",
"0.7520793",
"0.7304446",
"0.72170246",
"0.7079929",
"0.68441653",
"0.6794022",
"0.6782572",
"0.6651835",
"0.6640643",
"0.66359365",
"0.65395874",
"0.6499239",
"0.6448742",
"0.6447992",
"0.642975",
"0.6423805",
"0.63974905",
"0.6388154",
"0.6350114... | 0.7565338 | 1 |
Apply hard voxelization to points. | def voxelize(self, points):
voxels, coors, num_points = [], [], []
for res in points:
res_voxels, res_coors, res_num_points = self.voxel_layer(res)
voxels.append(res_voxels)
coors.append(res_coors)
num_points.append(res_num_points)
voxels = torch.c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def voxelize(self, points):\n voxels, coors, num_points = [], [], []\n for res in points:\n res_voxels, res_coors, res_num_points = self.pts_voxel_layer(res)\n voxels.append(res_voxels)\n coors.append(res_coors)\n num_points.append(res_num_points)\n ... | [
"0.6439414",
"0.6234096",
"0.61848783",
"0.61010504",
"0.6074771",
"0.58545244",
"0.5738699",
"0.5695123",
"0.56734055",
"0.5653354",
"0.5604796",
"0.56036615",
"0.55895144",
"0.557377",
"0.55472815",
"0.5544818",
"0.55416125",
"0.54999644",
"0.54610586",
"0.54565",
"0.543493... | 0.6423426 | 1 |
Test function without augmentaiton. | def simple_test(self, points, img_metas, imgs=None, rescale=False):
x = self.extract_feat(points, img_metas)
outs = self.bbox_head(x)
bbox_list = self.bbox_head.get_bboxes(
*outs, img_metas, rescale=rescale)
bbox_results = [
bbox3d2result(bboxes, scores, labels)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_func():\n pass",
"def istest(func):\n func.__test__ = True\n return func",
"def test_empty_functions():",
"def test():\r\n pass",
"def test():\n pass",
"def test():\n pass",
"def test():",
"def test():",
"def nottest(func):\n func.__test__ = False\n return func"... | [
"0.8132576",
"0.8071819",
"0.800281",
"0.7998863",
"0.79607767",
"0.7866433",
"0.77652454",
"0.77652454",
"0.775515",
"0.76536846",
"0.74718827",
"0.74428475",
"0.7407458",
"0.7383898",
"0.7348863",
"0.72939146",
"0.72939146",
"0.72939146",
"0.72939146",
"0.72939146",
"0.7263... | 0.0 | -1 |
Test function with augmentaiton. | def aug_test(self, points, img_metas, imgs=None, rescale=False):
feats = self.extract_feats(points, img_metas)
# only support aug_test for one sample
aug_bboxes = []
for x, img_meta in zip(feats, img_metas):
outs = self.bbox_head(x)
bbox_list = self.bbox_head.get... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test():",
"def test():",
"def test():\n pass",
"def _test(self):",
"def _test(self):",
"def _test(self):",
"def _test(self):",
"def _test(self):",
"def test():\r\n pass",
"def test_func():\n pass",
"def test_something():",
"def istest(func):\n func.__test__ = True\n ret... | [
"0.74091053",
"0.74091053",
"0.7398965",
"0.7205164",
"0.7205164",
"0.7205164",
"0.7205164",
"0.7205164",
"0.71508545",
"0.71262884",
"0.71077543",
"0.70619524",
"0.70262593",
"0.6987379",
"0.6978902",
"0.69609225",
"0.6952422",
"0.69435656",
"0.69096893",
"0.6908036",
"0.689... | 0.0 | -1 |
Load the grid data from the sample earth_relief file. | def fixture_grid():
return load_earth_relief(registration="pixel") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fixture_grid():\n return load_earth_relief(registration=\"gridline\")",
"def load_train_grid40(return_imsize=True):\n file_base_path = os.path.join(rlvision.RLVISION_DATA,\n \"train\", \"gridworld_40\", \"gridworld_40\")\n\n if not os.path.isfile(file_base_path+\".h5... | [
"0.71628165",
"0.65157515",
"0.64941037",
"0.6290516",
"0.6283898",
"0.6261977",
"0.6137829",
"0.59520215",
"0.5852507",
"0.58480215",
"0.5800172",
"0.5742071",
"0.57125926",
"0.57125765",
"0.5712251",
"0.5711601",
"0.5700506",
"0.5699708",
"0.5662421",
"0.5648323",
"0.561772... | 0.7127945 | 1 |
grdfilter an input DataArray, and output as DataArray. | def test_grdfilter_dataarray_in_dataarray_out(grid):
result = grdfilter(grid=grid, filter="g600", distance="4")
# check information of the output grid
assert isinstance(result, xr.DataArray)
assert result.coords["lat"].data.min() == -89.5
assert result.coords["lat"].data.max() == 89.5
assert res... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_grdfilter_dataarray_in_file_out(grid):\n with GMTTempFile(suffix=\".nc\") as tmpfile:\n result = grdfilter(grid, outgrid=tmpfile.name, filter=\"g600\", distance=\"4\")\n assert result is None # grdfilter returns None if output to a file\n result = grdinfo(tmpfile.name, per_column=... | [
"0.72438073",
"0.71895283",
"0.6108349",
"0.6072146",
"0.60382855",
"0.6018336",
"0.58795875",
"0.58754164",
"0.5870362",
"0.5869875",
"0.5862751",
"0.5731808",
"0.56614274",
"0.5651315",
"0.56284916",
"0.5540049",
"0.55231196",
"0.5522951",
"0.5522951",
"0.54774076",
"0.5467... | 0.75263023 | 0 |
grdfilter an input DataArray, and output to a grid file. | def test_grdfilter_dataarray_in_file_out(grid):
with GMTTempFile(suffix=".nc") as tmpfile:
result = grdfilter(grid, outgrid=tmpfile.name, filter="g600", distance="4")
assert result is None # grdfilter returns None if output to a file
result = grdinfo(tmpfile.name, per_column=True)
a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_grdfilter_file_in_dataarray_out():\n outgrid = grdfilter(\n \"@earth_relief_01d\", region=\"0/180/0/90\", filter=\"g600\", distance=\"4\"\n )\n assert isinstance(outgrid, xr.DataArray)\n assert outgrid.gmt.registration == 1 # Pixel registration\n assert outgrid.gmt.gtype == 1 # Geo... | [
"0.74676794",
"0.6965203",
"0.6943156",
"0.57479334",
"0.5405306",
"0.5393092",
"0.53729516",
"0.5346795",
"0.5268873",
"0.5247941",
"0.5225041",
"0.52224445",
"0.52160496",
"0.5199661",
"0.51719517",
"0.5155658",
"0.5155277",
"0.5070777",
"0.50582415",
"0.50448567",
"0.50338... | 0.77258784 | 0 |
grdfilter an input grid file, and output as DataArray. | def test_grdfilter_file_in_dataarray_out():
outgrid = grdfilter(
"@earth_relief_01d", region="0/180/0/90", filter="g600", distance="4"
)
assert isinstance(outgrid, xr.DataArray)
assert outgrid.gmt.registration == 1 # Pixel registration
assert outgrid.gmt.gtype == 1 # Geographic type
# ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_grdfilter_dataarray_in_file_out(grid):\n with GMTTempFile(suffix=\".nc\") as tmpfile:\n result = grdfilter(grid, outgrid=tmpfile.name, filter=\"g600\", distance=\"4\")\n assert result is None # grdfilter returns None if output to a file\n result = grdinfo(tmpfile.name, per_column=... | [
"0.82479215",
"0.73520637",
"0.7201283",
"0.63456845",
"0.63165814",
"0.585526",
"0.576018",
"0.57303125",
"0.56888694",
"0.5629014",
"0.5605087",
"0.55669653",
"0.5533368",
"0.5529867",
"0.55254185",
"0.5519094",
"0.54980975",
"0.5455956",
"0.5448404",
"0.54415244",
"0.54415... | 0.76401544 | 1 |
grdfilter an input grid file, and output to a grid file. | def test_grdfilter_file_in_file_out():
with GMTTempFile(suffix=".nc") as tmpfile:
result = grdfilter(
"@earth_relief_01d",
outgrid=tmpfile.name,
region=[0, 180, 0, 90],
filter="g600",
distance="4",
)
assert result is None # return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_grdfilter_dataarray_in_file_out(grid):\n with GMTTempFile(suffix=\".nc\") as tmpfile:\n result = grdfilter(grid, outgrid=tmpfile.name, filter=\"g600\", distance=\"4\")\n assert result is None # grdfilter returns None if output to a file\n result = grdinfo(tmpfile.name, per_column=... | [
"0.704675",
"0.68028927",
"0.5841552",
"0.58407056",
"0.57574695",
"0.5738572",
"0.5637733",
"0.5556143",
"0.55201113",
"0.54455745",
"0.54209566",
"0.5312087",
"0.529742",
"0.52541614",
"0.5249761",
"0.52250904",
"0.5192693",
"0.5181852",
"0.5169016",
"0.51613814",
"0.516137... | 0.7821418 | 0 |
Check that grdfilter fails correctly. | def test_grdfilter_fails():
with pytest.raises(GMTInvalidInput):
grdfilter(np.arange(10).reshape((5, 2))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_filter_errors(self):\n\n with self.assertRaises(ValueError):\n self.test_table.filter()\n\n with self.assertRaises(ValueError):\n self.test_table.filter(mode='wrongmode', Property='Property')",
"def test_filter_function_settings_fail(self):\n with self.assertRa... | [
"0.67835367",
"0.6310252",
"0.62462205",
"0.61204123",
"0.6087536",
"0.60227674",
"0.59823984",
"0.59056413",
"0.58599424",
"0.57920605",
"0.573395",
"0.5714643",
"0.5699136",
"0.5680347",
"0.5672416",
"0.56558776",
"0.56553173",
"0.56384057",
"0.563598",
"0.55971026",
"0.558... | 0.71679807 | 0 |
Ensure tests are running | def test_this_is_working(self):
self.assertEqual(1, 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_run_started(self):",
"def runTests(self):\n \n pass",
"def startTestRun(self):",
"def do_test(self):\n\t\tshutit_global.shutit_global_object.yield_to_draw()\n\t\tif not self.build['dotest']:\n\t\t\tself.log('Tests configured off, not running',level=logging.DEBUG)\n\t\t\treturn\n\t\t# Test ... | [
"0.7622389",
"0.7469543",
"0.73592174",
"0.7115611",
"0.70846725",
"0.70702255",
"0.70586264",
"0.6923004",
"0.6884074",
"0.6880718",
"0.68450254",
"0.68419343",
"0.6823735",
"0.6821682",
"0.68007135",
"0.6797732",
"0.67934436",
"0.67854553",
"0.67481923",
"0.669763",
"0.6676... | 0.0 | -1 |
Generate Pydantic Model files given the Postman Collection input file. | def generate_models(input_file):
if not os.path.exists(input_file):
console.print(
f":pile_of_poo: [bold red]No file found at the given path:[/bold red] [i yellow]{input_file}[/i yellow]"
)
exit(1)
# TODO: Add try/catch for other possible errors
collection = postman.load... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def input_models():\n return [\n PDBFile(\n Path(golden_data, \"protdna_complex_1.pdb\"),\n path=golden_data,\n score=42.0,\n restr_fname=Path(golden_data, \"example_ambig_1.tbl\")\n ),\n PDBFile(\n Path(golden_data, \"protdna_compl... | [
"0.56165767",
"0.5588253",
"0.5478929",
"0.54493415",
"0.5426958",
"0.53957415",
"0.53064173",
"0.52855295",
"0.52591866",
"0.52293295",
"0.5166549",
"0.50401545",
"0.5026971",
"0.50226295",
"0.5017243",
"0.4993968",
"0.4981129",
"0.49646968",
"0.4943805",
"0.4927351",
"0.491... | 0.7841486 | 0 |
Tests that update_status creates a correctly formatted url. Compares the url created by update_status to correct_url | def test_update_status(self):
content_url = 'https://api.github.com'
status = 'success'
token = '123'
correct_url = 'https://123:x-oauth-basic@api.github.com/'
post_req = update_status(content_url, status, token)
self.assertEqual(correct_url, post_req.url)
"""
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _checkServiceURL(self, serviceName, options):\n url = self._getURL(serviceName, options)\n system = options['System']\n module = options['Module']\n self.log.info(\"Checking URLs for %s/%s\" % (system, module))\n urlsConfigPath = os.path.join('/Systems', system, self.setup, 'URLs', module)\n ... | [
"0.6494839",
"0.63909346",
"0.62975353",
"0.61703724",
"0.61658883",
"0.61041194",
"0.6101163",
"0.6069293",
"0.59918106",
"0.5973078",
"0.5959037",
"0.59548736",
"0.59496254",
"0.5906024",
"0.5898634",
"0.58770066",
"0.58564144",
"0.58474356",
"0.58468753",
"0.5846074",
"0.5... | 0.7175717 | 0 |
Helper method for making a request to the Blockstore REST API | def api_request(method, url, **kwargs):
if not settings.BLOCKSTORE_API_AUTH_TOKEN:
raise ImproperlyConfigured("Cannot use Blockstore unless BLOCKSTORE_API_AUTH_TOKEN is set.")
kwargs.setdefault('headers', {})['Authorization'] = f"Token {settings.BLOCKSTORE_API_AUTH_TOKEN}"
response = requests.reques... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getBlocks(request):\n if request.method == 'GET':\n blockName = request.GET.get('block', '')\n bid = request.GET.get('bid', '')\n districtName=request.GET.get('district', '')\n stateName=request.GET.get('state', '')\n limit=request.GET.get('limit', '')\n if limit ==... | [
"0.63156694",
"0.63156694",
"0.58579916",
"0.5850182",
"0.58061534",
"0.5766906",
"0.57296586",
"0.57222426",
"0.5660935",
"0.56325656",
"0.55943286",
"0.5584792",
"0.5576492",
"0.5573743",
"0.5564736",
"0.55544657",
"0.5547002",
"0.5537741",
"0.55332834",
"0.55300415",
"0.55... | 0.7547545 | 0 |
Given data about a Collection returned by any blockstore REST API, convert it to a Collection instance. | def _collection_from_response(data):
return Collection(uuid=UUID(data['uuid']), title=data['title']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def return_collection(self, collection, request, environ, start_response,\n response_headers):\n response_type = self.content_negotiation(\n request, environ, self.ValueTypes)\n if response_type is None:\n return self.odata_error(\n reques... | [
"0.6577779",
"0.6343278",
"0.6237831",
"0.6221495",
"0.6207642",
"0.6203012",
"0.6195551",
"0.6181388",
"0.6098431",
"0.6020433",
"0.60099417",
"0.5990563",
"0.5976519",
"0.5969405",
"0.5889118",
"0.58554935",
"0.58416325",
"0.5817092",
"0.5749313",
"0.57408684",
"0.57094455"... | 0.71289414 | 0 |
Given data about a Bundle returned by any blockstore REST API, convert it to a Bundle instance. | def _bundle_from_response(data):
return Bundle(
uuid=UUID(data['uuid']),
title=data['title'],
description=data['description'],
slug=data['slug'],
# drafts: Convert from a dict of URLs to a dict of UUIDs:
drafts={draft_name: UUID(url.split('/')[-1]) for (draft_name, ur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bundle_instance(obj):\n\n content, contents = osl_encode(obj, True)\n # should be a bunch of documents, not just one.\n bundle = [json.dumps(c) for c in contents]\n return bundle",
"def get(resource_name: str,\n id: pulumi.Input[str],\n opts: Optional[pulumi.ResourceOptions]... | [
"0.6342084",
"0.6269155",
"0.62631524",
"0.6151707",
"0.60612935",
"0.5925814",
"0.59022117",
"0.5898795",
"0.5896431",
"0.58471715",
"0.5792275",
"0.5681991",
"0.56783265",
"0.56710964",
"0.566184",
"0.5634402",
"0.56337357",
"0.56250954",
"0.5600761",
"0.5547723",
"0.554208... | 0.76745385 | 0 |
Given data about a Draft returned by any blockstore REST API, convert it to a Draft instance. | def _draft_from_response(data):
return Draft(
uuid=UUID(data['uuid']),
bundle_uuid=UUID(data['bundle_uuid']),
name=data['name'],
updated_at=dateutil.parser.parse(data['staged_draft']['updated_at']),
files={
path: DraftFile(path=path, **file)
for path, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_draft(self):\n return Draft(self)",
"def convert_to_draft(self, source_location):\r\n if source_location.category in DIRECT_ONLY_CATEGORIES:\r\n raise InvalidVersionError(source_location)\r\n original = self.collection.find_one({'_id': source_location.to_deprecated_son(... | [
"0.6512679",
"0.6157547",
"0.58887076",
"0.5854836",
"0.57501346",
"0.5479013",
"0.54623795",
"0.5257162",
"0.5218776",
"0.51486325",
"0.51365983",
"0.5121651",
"0.50962335",
"0.50772154",
"0.5046453",
"0.4987209",
"0.49718696",
"0.49420643",
"0.48823994",
"0.4866242",
"0.482... | 0.75933146 | 0 |
Retrieve metadata about the specified collection Raises CollectionNotFound if the collection does not exist | def get_collection(collection_uuid):
assert isinstance(collection_uuid, UUID)
try:
data = api_request('get', api_url('collections', str(collection_uuid)))
except NotFound:
raise CollectionNotFound(f"Collection {collection_uuid} does not exist.") # lint-amnesty, pylint: disable=raise-missing... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collection(self, collection):\r\n\t\tself.fetch_collections()\r\n\t\tif collection is not None:\r\n\t\t\treturn self._collections[collection]\r\n\t\treturn None",
"def get_collection(self, collection):\n return self.database[collection]",
"def __find_collection_in_meta(self, db_name, collection_name... | [
"0.7305138",
"0.69398516",
"0.68930227",
"0.6497091",
"0.6449103",
"0.6319241",
"0.6290924",
"0.62775695",
"0.6266724",
"0.6266204",
"0.6262986",
"0.6204985",
"0.6163578",
"0.6105707",
"0.60913056",
"0.60794675",
"0.6076522",
"0.6055384",
"0.6033745",
"0.6032824",
"0.6010094"... | 0.60184395 | 20 |
Create a new collection. | def create_collection(title):
result = api_request('post', api_url('collections'), json={"title": title})
return _collection_from_response(result) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_collection(collection):\n return db[collection]",
"def collection_create(self, name):\n try:\n return CastleCollection(name, self)\n except:\n raise",
"def test_create_collection(self):\n pass",
"def create_collections(self):\n\n ''''''",
"def... | [
"0.7994884",
"0.7690659",
"0.75408405",
"0.7422378",
"0.7185147",
"0.71705693",
"0.7120078",
"0.71186167",
"0.7102771",
"0.704654",
"0.69963944",
"0.69785434",
"0.6919937",
"0.6918079",
"0.6877754",
"0.68428624",
"0.6807147",
"0.68062043",
"0.67231405",
"0.67221653",
"0.67078... | 0.75662047 | 2 |
Update a collection's title | def update_collection(collection_uuid, title):
assert isinstance(collection_uuid, UUID)
data = {"title": title}
result = api_request('patch', api_url('collections', str(collection_uuid)), json=data)
return _collection_from_response(result) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_title(self, title):\n if type(title) != str:\n raise Exception(\"title is not a string\")\n\n self.__title_var.set(title)",
"def _UpdateTitle(self, event, new_title='Updated event title'):\n\n previous_title = event.title.text\n event.title.text = new_title\n print 'U... | [
"0.7148695",
"0.70232713",
"0.70118755",
"0.69351953",
"0.6923893",
"0.6876951",
"0.67621106",
"0.67621106",
"0.67621106",
"0.67621106",
"0.67621106",
"0.67621106",
"0.67621106",
"0.67621106",
"0.67621106",
"0.67621106",
"0.67621106",
"0.67621106",
"0.67621106",
"0.67621106",
... | 0.6916492 | 5 |
Get the details of all bundles | def get_bundles(uuids=None, text_search=None):
query_params = {}
if uuids:
query_params['uuid'] = ','.join(map(str, uuids))
if text_search:
query_params['text_search'] = text_search
version_url = api_url('bundles') + '?' + urlencode(query_params)
response = api_request('get', version... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_bundles():\n response = houston.get(\"/zipline/bundles\")\n\n houston.raise_for_status_with_json(response)\n return response.json()",
"def js_bundle_names(self):\n yield 'djblets-utils'\n yield 'djblets-avatars-config'\n\n for service in self.avatar_service_registry.configu... | [
"0.7786203",
"0.6552698",
"0.65044695",
"0.6455476",
"0.6441764",
"0.6422063",
"0.6287278",
"0.61940336",
"0.6077372",
"0.6044391",
"0.6042801",
"0.6016157",
"0.59816015",
"0.5979297",
"0.59682506",
"0.59142685",
"0.59101593",
"0.5890483",
"0.5887062",
"0.58353376",
"0.579112... | 0.609653 | 8 |
Retrieve metadata about the specified bundle Raises BundleNotFound if the bundle does not exist | def get_bundle(bundle_uuid):
assert isinstance(bundle_uuid, UUID)
try:
data = api_request('get', api_url('bundles', str(bundle_uuid)))
except NotFound:
raise BundleNotFound(f"Bundle {bundle_uuid} does not exist.") # lint-amnesty, pylint: disable=raise-missing-from
return _bundle_from_re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bundle_file_metadata(bundle_uuid, path, use_draft=None):\n assert isinstance(bundle_uuid, UUID)\n files_dict = get_bundle_files_dict(bundle_uuid, use_draft=use_draft)\n try:\n return files_dict[path]\n except KeyError:\n raise BundleFileNotFound( # lint-amnesty, pylint: disable=r... | [
"0.6519393",
"0.6253627",
"0.57244164",
"0.55816317",
"0.5546743",
"0.5535242",
"0.5494695",
"0.54787546",
"0.54765534",
"0.54500854",
"0.54294044",
"0.5417688",
"0.53673923",
"0.53673923",
"0.5361767",
"0.53374165",
"0.5311152",
"0.53036445",
"0.5297356",
"0.52674055",
"0.52... | 0.5795087 | 2 |
Create a new bundle. Note that description is currently required. | def create_bundle(collection_uuid, slug, title="New Bundle", description=""):
result = api_request('post', api_url('bundles'), json={
"collection_uuid": str(collection_uuid),
"slug": slug,
"title": title,
"description": description,
})
return _bundle_from_response(result) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_bundle(self):\n self._highest_bundle_id += 1\n bundle = Bundle(document=self, bundle_id=str(self._highest_bundle_id))\n self.bundles.append(bundle)\n bundle.number = len(self.bundles)\n return bundle",
"def firmware_pack_create(handle, org_name, name, rack_bundle_ver... | [
"0.668372",
"0.62939143",
"0.6256046",
"0.61546004",
"0.61484855",
"0.6085676",
"0.6012268",
"0.5936996",
"0.5896103",
"0.5847529",
"0.58094597",
"0.5789102",
"0.57620066",
"0.57466364",
"0.5724561",
"0.5723571",
"0.5719755",
"0.5677166",
"0.5674543",
"0.5627814",
"0.5617824"... | 0.71486557 | 0 |
Update a bundle's title, description, slug, or collection. | def update_bundle(bundle_uuid, **fields):
assert isinstance(bundle_uuid, UUID)
data = {}
# Most validation will be done by Blockstore, so we don't worry too much about data validation
for str_field in ("title", "description", "slug"):
if str_field in fields:
data[str_field] = fields.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_in_place(self, request, original_bundle, new_data):\r\n\r\n # TODO: Is this the place to use MongoDB atomic operations to update the document?\r\n\r\n from tastypie.utils import dict_strip_unicode_keys\r\n original_bundle.data.update(**dict_strip_unicode_keys(new_data))\r\n\r\n ... | [
"0.64282304",
"0.5881592",
"0.58728546",
"0.5861083",
"0.5718554",
"0.56827384",
"0.5633981",
"0.5599242",
"0.55933994",
"0.55191696",
"0.54296964",
"0.5405867",
"0.54009414",
"0.5397951",
"0.5393401",
"0.5391082",
"0.5379236",
"0.53778917",
"0.5375577",
"0.5358188",
"0.53553... | 0.7425863 | 0 |
Retrieve metadata about the specified draft. If you don't know the draft's UUID, look it up using get_bundle() | def get_draft(draft_uuid):
assert isinstance(draft_uuid, UUID)
try:
data = api_request('get', api_url('drafts', str(draft_uuid)))
except NotFound:
raise DraftNotFound(f"Draft does not exist: {draft_uuid}") # lint-amnesty, pylint: disable=raise-missing-from
return _draft_from_response(da... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self,\n draft_id,\n ):\n return self._invoke('get',\n {\n 'draft_id': draft_id,\n })",
"def get(self, oauth, resource_id, draft_id):\n d = Deposition.get(resource_id, user=current_user)\n ... | [
"0.67328864",
"0.6331739",
"0.6144933",
"0.58064723",
"0.5665685",
"0.5603166",
"0.55384314",
"0.5455672",
"0.53143066",
"0.531383",
"0.5187394",
"0.5155247",
"0.5139512",
"0.51386",
"0.5116797",
"0.5080759",
"0.5057689",
"0.5048839",
"0.50426704",
"0.50284934",
"0.50284934",... | 0.57508475 | 4 |
Retrieve metadata about the specified draft. | def get_or_create_bundle_draft(bundle_uuid, draft_name):
bundle = get_bundle(bundle_uuid)
try:
return get_draft(bundle.drafts[draft_name]) # pylint: disable=unsubscriptable-object
except KeyError:
# The draft doesn't exist yet, so create it:
response = api_request('post', api_url('d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self,\n draft_id,\n ):\n return self._invoke('get',\n {\n 'draft_id': draft_id,\n })",
"def get(self, oauth, resource_id, draft_id):\n d = Deposition.get(resource_id, user=current_user)\n ... | [
"0.6504005",
"0.60097516",
"0.57217854",
"0.5682793",
"0.5668223",
"0.5561862",
"0.5507919",
"0.54667366",
"0.5463275",
"0.54286134",
"0.5427839",
"0.54156",
"0.5385616",
"0.5367478",
"0.5338896",
"0.5338896",
"0.5327211",
"0.53266174",
"0.53234196",
"0.5313462",
"0.52506757"... | 0.0 | -1 |
Commit all of the pending changes in the draft, creating a new version of the associated bundle. Does not return any value. | def commit_draft(draft_uuid):
api_request('post', api_url('drafts', str(draft_uuid), 'commit')) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def commit(self):\n self.create()\n return self.refresh()",
"async def commit(self):\n if await self.is_valid():\n await self.update(committed=True).apply()",
"def commit(self):\n return",
"def Commit(self, request, context):\n context.code(beta_interfaces.StatusCode... | [
"0.6353239",
"0.599407",
"0.59923935",
"0.590607",
"0.5880677",
"0.5827969",
"0.57992727",
"0.579128",
"0.5776125",
"0.5776125",
"0.5776125",
"0.5776125",
"0.5776125",
"0.5657164",
"0.56538993",
"0.5624831",
"0.5623977",
"0.559058",
"0.5577797",
"0.5562359",
"0.55580884",
"... | 0.5923847 | 3 |
Delete the specified draft, removing any staged changes/files/deletes. Does not return any value. | def delete_draft(draft_uuid):
api_request('delete', api_url('drafts', str(draft_uuid))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self,\n draft_id,\n ):\n return self._invoke('delete',\n {\n 'draft_id': draft_id,\n })",
"def _delete_draft_message(draft):\n if draft is not None:\n draft.key.delete()\n return Ht... | [
"0.8477247",
"0.7536803",
"0.70039415",
"0.6800242",
"0.6678656",
"0.6091169",
"0.59882015",
"0.598721",
"0.5658908",
"0.5609526",
"0.55231327",
"0.55021924",
"0.5446673",
"0.54136",
"0.5397559",
"0.53314614",
"0.53098047",
"0.5283851",
"0.52465004",
"0.5162799",
"0.5152421",... | 0.78767365 | 1 |
Get the details of the specified bundle version | def get_bundle_version(bundle_uuid, version_number):
if version_number == 0:
return None
version_url = api_url('bundle_versions', str(bundle_uuid) + ',' + str(version_number))
return api_request('get', version_url) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_version():\n return about.get_version()",
"def get_version(self):\n return self.http_call(\"get\", url=f\"{self.base_url}/version\").json()",
"def _get_via_app_bundle(self, path: pathlib.Path | str) -> str:\n\n path = pathlib.Path(path) / \"Contents\" / \"Info.plist\"\n\n if not... | [
"0.71063685",
"0.7055568",
"0.69581395",
"0.6899469",
"0.68665576",
"0.68434507",
"0.6821725",
"0.6754685",
"0.6730333",
"0.6705119",
"0.67003167",
"0.6696833",
"0.6665585",
"0.66480154",
"0.6647472",
"0.663893",
"0.6636554",
"0.66245484",
"0.6607001",
"0.658064",
"0.6521611"... | 0.7637766 | 0 |
Get a list of the files in the specified bundle version | def get_bundle_version_files(bundle_uuid, version_number):
if version_number == 0:
return []
version_info = get_bundle_version(bundle_uuid, version_number)
return [BundleFile(path=path, **file_metadata) for path, file_metadata in version_info["snapshot"]["files"].items()] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_version_files(self, package, version):\n with self._conn.begin():\n return {\n row.filename\n for row in self._conn.execute(\n \"SELECT filename \"\n \"FROM get_version_files(%s, %s)\", (package, version)\n ... | [
"0.7293217",
"0.69692844",
"0.6767985",
"0.65724486",
"0.65694773",
"0.6546248",
"0.6306112",
"0.6290885",
"0.6254722",
"0.6251354",
"0.6199755",
"0.6197552",
"0.61879873",
"0.61280656",
"0.61088586",
"0.60504794",
"0.60438734",
"0.59778523",
"0.5970127",
"0.5940632",
"0.5922... | 0.7863409 | 0 |
Get a dictionary of the links in the specified bundle version | def get_bundle_version_links(bundle_uuid, version_number):
if version_number == 0:
return {}
version_info = get_bundle_version(bundle_uuid, version_number)
return {
name: LinkDetails(
name=name,
direct=LinkReference(**link["direct"]),
indirect=[LinkReferen... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bundle_links(bundle_uuid, use_draft=None):\n bundle = get_bundle(bundle_uuid)\n if use_draft and use_draft in bundle.drafts: # pylint: disable=unsupported-membership-test\n draft_uuid = bundle.drafts[use_draft] # pylint: disable=unsubscriptable-object\n return get_draft(draft_uuid).li... | [
"0.65551144",
"0.63308424",
"0.6044713",
"0.5982717",
"0.5820173",
"0.58162254",
"0.5697063",
"0.5680008",
"0.5680008",
"0.5654119",
"0.5614463",
"0.5573144",
"0.55640477",
"0.55347484",
"0.5501417",
"0.5493479",
"0.5456731",
"0.5444286",
"0.54436064",
"0.5442817",
"0.5428819... | 0.7957789 | 0 |
Get a dict of all the files in the specified bundle. Returns a dict where the keys are the paths (strings) and the values are BundleFile or DraftFile tuples. | def get_bundle_files_dict(bundle_uuid, use_draft=None):
bundle = get_bundle(bundle_uuid)
if use_draft and use_draft in bundle.drafts: # pylint: disable=unsupported-membership-test
draft_uuid = bundle.drafts[use_draft] # pylint: disable=unsubscriptable-object
return get_draft(draft_uuid).files
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bundle_files(bundle_uuid, use_draft=None):\n return get_bundle_files_dict(bundle_uuid, use_draft).values() # lint-amnesty, pylint: disable=dict-values-not-iterating",
"def get_bundle_version_files(bundle_uuid, version_number):\n if version_number == 0:\n return []\n version_info = get_bu... | [
"0.7790072",
"0.64431036",
"0.63394016",
"0.63182753",
"0.630003",
"0.62759304",
"0.6194732",
"0.6178175",
"0.61479455",
"0.6144583",
"0.6076846",
"0.60737944",
"0.6040074",
"0.5976576",
"0.59606755",
"0.5862239",
"0.5857732",
"0.58249676",
"0.5790602",
"0.5765096",
"0.576296... | 0.8014129 | 0 |
Get an iterator over all the files in the specified bundle or draft. | def get_bundle_files(bundle_uuid, use_draft=None):
return get_bundle_files_dict(bundle_uuid, use_draft).values() # lint-amnesty, pylint: disable=dict-values-not-iterating | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_files(self, block):\n \n raise NotImplementedError('get_files')",
"def __iter__(self):\n\n return iter(self.files)",
"def getFiles(self, getContent=False):\n for index, file in enumerate(self.files):\n if getContent:\n logger.debug(\n ... | [
"0.61938465",
"0.6149882",
"0.61284655",
"0.60207605",
"0.5920121",
"0.5907837",
"0.5906147",
"0.58372724",
"0.5820502",
"0.5797337",
"0.575836",
"0.5687807",
"0.56840444",
"0.56556374",
"0.56395537",
"0.5559454",
"0.5515556",
"0.54998755",
"0.54887193",
"0.54826784",
"0.5477... | 0.6996779 | 0 |
Get a dict of all the links in the specified bundle. Returns a dict where the keys are the link names (strings) and the values are LinkDetails or DraftLinkDetails tuples. | def get_bundle_links(bundle_uuid, use_draft=None):
bundle = get_bundle(bundle_uuid)
if use_draft and use_draft in bundle.drafts: # pylint: disable=unsupported-membership-test
draft_uuid = bundle.drafts[use_draft] # pylint: disable=unsubscriptable-object
return get_draft(draft_uuid).links
e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bundle_version_links(bundle_uuid, version_number):\n if version_number == 0:\n return {}\n version_info = get_bundle_version(bundle_uuid, version_number)\n return {\n name: LinkDetails(\n name=name,\n direct=LinkReference(**link[\"direct\"]),\n indire... | [
"0.7305899",
"0.68209445",
"0.6084511",
"0.5888304",
"0.58443224",
"0.58205533",
"0.57978463",
"0.57962805",
"0.57638013",
"0.56552774",
"0.56552774",
"0.56552774",
"0.56552774",
"0.56552774",
"0.5595823",
"0.55944407",
"0.5573283",
"0.5561761",
"0.5560517",
"0.55239433",
"0.... | 0.73346376 | 0 |
Get the metadata of the specified file. | def get_bundle_file_metadata(bundle_uuid, path, use_draft=None):
assert isinstance(bundle_uuid, UUID)
files_dict = get_bundle_files_dict(bundle_uuid, use_draft=use_draft)
try:
return files_dict[path]
except KeyError:
raise BundleFileNotFound( # lint-amnesty, pylint: disable=raise-missin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_metadata(self, filename):\n return self.execute_json(filename)[0]",
"def get_metadata(self, file_id):\n pass",
"def metadata_file(self):\n return self._metadata_file",
"def _get_file_meta(cls, file=None, file_path=None):\n if not file and file_path:\n file = ope... | [
"0.83143204",
"0.7956004",
"0.76730394",
"0.738435",
"0.73713607",
"0.72093016",
"0.7183509",
"0.7126052",
"0.7085625",
"0.7016068",
"0.70038253",
"0.6963683",
"0.69587713",
"0.68719065",
"0.6854037",
"0.683621",
"0.6826863",
"0.68247527",
"0.6806132",
"0.6795918",
"0.679283"... | 0.0 | -1 |
Read all the data in the given bundle file and return it as a binary string. Do not use this for large files! | def get_bundle_file_data(bundle_uuid, path, use_draft=None):
metadata = get_bundle_file_metadata(bundle_uuid, path, use_draft)
with requests.get(metadata.url, stream=True) as r:
return r.content | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_binary(fname):\n with open(fname, 'rb+') as f_name:\n data = f_name.read()\n return data",
"def read_binary(self):\n with self.open(\"rb\") as f:\n return f.read()",
"def get_binary(self, filepath):\n with open(filepath, \"rb\") as f:\n return b64encode(... | [
"0.71974015",
"0.66317815",
"0.66020185",
"0.6489387",
"0.64036137",
"0.62352324",
"0.6202045",
"0.6177646",
"0.6148498",
"0.614845",
"0.6109348",
"0.61091924",
"0.6097358",
"0.6048688",
"0.6039264",
"0.59987104",
"0.59759474",
"0.5970356",
"0.596682",
"0.5955203",
"0.5937059... | 0.628166 | 5 |
Create or overwrite the file at 'path' in the specified draft with the given contents. To delete a file, pass contents=None. If you don't know the draft's UUID, look it up using get_or_create_bundle_draft() Does not return anything. | def write_draft_file(draft_uuid, path, contents):
api_request('patch', api_url('drafts', str(draft_uuid)), json={
'files': {
path: encode_str_for_draft(contents) if contents is not None else None,
},
}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_file(path: Path, content: str) -> None:\n path.touch()\n with path.open(\"w\") as f:\n f.write(content)",
"def put_contents( path, name, contents, dryrun = False, get_config=lambda: {}, verbose=False ):\n t_file_fh, t_file_name = tempfile.mkstemp()\n os.close(t_file_fh)\n print(c... | [
"0.59362435",
"0.5571267",
"0.5565971",
"0.55636615",
"0.55125356",
"0.5481879",
"0.5437837",
"0.5421367",
"0.5293984",
"0.5231956",
"0.5211434",
"0.51726305",
"0.5162061",
"0.5162061",
"0.5150922",
"0.51438993",
"0.51366174",
"0.5113197",
"0.5112223",
"0.51041156",
"0.509784... | 0.80568475 | 0 |
Create or replace the link with the given name in the specified draft so that it points to the specified bundle version. To delete a link, pass bundle_uuid=None, version=None. If you don't know the draft's UUID, look it up using get_or_create_bundle_draft() Does not return anything. | def set_draft_link(draft_uuid, link_name, bundle_uuid, version):
api_request('patch', api_url('drafts', str(draft_uuid)), json={
'links': {
link_name: {"bundle_uuid": str(bundle_uuid), "version": version} if bundle_uuid is not None else None,
},
}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_or_create_bundle_draft(bundle_uuid, draft_name):\n bundle = get_bundle(bundle_uuid)\n try:\n return get_draft(bundle.drafts[draft_name]) # pylint: disable=unsubscriptable-object\n except KeyError:\n # The draft doesn't exist yet, so create it:\n response = api_request('post',... | [
"0.58408153",
"0.51587373",
"0.49001387",
"0.4804741",
"0.47611052",
"0.47401834",
"0.46968883",
"0.46876737",
"0.45107222",
"0.4470004",
"0.44540083",
"0.4445877",
"0.44092384",
"0.44081253",
"0.44045332",
"0.44012755",
"0.43953812",
"0.4391029",
"0.43773264",
"0.43721762",
... | 0.8172148 | 0 |
Given a string, return UTF8 representation that is then base64 encoded. | def encode_str_for_draft(input_str):
if isinstance(input_str, str):
binary = input_str.encode('utf8')
else:
binary = input_str
return base64.b64encode(binary) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def my_base64encode(s):\n return base64.b64encode(s).decode(\"utf-8\")",
"def convert_to_base64(str):\n str_bytes = str.encode(\"utf-8\")\n str_bytes_base64 = base64.b64encode(str_bytes)\n str_base64 = str_bytes_base64.decode(\"utf-8\")\n return str_base64",
"def base64_encode_string(string):\n ... | [
"0.8349008",
"0.82634866",
"0.8113166",
"0.7998077",
"0.7926648",
"0.77931964",
"0.7790754",
"0.7628252",
"0.7628252",
"0.7508145",
"0.7495968",
"0.7376367",
"0.7362331",
"0.7323071",
"0.7307147",
"0.72765124",
"0.7257662",
"0.7248031",
"0.72335285",
"0.72253436",
"0.7190259"... | 0.72494906 | 17 |
Ensure that the given URL Blockstore is a URL accessible from the end user's browser. | def force_browser_url(blockstore_file_url):
# Hack: on some devstacks, we must necessarily use different URLs for
# accessing Blockstore file data from within and outside of docker
# containers, but Blockstore has no way of knowing which case any particular
# request is for. So it always returns a URL s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_url(self):\n pass",
"def check_url_invalidity(self) -> bool:\n validate = URLValidator()\n try:\n validate(self.args.url)\n return False\n except ValidationError:\n return True",
"def check_url(url=None, parse_url=None):\n return ... | [
"0.6467403",
"0.61517715",
"0.61352235",
"0.6027143",
"0.6014926",
"0.6010201",
"0.6007184",
"0.599208",
"0.59750557",
"0.5965351",
"0.5957245",
"0.5952767",
"0.5918729",
"0.5906625",
"0.589159",
"0.58743834",
"0.58737737",
"0.58627915",
"0.5818365",
"0.581255",
"0.5793624",
... | 0.66461307 | 0 |
Initialize the weights of the model. The weights are initialized to small random values and the biases to zero. Weights are stored in the variable dictionary named self.params. | def initialize_weights(self, input_dim, std_dev=1e-2):
self.params = {}
hidden_size = self.hidden_size
num_classes = self.num_classes
num_layers = self.num_layers
#############################################################################
# TODO: Initialize th... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_parameters(self):\n stdv = 1. / math.sqrt(self.weight.data.size(1))\n self.weight.data.uniform_(-stdv, stdv)\n if self.bias is not None:\n self.bias.data.uniform_(-stdv, stdv)",
"def init_weights(model):\n ...",
"def init_weights(self):\n \n self.w ... | [
"0.84454",
"0.83300084",
"0.83285135",
"0.8306398",
"0.81789726",
"0.8172356",
"0.81278425",
"0.80801696",
"0.80633783",
"0.8052339",
"0.8016938",
"0.8014385",
"0.7996117",
"0.7978683",
"0.7978683",
"0.7978683",
"0.79736733",
"0.791141",
"0.791141",
"0.7864369",
"0.7859745",
... | 0.7425541 | 56 |
Computes the forward pass of a fully connected layer. A fully connected / affine / linear / dense layer applies a linear transformation | def fully_connected_forward(self, X, W, b):
#############################################################################
# TODO: Implement the forward pass of a fully connected layer and store #
# the variables needed for the backward pass (gradient computation) #
#... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, x):\n\n\t\t## Conv layers\n\t\tx = self.avgpool(F.tanh(self.conv1(x)))\n\t\tx = self.avgpool(F.tanh(self.conv2(x)))\n\t\tx = F.tanh(self.conv3(x))\n\n\t\t## Flatten\n\t\tx = x.view(x.size(0), -1)\n\n\t\t## Fully connected layers\n\t\tx = F.tanh(self.fc1(x))\n\t\tx = self.fc2(x)\n\n\t\tx = F.softm... | [
"0.70442754",
"0.70390433",
"0.6991137",
"0.69601756",
"0.6937577",
"0.68354714",
"0.6818054",
"0.68100935",
"0.67688334",
"0.6750614",
"0.6743198",
"0.67403555",
"0.672098",
"0.6709776",
"0.6684743",
"0.6683617",
"0.6679447",
"0.6648096",
"0.6629698",
"0.66107196",
"0.659222... | 0.643094 | 34 |
Computes the backward pass for a fully connected layer layer. | def fully_connected_backward(self, dUpper, cache):
X, W, b = cache
#############################################################################
# TODO: Implement the affine backward pass. #
#################################################################... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def backward_pass(self):\r\n # the gradient of cross-entropy on top of softmax is (t-y)\r\n back_output = (self.targets - self.y) / self.y.shape[0]\r\n\r\n for layer in reversed(self.layers):\r\n back_output = layer.backward_pass(back_output)",
"def backward_pass(self, loss):\n\n ... | [
"0.7731608",
"0.7610461",
"0.73420644",
"0.72815114",
"0.72757447",
"0.72352403",
"0.7125551",
"0.7122199",
"0.7122199",
"0.71118426",
"0.7089552",
"0.70816886",
"0.7054744",
"0.7054744",
"0.69949067",
"0.6970302",
"0.6941496",
"0.6925301",
"0.6913951",
"0.69076765",
"0.68970... | 0.0 | -1 |
Computes the forward pass for sigmoid activation function. | def sigmoid_forward(self, x):
#############################################################################
# TODO: Implement the Sigmoid forward pass. #
#############################################################################
out = 1 / (1 + ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(inputs,weights,function=sigmoid,step=-1):\n if step == 0:\n return inputs\n elif step == -1:\n step = len(weights) #go to output layer \n output = np.append(1, inputs)\n for i in range(step):\n output = np.append(1, function(np.dot(weights[i], output))) #calculating ac... | [
"0.77107674",
"0.7618095",
"0.75897205",
"0.75454354",
"0.74707013",
"0.7382036",
"0.7337359",
"0.72318465",
"0.718649",
"0.7181982",
"0.7180619",
"0.71706724",
"0.71224266",
"0.71222806",
"0.71213764",
"0.71071005",
"0.7100093",
"0.70848095",
"0.70848095",
"0.7031294",
"0.70... | 0.7314022 | 7 |
Computes the backward pass for a sigmoid activation function. | def sigmoid_backward(self, dUpper, cache):
out = cache
#############################################################################
# TODO: Implement the backward pass for the sigmoid function. #
#############################################################################... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sigmoid_backward(dout, cache):\n dx, x = None, cache\n\n f = lambda x: 1/(1 + np.exp(-x)) # activation function (sigmoid)\n\n fun = f(x)\n\n dx = np.multiply(fun, (1-fun))\n dx = np.multiply(dx,dout)\n\n return dx",
"def sigmoid_backward(dA, Z):\r\n dsig = sigmoid(Z) * (1 - sigmoid(Z))\... | [
"0.7805891",
"0.76624775",
"0.75691813",
"0.7389613",
"0.72973096",
"0.72793454",
"0.72200996",
"0.72104853",
"0.72072583",
"0.7176278",
"0.7166796",
"0.71486557",
"0.712793",
"0.7086538",
"0.7080874",
"0.70740503",
"0.7072516",
"0.70650476",
"0.7015476",
"0.70073223",
"0.698... | 0.7265221 | 6 |
Compute the softmax function for each row of the input x. | def softmax(self, x):
#############################################################################
# TODO: Implement the softmax function. #
#############################################################################
meanValue = np.mean(x, axis=1)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def softmax(self, x):\n\n out = np.zeros(x.shape)\n for i in range(x.shape[0]):\n max_x = x[i] - np.max(x[i])\n out[i] = np.exp(max_x) / np.sum(np.exp(max_x), axis=0)\n\n return out",
"def softmax(x: npt.NDArray) -> npt.NDArray:\n row_wise_max = np.max(x, axis=1).res... | [
"0.8561103",
"0.8524938",
"0.8485795",
"0.84788704",
"0.84645116",
"0.84644413",
"0.84097195",
"0.8395736",
"0.8390502",
"0.8372838",
"0.8333905",
"0.8323554",
"0.8323105",
"0.8323105",
"0.8323105",
"0.8323105",
"0.8323105",
"0.8323105",
"0.8323105",
"0.8323105",
"0.8309577",... | 0.8095466 | 48 |
Jointly computes the softmax and cross entropy loss. This function should return the loss and its gradient with respect to the scores. | def softmax_cross_entropy_loss(self, scores, labels):
#############################################################################
# TODO: Compute for the softmax cross entropy loss #
#############################################################################
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loss_and_grad(self, X, y):\n\n # Initialize the loss and gradient to zero.\n loss = 0.0\n grad = np.zeros_like(self.W)\n grad_tmp = np.zeros_like(self.W)\n num_classes = self.W.shape[0] # C = num_classes\n num_train = X.shape[0]\n \n # ==================================================... | [
"0.7552237",
"0.74971294",
"0.7361533",
"0.7297716",
"0.7081309",
"0.7060637",
"0.70372635",
"0.70132375",
"0.7011851",
"0.698142",
"0.69772744",
"0.6949587",
"0.69317883",
"0.6925177",
"0.69105256",
"0.6898687",
"0.6895407",
"0.68951285",
"0.6879018",
"0.682814",
"0.68271774... | 0.7278144 | 4 |
This functions performs the forward pass which computes for the class scores given the input. | def network_forward(self, X):
#############################################################################
# TODO: Perform a forward pass on the network and store the caches of #
# each layer inside the cache_list #
###############... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _forward(self, x):\n # Computing: `x * w^T`\n score = CArray(x.dot(self.w.T)).todense().ravel() + self.b\n\n scores = CArray.ones(shape=(x.shape[0], self.n_classes))\n scores[:, 0] = -score.ravel().T\n scores[:, 1] = score.ravel().T\n\n return scores",
"def _forward(... | [
"0.7152157",
"0.67411566",
"0.6440144",
"0.6402874",
"0.64024365",
"0.637545",
"0.62795955",
"0.6259711",
"0.62537515",
"0.62476677",
"0.6244945",
"0.62178695",
"0.62178695",
"0.62093914",
"0.61990786",
"0.6183218",
"0.6170751",
"0.61354846",
"0.61190605",
"0.61190605",
"0.61... | 0.61028564 | 21 |
This functions performs the backward pass which computes for the gradients of the loss with respect to every parameter. | def network_backward(self, dloss, cache_list):
#############################################################################
# TODO: Implement the backward pass. #
#############################################################################
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def backward(self, inputs, grad_loss_input):\n raise NotImplementedError",
"def backward_pass(architecture,gradient_layerwise,grad_weights,grad_bias):\n \n for layer in range(len(architecture)-1,-1,-1):\n X_input,X_output,weightsi,biasi,X_input_im2col,imi,output_shapei,kernel_shapei,strid... | [
"0.8062878",
"0.80259913",
"0.7828948",
"0.7777686",
"0.77527696",
"0.7702246",
"0.7693619",
"0.76381147",
"0.76381147",
"0.7636189",
"0.7616303",
"0.7592515",
"0.7568821",
"0.75661427",
"0.7554769",
"0.7545626",
"0.7532964",
"0.75251085",
"0.7524329",
"0.7416668",
"0.7412596... | 0.6830542 | 84 |
Compute the loss and gradients for an iteration. | def loss(self, X, y=None, lambda_reg=0.0):
# Unpack variables from the params dictionary
N, D = X.shape
# Compute the forward pass
#############################################################################
# TODO: Perform the forward pass, computing the class scores ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self) -> None:\n for _ in range(self.epochs):\n for x, y in zip(self.x_train, self.y_train):\n\n weights_gradient = [\n None for weight in self.weights\n ] # Initializing weight gradients for each layer which are going to be used to upda... | [
"0.7177683",
"0.70011306",
"0.69751114",
"0.68704146",
"0.6854747",
"0.6794312",
"0.67768157",
"0.67635286",
"0.6713901",
"0.6713034",
"0.66898924",
"0.66752005",
"0.665963",
"0.6622884",
"0.6610839",
"0.66093385",
"0.66018146",
"0.65964544",
"0.6590787",
"0.6583664",
"0.6579... | 0.0 | -1 |
Computes the forward pass for the tanh activation function. | def tanh_forward(self, x):
#############################################################################
# TODO: Implement the tanh forward pass. #
#############################################################################
out = np.tanh(x)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward_hidden_activation(self, X):\n return np.tanh(X)",
"def test_tanh_activation(self):\n self.assertEqual([0.099668, 0.099668], list(\n af.TanH().output(np.array([0.1, 0.1]))))\n self.assertEqual([0.990066, 0.990066], list(\n af.TanH().derivative(np.array([0.1, ... | [
"0.7288412",
"0.7224226",
"0.71908355",
"0.7186722",
"0.7179838",
"0.71629184",
"0.71265453",
"0.7122386",
"0.7074787",
"0.7027048",
"0.69930476",
"0.69930476",
"0.6986668",
"0.6968281",
"0.6967701",
"0.6929699",
"0.6904969",
"0.68929416",
"0.68862855",
"0.6878756",
"0.687386... | 0.8011069 | 0 |
Computes the backward pass for tanh activation function. | def tanh_backward(self, dUpper, cache):
out = cache
#############################################################################
# TODO: Implement the tanh backward pass. #
#############################################################################
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tanh_backward(dA, internal_params):\n Z = internal_params\n Zt=tanh(Z)\n dzp=np.power(Zt,2)\n print(dzp.shape)\n dZ=np.multiply(dzp,dA)\n return dZ\n # raise NotImplementedError",
"def tanh_backward(dA, Z):\n\n s = 1 - tanh(Z)**2\n dZ = dA * s\n\n assert (dZ.shape == Z.shape)\n\... | [
"0.74967176",
"0.73036784",
"0.72315353",
"0.7112281",
"0.7106927",
"0.70630103",
"0.70371467",
"0.70149505",
"0.69678706",
"0.6954078",
"0.6912582",
"0.6871865",
"0.6849014",
"0.6831122",
"0.6824879",
"0.6811179",
"0.68090993",
"0.6785766",
"0.67692584",
"0.6741517",
"0.6728... | 0.70860624 | 5 |
Computes the forward pass of a rectified linear unit (ReLU). | def relu_forward(self, x):
#out = None
#############################################################################
# TODO: Implement the ReLU forward pass. #
#############################################################################
out = n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def relu_forward(x):\n ############################################################################\n # TODO: Implement the ReLU forward pass. #\n ############################################################################\n ######################################################... | [
"0.6923425",
"0.6670239",
"0.6663412",
"0.6650045",
"0.6630312",
"0.65392053",
"0.64895386",
"0.648836",
"0.64600945",
"0.6429588",
"0.6399773",
"0.63981783",
"0.63528794",
"0.63357466",
"0.63077855",
"0.62966233",
"0.6285175",
"0.6278084",
"0.62459034",
"0.62427825",
"0.6203... | 0.67316556 | 1 |
Computes the backward pass for a layer of rectified linear units (ReLUs). | def relu_backward(self, dUpper, cache):
x = cache
#############################################################################
# TODO: Implement the ReLU backward pass. #
#############################################################################
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def backward(ctx, grad_output):\n loss, reg, u, lbda = ctx.saved_tensors\n\n device = u.device\n\n # do clever computations\n eps = 1e-10\n grad, = torch.autograd.grad(loss, u, only_inputs=True,\n retain_graph=True)\n x = (u - eps * grad)... | [
"0.6948249",
"0.6898323",
"0.6847992",
"0.6847992",
"0.68477255",
"0.68407637",
"0.68200904",
"0.6768128",
"0.67572653",
"0.67565167",
"0.67562467",
"0.6743265",
"0.67394495",
"0.6715497",
"0.67090523",
"0.67006433",
"0.669643",
"0.669643",
"0.66886026",
"0.6666757",
"0.66667... | 0.70406467 | 0 |
Train Linear Regression using stochastic gradient descent. | def train(self, X, y, learning_rate=1e-3, lambda_reg=0.0, num_iters=100, std_dev=1e-2,
batch_size=200, verbose=False, one_step=False):
num_train, dim = X.shape
self.initialize_weights(dim, std_dev)
loss_history = []
for it in range(num_iters):
loss, grads = self... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self, loss_function='logistic',\n lr=0.1, decay=0.5, max_iters=3000, batch_size=128, **kwargs):\n return super(LogisticRegression, self).train('sgd', loss_function,\n lr=lr,\n decay... | [
"0.7195158",
"0.71620756",
"0.71615815",
"0.71331125",
"0.70809966",
"0.7030623",
"0.70056266",
"0.69661504",
"0.6926212",
"0.690336",
"0.68971825",
"0.6893532",
"0.6856372",
"0.6845524",
"0.6811018",
"0.6810703",
"0.6780936",
"0.67630255",
"0.6749425",
"0.67289364",
"0.67193... | 0.631829 | 94 |
Predict labels for test data using this classifier. | def predict(self, X, return_scores=False):
scores, cache_list = self.network_forward(X)
probs = self.softmax(scores)
prediction = np.argmax(probs, axis=1)
if return_scores:
return prediction, scores
else:
return prediction | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(self):\n self.get_test_data()\n predicted_labels = []\n for row in self.test_data:\n predicted_labels.append(DecisionTree.predict_row(self.classifier, row))\n return predicted_labels",
"def predict(self, X_test):\n\n # Predict Label 0\n i = 0\n ... | [
"0.811686",
"0.80712956",
"0.78437126",
"0.7705113",
"0.7671728",
"0.7612549",
"0.7588116",
"0.7575117",
"0.7493927",
"0.7471557",
"0.74658227",
"0.74150544",
"0.7381984",
"0.73806554",
"0.73481315",
"0.73377925",
"0.72906667",
"0.72607785",
"0.7221459",
"0.72066003",
"0.7181... | 0.0 | -1 |
Given gradient, will update the layer weights | def update_params(self, update_weights, update_bias):
if not self.trainable:
return
update_weights = np.squeeze(update_weights)
update_bias = np.squeeze(update_bias)
# some have non-trainable parameters, in addition to the
# weights and biases
if len(self.p... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def perform_update(self, gradient):\n w = sys.modules[self.shared_mem_name].__dict__[\"w\"]\n w -= self.learning_rate * gradient",
"def update_weights(self, X, Y, learning_rate):\n grads = self.calculate_gradients(X, Y)\n #update weights and biases\n self.weights[0] = self.weig... | [
"0.7662058",
"0.756946",
"0.7527331",
"0.73841107",
"0.7367387",
"0.72501403",
"0.7238229",
"0.7204643",
"0.71658003",
"0.7152769",
"0.71068096",
"0.7099971",
"0.70949143",
"0.7080805",
"0.70684385",
"0.70570195",
"0.70487124",
"0.70160997",
"0.6927363",
"0.6914079",
"0.68777... | 0.6196009 | 100 |
Save input to the function, and output f(x) | def output(self, inputs):
# if max pool we need to save the indices for backproping
if self.max_pool:
self.indices = self.f(inputs)
out = np.take(inputs, self.indices)
else:
out = self.f(inputs)
# save input
self.current_input = inputs
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def saveall(self, f):\n if not self.enabled:\n return f\n @wraps(f)\n def wrapper(*args, **kwargs):\n func_name = f.__name__\n\n # save parameters\n params = dict(zip(f.__code__.co_varnames, args))\n params.update(kwargs)\n\n fo... | [
"0.61477196",
"0.60924035",
"0.60078835",
"0.5988158",
"0.5940525",
"0.58522373",
"0.57708055",
"0.57708055",
"0.5726363",
"0.5718889",
"0.57045394",
"0.56582165",
"0.56162596",
"0.55415493",
"0.5506286",
"0.5488552",
"0.54811376",
"0.5469306",
"0.5469306",
"0.5469306",
"0.54... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.