max):\\n max=prod #en max guardamos la distancia a la instancia que más cerca está de la que estamos recorriendo\\n indclase=j #guardas el índice de la clase a la que predices que pertenece\\n\\n if(indclase != trainingLabels[i]):\\n # recalcular pesos\\n self.weights[trainingLabels[i]].__radd__(trainingData[i]) #honek jarraian egiten du gehiketa pisu guztientzat\\n #pdb.set_trace() # esto es un break point para que puedas comprobar el formato de los datos\\n self.weights[indclase].__sub__(trainingData[i]) #honek jarraian egiten du kenketa pisu guztientzat\\n\\n\\n\\n\\n\\n ########################################################################################\\n # 1. i es el indice de un ejemplo (un item, f(x) de un ejemplo) del conjunto de entrenamiento.\\n # 2. Asi pues, en cada vuelta de este loop se trata un solo ejemplo\\n # por cada ejemplo calculareis el producto punto (dotProduct) w*item\\n # NOTAS: Recordad que cada ejemplo viene representado por varios rasgos (o features), es decir, es un vector de rasgos, tantos como nos marca el atributo self.features.\\n # Asi cada ejemplo es de dimension 1 filas y self.features).\\n # La dimension del vector w tambien es self.features, es decir, habra tantos pesos en w_rasgo dentro de w como rasgos haya en cada item de ejemplo\\n # Recordad tambien que es una clasificacion multiclase en este caso. Hay tantas clases como nos marca el atributo self.legalLabels\\n #########################################################################################\",\n \"def training(self, dataset, \\n epochs, r_loss, beta, \\n test= None ,Plotter=None):\\n\\n losses = []\\n val_losses = []\\n fidelities = []\\n val_fidelities = []\\n epochs = range(epochs)\\n\\n for i in tqdm(epochs, desc='Epochs'):\\n losses_epochs = []\\n fidelity_epochs =[]\\n for step, x in enumerate(dataset):\\n\\n loss, fidelity = self.training_step(x, r_loss, beta)\\n \\n # Logging.\\n losses_epochs.append(float(loss))\\n fidelity_epochs.append(float(fidelity))\\n \\n losses.append(np.mean(losses_epochs))\\n fidelities.append(np.mean(fidelity_epochs))\\n \\n if test:\\n val_losses_epochs = []\\n val_fidelity_epochs = []\\n\\n for step, x in enumerate(test):\\n\\n val_loss, val_fidelity = self.validating_step(x, r_loss, beta)\\n \\n # Logging.\\n val_losses_epochs.append(float(val_loss))\\n val_fidelity_epochs.append(float(val_fidelity))\\n \\n val_losses.append(np.mean(val_losses_epochs))\\n val_fidelities.append(np.mean(val_fidelity_epochs))\\n\\n if Plotter != None:\\n if test:\\n Plotter.plot([losses,val_losses]) \\n else:\\n Plotter.plot(losses)\\n \\n\\n return losses, val_losses, fidelities, val_fidelities\",\n \"def train(self, X, y, batch_size=8, learning_rate=1, n_steps=100):\\n self.training_w = np.zeros((n_steps, self.n_in+1))\\n self.training_loss = np.zeros(n_steps)\\n for s in tqdm(range(n_steps)):\\n # draw a random batch\\n batch_idx = np.random.choice(X.shape[0], batch_size, replace=False)\\n # compute and store mean loss\\n self.training_loss[s] = np.mean(self.loss(y[batch_idx], self.predict(X[batch_idx])))\\n # store current weights\\n self.training_w[s,:self.n_in] = self.w\\n self.training_w[s,-1] = self.b\\n # perform a gradient descent step\\n self.gradient_descent_step(X[batch_idx], y[batch_idx], learning_rate)\",\n \"def train(self, trainingData, trainingLabels, validationData, validationLabels): \\n \\n # might be useful in your code later...\\n # this is a list of all features in the training set.\\n self.features = list(set([ f for datum in trainingData for f in datum.keys() ]));\\n \\n if (self.automaticTuning):\\n kgrid = [0.001, 0.01, 0.05, 0.1, 0.5, 1, 5, 10, 20, 50]\\n else:\\n kgrid = [self.k]\\n \\n self.trainAndTune(trainingData, trainingLabels, validationData, validationLabels, kgrid)\",\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):\\n p = self._params\\n if self.train_data != None:\\n tens_to_log = self.params.tens_to_log\\n logging_hook = tf.train.LoggingTensorHook(tensors = tens_to_log,\\n every_n_iter = p.logging_step,\\n )\\n t_fn = tf.estimator.inputs.numpy_input_fn(x = {\\\"x\\\": self.train_data[\\\"x\\\"]},\\n y = self.train_data[\\\"y\\\"],\\n batch_size = p.batch_size,\\n num_epochs = None,\\n shuffle = True,\\n )\\n self._model.train(input_fn = t_fn,\\n steps = self.params.training_steps,\\n hooks = [logging_hook],\\n )\\n \\n if self.eval_data != None:\\n e_fn = tf.estimator.inputs.numpy_input_fn(x = {\\\"x\\\": self.eval_data[\\\"x\\\"]},\\n y = self.eval_data[\\\"y\\\"],\\n num_epochs = 1,\\n shuffle = False,\\n )\\n eval_results = self.model.evaluate(input_fn = e_fn,\\n checkpoint_path = self.model_dir,\\n )\\n print(eval_results)\",\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 network_training(batch_size, cost, iterations, data_input, label_input, minimization_step, pred, sess,\\n test_labels, test_vec, training_labels, training_vec):\\n\\n # Define list to keep track of the loss and accuracy\\n all_costs = []\\n all_test_costs = []\\n all_accuracy = [0]\\n all_test_accuracy = [0]\\n\\n # Set the range for looping to train the neural network\\n for i in range(iterations + 1):\\n # To prevent slicing will be out of range\\n offset = int(i * batch_size % len(training_vec))\\n\\n # Epoch wise training data shuffling\\n if offset + batch_size >= len(training_vec):\\n training_vec, training_labels = shuffled_copies(training_vec, training_labels)\\n test_vec, test_labels = shuffled_copies(test_vec, test_labels)\\n\\n batch_samples = training_vec[offset:offset + batch_size]\\n batch_labels = training_labels[offset:offset + batch_size]\\n\\n # Calculate for every iteration the training and test loss\\n _, current_cost = sess.run([minimization_step, cost],\\n # feed_dict={data_input: training_vec,\\n # label_input: training_labels})\\n feed_dict={data_input: batch_samples,\\n label_input: batch_labels})\\n\\n test_cost = sess.run(cost, feed_dict={data_input: test_vec,\\n label_input: test_labels})\\n\\n # Get the accuracy for the first 100 iterations in step of 5, because this is a steep part in the graph\\n if i in range(0, 101) and i % 5 == 0:\\n accuracy_sess = get_accuracy(data_input, label_input, pred, sess, training_labels, training_vec,\\n offset=offset, batch_size=batch_size)\\n accuracy_sess_test = get_accuracy(data_input, label_input, pred, sess, test_labels, test_vec)\\n\\n # Thereafter get the accuracy for every 20th iteration\\n if i in range(102, iterations + 1) and i % 20 == 0:\\n accuracy_sess = get_accuracy(data_input, label_input, pred, sess, training_labels, training_vec,\\n offset=offset, batch_size=batch_size)\\n accuracy_sess_test = get_accuracy(data_input, label_input, pred, sess, test_labels, test_vec)\\n\\n # Check every 50th loop how well the prediction is\\n if i % 50 == 0:\\n print(\\\"accuracy : {0:.2f}%\\\".format(accuracy_sess))\\n print(\\\"STEP: {} | Cost: {}\\\".format(i, current_cost))\\n\\n # Add the los and accuracy to the defined lists\\n all_costs.append(current_cost)\\n all_test_costs.append(test_cost)\\n all_accuracy.append(accuracy_sess)\\n all_test_accuracy.append(accuracy_sess_test)\\n\\n return all_accuracy, all_costs, all_test_accuracy, all_test_costs, test_labels, test_vec, training_labels, \\\\\\n training_vec\",\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 train(features, targets, weights, bias):\\n # see gradient_descent for explanation\\n epochs = 100\\n learning_rate = 0.1\\n\\n picture_nb = 2\\n\\n # Print current accuracy. How many people have been classified as sick/healthy correctly?\\n predictions = predict(features, weights, bias)\\n print(\\\"Accuracy: \\\", np.mean(predictions == targets))\\n\\n for epoch in range(epochs):\\n if epoch % 10 == 0:\\n # get normalized scores\\n predictions = activation(pre_activation(features, weights, bias))\\n # compare with targets to see how bad our algorithm is\\n print(\\\"Cost = %s\\\" % cost(predictions, targets))\\n # Replot graph. Check in create_dataset for explanation of parameters\\n if picture_nb == 2:\\n plt.plot(features[:, 0], (weights[0] * features[:, 0] + bias) / -weights[1], color='red')\\n elif picture_nb == 11:\\n plt.plot(features[:, 0], (weights[0] * features[:, 0] + bias) / -weights[1], color='green')\\n else:\\n plt.plot(features[:, 0], (weights[0] * features[:, 0] + bias) / -weights[1], color='orange')\\n picture_nb+=1\\n\\n # Initialize gradients\\n # weights_gradients is 2D array with 2 values\\n weights_gradients = np.zeros(weights.shape)\\n bias_gradient = 0\\n # Go through each row\\n for feature, target in zip(features, targets):\\n # Compute prediction\\n z = pre_activation(feature, weights, bias)\\n # Get normalized score\\n y = activation(z)\\n # Update gradients based on formulas established before. Look at gradient_descent to understand what we\\n # are doing. Also, the formulas are below, just before the call of the function train.\\n weights_gradients += (y - target) * derivative_activation(z) * feature\\n # no multiplication of feature because it does not depend on some coordinates.\\n bias_gradient += (y - target) * derivative_activation(z)\\n\\n # Update variables. These are the lines that result the cost to get reduced.\\n weights = weights - learning_rate * weights_gradients\\n bias = bias - learning_rate * bias_gradient\\n\\n # Print final accuracy. How many people have been classified as sick/healthy correctly?\\n predictions = predict(features, weights, bias)\\n print(\\\"Accuracy: \\\", np.mean(predictions == targets))\\n\\n plt.scatter(features[:, 0], features[:, 1], s=40, c=targets, cmap=plt.cm.Spectral)\\n plt.savefig(\\\"DataPointsLineEvolution.png\\\")\\n # legend for understanding\\n plt.legend(['Original division', 'New division', 'New division', 'New division', 'New division', 'New division',\\n 'New division', 'New division', 'New division', 'Final division'], loc='upper left')\\n # save picture of data points drawn.\\n plt.savefig(\\\"DataPointsLineEvolutionLegend.png\\\")\",\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 online_smd(dataset_name='mnist',\\n init_lr=1e-1,\\n momentum=0.9,\\n num_steps=20000,\\n middle_decay=False,\\n steps_per_update=10,\\n smd=True,\\n steps_look_ahead=5,\\n num_meta_steps=10,\\n steps_per_eval=100,\\n batch_size=100,\\n meta_lr=1e-2,\\n print_step=False,\\n effective_lr=True,\\n negative_momentum=True,\\n optimizer='momentum',\\n stochastic=True,\\n exp_folder='.'):\\n dataset = get_dataset(dataset_name)\\n dataset_train = get_dataset(\\n dataset_name) # For evaluate training progress (full epoch).\\n dataset_test = get_dataset(\\n dataset_name, test=True) # For evaluate test progress (full epoch).\\n\\n if dataset_name == 'mnist':\\n input_shape = [None, 28, 28, 1]\\n elif dataset_name.startswith('cifar'):\\n input_shape = [None, 32, 32, 3]\\n\\n x = tf.placeholder(tf.float32, input_shape, name=\\\"x\\\")\\n y = tf.placeholder(tf.int64, [None], name=\\\"y\\\")\\n\\n if effective_lr:\\n init_lr_ = init_lr / (1.0 - momentum)\\n else:\\n init_lr_ = init_lr\\n\\n if negative_momentum:\\n init_mom_ = 1.0 - momentum\\n else:\\n init_mom_ = momentum\\n if dataset_name == 'mnist':\\n config = get_mnist_mlp_config(\\n init_lr_,\\n init_mom_,\\n effective_lr=effective_lr,\\n negative_momentum=negative_momentum)\\n elif dataset_name == 'cifar-10':\\n config = get_cifar_cnn_config(\\n init_lr_,\\n init_mom_,\\n effective_lr=effective_lr,\\n negative_momentum=negative_momentum)\\n else:\\n raise NotImplemented\\n with tf.name_scope('Train'):\\n with tf.variable_scope('Model'):\\n if dataset_name == 'mnist':\\n m = get_mnist_mlp_model(\\n config, x, y, optimizer=optimizer, training=True)\\n model = m\\n elif dataset_name == 'cifar-10':\\n m = get_cifar_cnn_model(\\n config, x, y, optimizer=optimizer, training=True)\\n model = m\\n with tf.name_scope('Test'):\\n with tf.variable_scope('Model', reuse=True):\\n if dataset_name == 'mnist':\\n mtest = get_mnist_mlp_model(config, x, y, training=False)\\n elif dataset_name == 'cifar-10':\\n mtest = get_cifar_cnn_model(config, x, y, training=False)\\n\\n final_lr = 1e-4\\n midpoint = num_steps // 2\\n\\n if dataset_name == 'mnist':\\n num_train = 60000\\n num_test = 10000\\n elif dataset_name.startswith('cifar'):\\n num_train = 50000\\n num_test = 10000\\n\\n lr_ = init_lr_\\n mom_ = init_mom_\\n bsize = batch_size\\n steps_per_epoch = num_train // bsize\\n steps_test_per_epoch = num_test // bsize\\n\\n train_xent_list = []\\n train_acc_list = []\\n test_xent_list = []\\n test_acc_list = []\\n lr_list = []\\n mom_list = []\\n step_list = []\\n log.info(\\n 'Applying decay at midpoint with final learning rate = {:.3e}'.format(\\n final_lr))\\n\\n if 'momentum' in optimizer:\\n mom_name = 'mom'\\n elif 'adam' in optimizer:\\n mom_name = 'beta1'\\n else:\\n raise ValueError('Unknown optimizer')\\n hp_dict = {'lr': init_lr, mom_name: momentum}\\n hp_names = hp_dict.keys()\\n hyperparams = dict([(hp_name, model.optimizer.hyperparams[hp_name])\\n for hp_name in hp_names])\\n grads = model.optimizer.grads\\n accumulators = model.optimizer.accumulators\\n new_accumulators = model.optimizer.new_accumulators\\n loss = model.cost\\n\\n # Build look ahead graph.\\n look_ahead_ops, hp_grad_ops, zero_out_ops = look_ahead_grads(\\n hyperparams, grads, accumulators, new_accumulators, loss)\\n\\n # Meta optimizer, use Adam on the log space.\\n meta_opt = LogOptimizer(tf.train.AdamOptimizer(meta_lr))\\n hp = [model.optimizer.hyperparams[hp_name] for hp_name in hp_names]\\n hp_grads_dict = {\\n 'lr': tf.placeholder(tf.float32, [], name='lr_grad'),\\n mom_name: tf.placeholder(\\n tf.float32, [], name='{}_grad'.format(mom_name))\\n }\\n hp_grads_plh = [hp_grads_dict[hp_name] for hp_name in hp_names]\\n hp_grads_and_vars = list(zip(hp_grads_plh, hp))\\n cgrad = {'lr': (-1e1, 1e1), mom_name: (-1e1, 1e1)}\\n cval = {'lr': (1e-4, 1e1), mom_name: (1e-4, 1e0)}\\n cgrad_ = [cgrad[hp_name] for hp_name in hp_names]\\n cval_ = [cval[hp_name] for hp_name in hp_names]\\n meta_train_op = meta_opt.apply_gradients(\\n hp_grads_and_vars, clip_gradients=cgrad_, clip_values=cval_)\\n\\n var_list = tf.global_variables()\\n ckpt = build_checkpoint(tf.global_variables())\\n write_op = write_checkpoint(ckpt, var_list)\\n read_op = read_checkpoint(ckpt, var_list)\\n\\n with tf.Session() as sess:\\n sess.run(tf.global_variables_initializer())\\n\\n exp_logger = _get_exp_logger(sess, exp_folder)\\n\\n def log_hp(hp_dict):\\n lr_ = hp_dict['lr']\\n mom_ = hp_dict['mom']\\n # Log current learning rate and momentum.\\n if negative_momentum:\\n exp_logger.log(ii, 'mom', 1.0 - mom_)\\n exp_logger.log(ii, 'log neg mom', np.log10(mom_))\\n mom__ = 1.0 - mom_\\n else:\\n exp_logger.log(ii, 'mom', mom_)\\n exp_logger.log(ii, 'log neg mom', np.log10(1.0 - mom_))\\n mom__ = mom_\\n\\n if effective_lr:\\n lr__ = lr_ * (1.0 - mom__)\\n eflr_ = lr_\\n else:\\n lr__ = lr_\\n eflr_ = lr_ / (1.0 - mom__)\\n exp_logger.log(ii, 'eff lr', eflr_)\\n exp_logger.log(ii, 'log eff lr', np.log10(eflr_))\\n exp_logger.log(ii, 'lr', lr__)\\n exp_logger.log(ii, 'log lr', np.log10(lr__))\\n exp_logger.flush()\\n return lr__, mom__\\n\\n # Assign initial learning rate and momentum.\\n m.optimizer.assign_hyperparam(sess, 'lr', lr_)\\n m.optimizer.assign_hyperparam(sess, 'mom', mom_)\\n train_iter = six.moves.xrange(num_steps)\\n if not print_step:\\n train_iter = tqdm(train_iter, ncols=0)\\n for ii in train_iter:\\n # Meta-optimization loop.\\n if ii == 0 or ii % steps_per_update == 0:\\n if ii < midpoint and smd:\\n if stochastic:\\n data_list = [\\n dataset.next_batch(bsize)\\n for step in six.moves.xrange(steps_look_ahead)\\n ]\\n # Take next few batches for last step evaluation.\\n eval_data_list = [\\n dataset.next_batch(bsize)\\n for step in six.moves.xrange(steps_look_ahead)\\n ]\\n else:\\n data_entry = dataset.next_batch(bsize)\\n data_list = [data_entry] * steps_look_ahead\\n # Use the deterministic batch for last step evaluation.\\n eval_data_list = [data_list[0]]\\n sess.run(write_op)\\n for ms in six.moves.xrange(num_meta_steps):\\n cost, hp_dict = meta_step(sess, model, data_list,\\n look_ahead_ops, hp_grad_ops,\\n hp_grads_plh, meta_train_op,\\n eval_data_list)\\n sess.run(read_op)\\n for hpname, hpval in hp_dict.items():\\n model.optimizer.assign_hyperparam(\\n sess, hpname, hpval)\\n lr_ = hp_dict['lr']\\n mom_ = hp_dict['mom']\\n else:\\n hp_dict = sess.run(model.optimizer.hyperparams)\\n lr_log, mom_log = log_hp(hp_dict)\\n lr_list.append(lr_log)\\n mom_list.append(mom_log)\\n\\n if ii == midpoint:\\n lr_before_mid = hp_dict['lr']\\n tau = (num_steps - midpoint) / np.log(lr_before_mid / final_lr)\\n\\n if ii > midpoint:\\n lr_ = np.exp(-(ii - midpoint) / tau) * lr_before_mid\\n m.optimizer.assign_hyperparam(sess, 'lr', lr_)\\n\\n # Run regular training.\\n if lr_ > 1e-6:\\n xd, yd = dataset.next_batch(bsize)\\n cost_, _ = sess.run(\\n [m.cost, m.train_op], feed_dict={\\n m.x: xd,\\n m.y: yd\\n })\\n\\n # Evaluate every certain number of steps.\\n if ii == 0 or (ii + 1) % steps_per_eval == 0:\\n test_acc = 0.0\\n test_xent = 0.0\\n train_acc = 0.0\\n train_xent = 0.0\\n\\n # Report full epoch training loss.\\n for jj in six.moves.xrange(steps_per_epoch):\\n xd, yd = dataset_train.next_batch(bsize)\\n xent_, acc_ = sess.run(\\n [m.cost, m.acc], feed_dict={\\n x: xd,\\n y: yd\\n })\\n train_xent += xent_ / float(steps_per_epoch)\\n train_acc += acc_ / float(steps_per_epoch)\\n step_list.append(ii + 1)\\n train_xent_list.append(train_xent)\\n train_acc_list.append(train_acc)\\n dataset_train.reset()\\n\\n # Report full epoch validation loss.\\n for jj in six.moves.xrange(steps_test_per_epoch):\\n xd, yd = dataset_test.next_batch(bsize)\\n xent_, acc_ = sess.run(\\n [mtest.cost, mtest.acc], feed_dict={\\n x: xd,\\n y: yd\\n })\\n test_xent += xent_ / float(steps_test_per_epoch)\\n test_acc += acc_ / float(steps_test_per_epoch)\\n test_xent_list.append(test_xent)\\n test_acc_list.append(test_acc)\\n dataset_test.reset()\\n\\n # Log training progress.\\n exp_logger.log(ii, 'train loss', train_xent)\\n exp_logger.log(ii, 'log train loss', np.log10(train_xent))\\n exp_logger.log(ii, 'test loss', test_xent)\\n exp_logger.log(ii, 'log test loss', np.log10(test_xent))\\n exp_logger.log(ii, 'train acc', train_acc)\\n exp_logger.log(ii, 'test acc', test_acc)\\n exp_logger.flush()\\n\\n if print_step:\\n log.info((\\n 'Steps {:d} T Xent {:.3e} T Acc {:.3f} V Xent {:.3e} V Acc {:.3f} '\\n 'LR {:.3e}').format(ii + 1, train_xent,\\n train_acc * 100.0, test_xent,\\n test_acc * 100.0, lr_))\\n\\n return Results(\\n step=np.array(step_list),\\n train_xent=np.array(train_xent_list),\\n train_acc=np.array(train_acc_list),\\n test_xent=np.array(test_xent_list),\\n test_acc=np.array(test_acc_list),\\n lr=np.array(lr_list),\\n momentum=np.array(mom_list))\",\n \"def fit(self, train_data_tuple, valid_data_tuple=None):\\n n_total = train_data_tuple[0].size\\n batch_loader = RatingsMiniBatchIterator(\\n *train_data_tuple,\\n batch_size=self.batch_size,\\n random_state=self.random_state)\\n\\n self.trace_epoch = []\\n self.trace_loss = []\\n self.trace_smooth_loss = []\\n self.trace_mae_train = []\\n self.trace_mae_valid = []\\n\\n self.all_loss = []\\n\\n ## Store list of L1 gradient norms for each parameter\\n self.trace_norm_per_param = dict()\\n for key in self.param_dict.keys():\\n self.trace_norm_per_param[key] = list()\\n self.trace_smooth_norm_per_param = dict()\\n for key in self.param_dict.keys():\\n self.trace_smooth_norm_per_param[key] = list()\\n\\n for epoch_count in range(self.n_epochs): \\n epoch = 1.0 * epoch_count\\n batch_loader.shuffle()\\n\\n for i, batch_tuple in enumerate(batch_loader):\\n\\n ## Compute loss and gradient\\n # loss : scalar float\\n # grad_dict : dict\\n # Keys are string names of individual parameters\\n # Values are autograd-generated numpy arrays\\n loss, grad_dict = self.calc_loss_and_grad_wrt_parameter_dict(\\n self.param_dict, batch_tuple)\\n\\n ## Rescale loss and gradient vectors\\n # So we always estimate the *per-example loss*\\n n_per_batch = batch_tuple[0].size\\n scale = 1.0 / n_per_batch\\n loss *= scale\\n for key, arr in grad_dict.items():\\n arr *= scale\\n self.all_loss.append(loss)\\n\\n ## Periodically report progress to stdout\\n ## & write to internal state attributes: self.trace_*\\n do_report_now = self.check_if_report_progress_now(\\n epoch_count, self.n_epochs, i, batch_loader.n_batches)\\n if do_report_now:\\n self.trace_epoch.append(epoch)\\n self.trace_loss.append(loss)\\n\\n # Compute MAE/MSE metrics on training and validation data\\n train_perf_dict = self.evaluate_perf_metrics(*train_data_tuple)\\n valid_perf_dict = self.evaluate_perf_metrics(*valid_data_tuple)\\n self.trace_mae_train.append(train_perf_dict['mae'])\\n self.trace_mae_valid.append(valid_perf_dict['mae'])\\n\\n # Compute 'smoothed' loss by averaging over last B batches\\n # Might remove some of the stochasticity in using only the\\n # loss from most recent batch.\\n smooth_loss = np.mean(self.all_loss[-batch_loader.n_batches:])\\n self.trace_smooth_loss.append(smooth_loss)\\n\\n # Compute L1 norm of gradient of each parameter\\n avg_grad_norm_str_list = []\\n for key, arr in grad_dict.items():\\n norm = np.mean(np.abs(arr))\\n self.trace_norm_per_param[key].append(norm)\\n cur_norm_str = \\\"grad_wrt_%s %11.5f\\\" % (key, norm)\\n avg_grad_norm_str_list.append(cur_norm_str)\\n avg_grad_norm_str = ' | '.join(avg_grad_norm_str_list)\\n\\n print(\\\"epoch %11.3f | loss_total % 11.5f | train_MAE % 11.5f | valid_MAE % 11.5f | %s\\\" % (\\n epoch, loss if epoch <= 2 else smooth_loss,\\n train_perf_dict['mae'], valid_perf_dict['mae'],\\n avg_grad_norm_str))\\n\\n ## Update each parameter by taking step in direction of gradient\\n epoch += n_per_batch / n_total \\n for key, arr in self.param_dict.items():\\n arr[:] = arr - self.step_size * grad_dict[key]\\n\\n # That's all folks.\",\n \"def train(self, x, y=None, **kwargs):\\n # fit for generator\\n if isinstance(x, types.GeneratorType):\\n # get train size, eval size\\n train_size = kwargs.get('train_size', 0)\\n eval_size = kwargs.get('eval_size', 0)\\n \\n # calculate steps_per_epoch\\n steps_per_epoch = self.steps_per_epoch\\n if not steps_per_epoch and train_size:\\n steps_per_epoch = math.ceil(train_size / self.batch_size)\\n if not steps_per_epoch:\\n raise Exception('You must specify `steps_per_epoch` argument if `train_size` is not set')\\n \\n # calculate validation steps\\n validation_steps = self.validation_steps\\n if not validation_steps and eval_size:\\n validation_steps = math.ceil(eval_size / self.batch_size)\\n if not validation_steps:\\n validation_steps = 1\\n \\n args = ['x', 'y', 'batch_size', 'epochs', 'verbose', 'steps_per_epoch',\\n 'callbacks', 'validation_split', 'validation_data', 'validation_steps',\\n 'validation_freq', 'class_weight', 'max_queue_size', 'sample_weight',\\n 'workers', 'use_multiprocessing', 'shuffle', 'initial_epoch']\\n keys = copy(list(kwargs.keys()))\\n for key in keys:\\n if key not in args: kwargs.pop(key)\\n \\n # fit generator\\n return self.model.fit_generator(x,\\n steps_per_epoch=steps_per_epoch,\\n epochs=self.epochs,\\n validation_data=kwargs.pop('validation_data'),\\n validation_steps=validation_steps,\\n callbacks=self.callbacks(),\\n **kwargs)\\n # fit for normal data\\n else:\\n args = ['generator', 'steps_per_epoch', 'epochs', 'verbose',\\n 'callbacks', 'validation_data', 'validation_steps',\\n 'validation_freq', 'class_weight', 'max_queue_size',\\n 'workers', 'use_multiprocessing', 'shuffle', 'initial_epoch']\\n keys = copy(list(kwargs.keys()))\\n for key in keys:\\n if key not in args: kwargs.pop(key)\\n # execute training\\n return self.model.fit(x=x,\\n y=y,\\n epochs=self.epochs,\\n batch_size=self.batch_size,\\n validation_data=kwargs.pop('validation_data'),\\n callbacks=self.callbacks(),\\n **kwargs)\",\n \"def fit(self, X, y):\\n\\n # compute number of minibatches for training, validation and testing\\n input_size = X.shape.eval()[0]\\n num_training_batches = input_size/self.mini_batch_size\\n\\n # define the (regularized) cost function, symbolic gradients, and updates\\n l2_norm_squared = sum([(layer.w**2).sum() for layer in self.layers])\\n cost = self.layers[-1].cost(self)+\\\\\\n 0.5*self.l2*l2_norm_squared/num_training_batches\\n grads = T.grad(cost, self.params)\\n updates = [(param, param-self.eta*grad)\\n for param, grad in zip(self.params, grads)]\\n\\n # define functions to train a mini-batch, and to compute the\\n # accuracy in validation and test mini-batches.\\n i = T.lscalar() # mini-batch index\\n train_mb = theano.function(\\n [i], cost, updates=updates,\\n givens={\\n self.x:\\n X[i*self.mini_batch_size: (i+1)*self.mini_batch_size],\\n self.y:\\n y[i*self.mini_batch_size: (i+1)*self.mini_batch_size]\\n })\\n \\n # Do the actual training\\n for epoch in xrange(self.epochs):\\n print(\\\"Training epoch number: {0}\\\".format(epoch))\\n for minibatch_index in xrange(num_training_batches):\\n iteration = num_training_batches*epoch+minibatch_index\\n cost_ij = train_mb(minibatch_index)\",\n \"def _nn_train_net(structure, training_set, optimizer, epochs, batch_size, verbose=1):\\n\\n # Preallocate output variables\\n net=[]\\n loss_stat=[]\\n\\n # Collect training time statistics\\n time_start = datetime.datetime.now()\\n\\n # Convert input data to be in float 32 (compression)\\n # Note: the conversion makes information loss\\n norm_data=training_set.copy().astype(np.float32)\\n\\n # Calculate input data statistics\\n mu=np.mean(norm_data[:,0])\\n sig=np.std(norm_data[:,0])\\n if sig==0: sig=1\\n norm_data[:,0]=(norm_data[:,0]-mu)/sig\\n\\n #Calculate the output factor of the net\\n min_out=np.min(norm_data[:,-1])\\n max_out=np.max(norm_data[:,-1])\\n output_factor=(max_out-min_out)\\n if output_factor == 0: output_factor=1\\n # Normalize the net output to be in [0, 1]\\n norm_data[:,-1]=(norm_data[:,-1]-min_out)/output_factor\\n\\n # New TF graph\\n with tf.Graph().as_default():\\n # Request initializer for net structure\\n values=_nn_initial_values(structure)\\n # Build net\\n net_variables=_nn_create(values)\\n data_in=net_variables[0]\\n data_out=net_variables[-1]\\n # Build optimizer\\n desired_out=tf.placeholder(dtype=tf.float32, shape=[None, structure[0]])\\n loss=tf.losses.mean_squared_error(data_out, desired_out)\\n opt=optimizer.minimize(loss)\\n\\n # Perform training\\n with tf.Session() as sess:\\n sess.run(tf.global_variables_initializer())\\n for epoch in range(epochs):\\n avg_cost=0.0\\n total_batch=np.ceil(norm_data.shape[0]/batch_size).astype(int)\\n\\n # Split samples to batches\\n batches = np.array_split(norm_data, total_batch)\\n\\n # For each batch\\n for i in range(total_batch):\\n _, c = sess.run([opt, loss],\\n feed_dict={\\n data_in: batches[i][:, 0:1],\\n desired_out: batches[i][:, 1:2]\\n })\\n\\n avg_cost += c / total_batch\\n\\n # Update statistics\\n loss_stat.append(avg_cost)\\n _log(verbose, 'Epoch %04d/%d: cost=%.9f' % (epoch+1, epochs, avg_cost), epoch>0)\\n\\n # Get the trained net's internal values\\n for v in net_variables[1:-1]:\\n net.append(sess.run(v))\\n\\n # Measure net training time\\n time_end = datetime.datetime.now()\\n time_diff = (time_end - time_start).total_seconds()\\n\\n _log(verbose, ' (mu: %.3f, sig: %.3f, fac: %.3f, omin: %.3f, training time: %.3f sec) \\\\n' % (mu, sig, output_factor, min_out, time_diff))\\n\\n # Return all data\\n return ( (loss_stat), (mu, sig, output_factor, min_out, net) )\",\n \"def start():\\n\\n xy = np.loadtxt('data-03-diabetes.csv', delimiter=',', dtype=np.float32)\\n x_data = xy[:, 0:-1]\\n y_data = xy[:, [-1]]\\n print \\\"X_data:%s\\\\nY_data:%s\\\" % (x_data, y_data)\\n\\n X = tf.placeholder(tf.float32, shape=[None, 8])\\n Y = tf.placeholder(tf.float32, shape=[None, 1])\\n\\n W = tf.Variable(tf.random_normal([8, 1]), name='weight')\\n b = tf.Variable(tf.random_normal([1]), name='bias')\\n\\n hypothesis = tf.sigmoid(tf.matmul(X, W) + b)\\n\\n cost = -tf.reduce_mean(Y*tf.log(hypothesis) + (1-Y) * tf.log(1-hypothesis))\\n optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)\\n train = optimizer.minimize(cost)\\n\\n # if hy > 0.5 = 1 else 0\\n predicted = tf.cast(hypothesis > 0.65, dtype=tf.float32)\\n accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, Y), dtype=tf.float32))\\n\\n sess = tf.Session()\\n sess.run(tf.global_variables_initializer())\\n\\n # coord = tf.train.Coordinator()\\n # threads = tf.train.start_queue_runners(sess=sess, coord=coord)\\n\\n print \\\"start step\\\"\\n\\n for step in range(10001):\\n # x_data, y_data = sess.run([train_x_batch, train_y_batch])\\n feed = {X: x_data, Y: y_data}\\n sess.run(train, feed_dict=feed)\\n cost_val = sess.run(cost, feed_dict=feed)\\n if step % 200 == 0:\\n print \\\"step %s, cost:%s\\\" % \\\\\\n (step, cost_val)\\n\\n # Accuracy report\\n # x_data, y_data = sess.run([train_x_batch, train_y_batch])\\n feed = {X: x_data, Y: y_data}\\n h, c, a = sess.run([hypothesis, predicted, accuracy],\\n feed_dict=feed)\\n print \\\"hy:%s, correct:%s, accurcy:%s\\\" % (h, c, a)\\n # coord.request_stop()\\n # coord.join(threads)\",\n \"def train(self, network, training_examples, iterations, unsupervised=False):\\n if unsupervised:\\n # For now this means we are training a sparse autoencoder.\\n # Therefore, we need to keep a running estimate of the\\n # \\\"sparsity\\\" of a node, where we try to keep the activation\\n # of the node stay close to a small value near 0 known as\\n # rho (Greek lower case p) or the 'sparsity parameter',\\n # which we will set to 0.05.\\n # This forces the network to learn the smallest set of features\\n # necessary to accurately build a close estimate of the original\\n # input vector\\n # In this case, we set the input vector equal to the target vector,\\n # and usually set a smaller value for the number of hidden nodes\\n # Then perform normal backpropagation, and during that, for each\\n # hidden node, also update the rho_estimate, and then update the\\n # threshold value\\n rho = 0.05\\n rho_estimates = [0] * len(network.layers[0].neurons) # set to 0 for each node\\n beta = 0.2 # the learning rate for updating the threshold terms\\n for iteration_counter in range(iterations):\\n random.shuffle(training_examples)\\n # for each row of data\\n for training_example in training_examples:\\n input_vector = training_example[0]\\n target_output_vector = training_example[1]\\n # prime the network on this row of input data\\n # -this will cause output (activation) values to be\\n # set for each neuron\\n network.forward(input_vector)\\n\\n # Note: next_layer_deltas is a vector of the single\\n # delta values for each node in the next\\n # (forward) layer\\n next_layer_deltas = []\\n next_layer_weights = []\\n isOutputLayer = True\\n for layer in reversed(network.layers): # iterate backwards\\n this_layer_deltas = [] # values from current layer\\n this_layer_weights = []\\n for j, neuron in enumerate(layer.neurons):\\n derivative = neuron.activation_function.derivative\\n # The output layer neurons are treated slightly\\n # different than the hidden neurons\\n if isOutputLayer:\\n if neuron.activation_function.name == \\\"logistic\\\":\\n # derivative simplifies down to just\\n # subtracting the target from the\\n # hypothesis\\n delta = neuron.output - target_output_vector[j]\\n else: # Tanh or Linear\\n delta = (neuron.output-target_output_vector[j])*derivative(neuron.output)\\n else: # for the hidden layer neurons\\n # Need to sum the products of the delta of\\n # a neuron in the next (forward) layer and the\\n # weight associated with the connection between\\n # this hidden layer neuron and that neuron.\\n # This will basically determine how much this\\n # neuron contributed to the error of the neuron\\n # it is connected to\\n # Note: next_layer_deltas is a vector of the \\n # single delta values for each node in the next\\n # (forward) layer\\n sum_value = 0.0\\n for next_delta, weights in zip(next_layer_deltas,\\n next_layer_weights):\\n sum_value += weights[j] * next_delta\\n delta = (derivative(neuron.output) *\\n sum_value)\\n # now store the delta and the list of weights\\n # for this neuron into these storage lists for the\\n # whole layer\\n this_layer_deltas.append(delta)\\n this_layer_weights.append(neuron.weights)\\n # Now, compute the gradient (partial deriv of cost\\n # func, J, w/ respect to parameter ij) for each\\n # weight_ij (parameter_ij) associated with\\n # this neuron\\n for ij, input_ij in enumerate(neuron.input_vector):\\n # compute gradient (partial deriv of cost J w/\\n # respect to parameter ij)\\n # Note: index ij means from a previous\\n # layer node i to this layer node j\\n # Then Gradient Descent: multiply by the learning\\n # rate, and subtract from the current value\\n # Note: Subtract in order to minimize error, since\\n # partial derivs point in direction of gradient\\n # AScent\\n gradient_ij = delta * input_ij\\n neuron.weights[ij] -= self.learning_rate * gradient_ij\\n # Now, compute the gradient (partial deriv of cost\\n # func, J, with respect to parameter ij) for the\\n # threshold value (parameter_0j), by using a \\\"1\\\" as\\n # the threshold \\\"input value\\\"\\n # -Note: index 0j means from a previous\\n # layer threshold node 0 (threshold always has\\n # index i=0) to this layer node j\\n # -can also think of it as the threshold being\\n # internal to this neuron\\n gradient_0j = delta * 1\\n neuron.threshold -= self.learning_rate * gradient_0j\\n if unsupervised and not isOutputLayer:\\n rho_estimates[j] = (0.999*rho_estimates[j] +\\n 0.001*neuron.output)\\n neuron.threshold -= (self.learning_rate * beta *\\n (rho_estimates[j] - rho))\\n # Once this layer is done, store the gradients and weights\\n # from the current layer for the next layer iteration\\n # (moving backwards)\\n next_layer_deltas = this_layer_deltas\\n next_layer_weights = this_layer_weights\\n isOutputLayer = False\\n # Note: this is after the while loop\\n self.iterations = iteration_counter\",\n \"def train(train_dataset: torch.utils.data.Dataset, test_dataset: torch.utils.data.Dataset,\\n training_config: dict = train_config, global_config: dict = global_config):\\n\\n for path in global_config.values():\\n create_dirs(path)\\n\\n # wrap datasets with Dataloader classes\\n train_loader = torch.utils.data.DataLoader(train_dataset,\\n **training_config[\\\"DATA_LOADER_CONFIG\\\"])\\n test_loader = torch.utils.data.DataLoader(test_dataset,\\n **training_config[\\\"DATA_LOADER_CONFIG\\\"])\\n\\n # model name & paths\\n name = \\\"_\\\".join([train_config[\\\"DATE\\\"], train_config[\\\"SESSION_NAME\\\"]])\\n modelpath = os.path.join(global_config[\\\"WEIGHT_DIR\\\"], name)\\n\\n # instantiate model\\n model = training_config[\\\"MODEL\\\"](**training_config[\\\"MODEL_CONFIG\\\"])\\n\\n optimizer = training_config[\\\"OPTIMIZER\\\"](model.parameters(),\\n **training_config[\\\"OPTIMIZER_CONFIG\\\"])\\n\\n # set up ignite engine\\n training_config[\\\"METRICS\\\"].update({\\\"loss\\\" : Loss(training_config[\\\"LOSS\\\"])})\\n trainer = create_supervised_trainer(model=model, optimizer=optimizer,\\n loss_fn=training_config[\\\"LOSS\\\"],\\n device=training_config[\\\"DEVICE\\\"])\\n evaluator = create_supervised_evaluator(model,\\n metrics=training_config[\\\"METRICS\\\"],\\n device=training_config[\\\"DEVICE\\\"])\\n\\n\\n # tensorboardX setup\\n log_dir = os.path.join(global_config[\\\"LOG_DIR\\\"], \\\"tensorboardx\\\", name)\\n create_dirs(log_dir)\\n writer = SummaryWriter(logdir=log_dir)\\n\\n # log using the logging tool\\n logger = log.Log(training_config, run_name=train_config['SESSION_NAME'])\\n\\n @trainer.on(Events.ITERATION_COMPLETED)\\n def log_training(engine):\\n iteration = (engine.state.iteration - 1) % len(train_loader) + 1\\n writer.add_scalar(\\\"training/loss\\\", engine.state.output, engine.state.iteration)\\n if iteration % 4 == 0:\\n print(\\\"\\\\repoch[{}] iteration[{}/{}] loss: {:.2f} \\\".format(engine.state.epoch,\\n iteration, len(train_loader),\\n engine.state.output), end=\\\"\\\")\\n\\n # generic evaluation function\\n def evaluate(engine, loader):\\n evaluator.run(loader)\\n metrics = evaluator.state.metrics\\n return metrics\\n\\n # training data metrics\\n @trainer.on(Events.EPOCH_COMPLETED)\\n def log_training_results(engine):\\n print(\\\"\\\\ntraining results - epoch {}\\\".format(engine.state.epoch))\\n metrics = evaluate(engine, train_loader)\\n print(metrics)\\n for key, value in metrics.items():\\n logger.log_metric(key, value)\\n writer.add_scalar(\\\"training/avg_{}\\\".format(key), value, engine.state.epoch)\\n\\n # test data metrics\\n @trainer.on(Events.EPOCH_COMPLETED)\\n def log_validation_results(engine):\\n print(\\\"test results - epoch {}\\\".format(engine.state.epoch))\\n metrics = evaluate(engine, test_loader)\\n print(metrics)\\n for key, value in metrics.items():\\n writer.add_scalar(\\\"validation/avg_{}\\\".format(key), value, engine.state.epoch)\\n\\n # model checkpointing\\n @trainer.on(Events.EPOCH_COMPLETED)\\n def model_checkpoint(engine):\\n torch.save(model.state_dict(), modelpath + \\\".pth\\\")\\n print(\\\"Checkpoint saved to {}\\\".format(modelpath + \\\".pth\\\"))\\n\\n # training iteration\\n try:\\n trainer.run(train_loader, max_epochs=training_config[\\\"EPOCHS\\\"])\\n except KeyboardInterrupt:\\n torch.save(model.state_dict(), modelpath + \\\".pth\\\")\\n print(\\\"Model saved to {}\\\".format(modelpath + \\\".pth\\\"))\\n raise KeyboardInterrupt\\n\\n # write weights\\n torch.save(model.state_dict(), modelpath + \\\".pth\\\")\\n\\n # write csv log file\\n log_content = training_config.copy()\\n evaluator.run(test_loader)\\n log_content[\\\"VAL_METRICS\\\"] = evaluator.state.metrics\\n log_path = os.path.join(global_config[\\\"LOG_DIR\\\"], training_config[\\\"LOGFILE\\\"])\\n write_log(log_path, log_content)\\n\\n logger.end_run()\\n \\n return evaluator.state.metrics[\\\"training/avg_loss\\\"]\",\n \"def sgd(self, training_data, epochs, mini_batch_size, eta, test_data=None):\\n training_data = list(training_data)\\n n = len(training_data)\\n n_test = None\\n\\n if test_data:\\n test_data = list(test_data)\\n n_test = len(test_data)\\n\\n for j in range(epochs):\\n random.shuffle(training_data)\\n mini_batches = [\\n training_data[k:k + mini_batch_size]\\n for k in range(0, n, mini_batch_size)]\\n for mini_batch in mini_batches:\\n self.update_mini_batch(mini_batch, eta)\\n if test_data:\\n print(\\\"Epoch {} : {} / {}\\\".format(j, self.evaluate(test_data), n_test))\\n else:\\n print(\\\"Epoch {} complete\\\".format(j))\",\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 train(self, X, y, X_val, y_val,\\n learning_rate=1e-3, learning_rate_decay=0.95,\\n reg=5e-6, num_iters=100,\\n batch_size=200, verbose=False):\\n\\n num_train = X.shape[0]\\n iterations_per_epoch = max(num_train / batch_size, 1)\\n\\n # Use SGD to optimize the parameters in self.model\\n loss_history = []\\n train_acc_history = []\\n val_acc_history = []\\n\\n indices = np.array(range(num_train))\\n\\n for it in xrange(num_iters):\\n # randomly select number of indices equal batch size to train on \\n batch_indices = np.random.choice(indices, size=batch_size)\\n\\n # minibatch of training data\\n X_batch = X[batch_indices]\\n y_batch = y[batch_indices]\\n\\n\\n loss, grads = self.loss(X_batch, y=y_batch)\\n loss_history.append(loss)\\n\\n # Stochastic Gradient Descent\\n for i in range(1, self.num_layers+1):\\n key = ['W' + str(i), 'b' + str(i)]\\n self.params[key[0]] += -learning_rate * grads[key[0]]\\n self.params[key[1]] += -learning_rate * grads[key[1]]\\n\\n if verbose and it % 100 == 0:\\n print('iteration %d / %d: loss %f' % (it, num_iters, loss))\\n\\n # Every epoch, check train and val accuracy and decay learning rate.\\n if it % iterations_per_epoch == 0:\\n # Check accuracy\\n train_acc = (self.predict(X_batch) == y_batch).mean()\\n val_acc = (self.predict(X_val) == y_val).mean()\\n train_acc_history.append(train_acc)\\n val_acc_history.append(val_acc)\\n\\n # Decay learning rate\\n learning_rate *= learning_rate_decay\\n\\n return {\\n 'loss_history': loss_history,\\n 'train_acc_history': train_acc_history,\\n 'val_acc_history': val_acc_history,\\n }\",\n \"def train(self, x, step): \\n self.epoch, self.training_iteration, self.batch_iteration = step\\n \\n # calculate loss\\n with tf.GradientTape() as tape:\\n self.loss_value = self.loss(self.flow, x)\\n \\n grads = tape.gradient(self.loss_value, self.flow.trainable_variables)\\n grads = [grad if grad is not None else tf.zeros_like(var) for var, grad in zip(self.flow.trainable_variables, grads)]\\n\\n self.opt.apply_gradients(zip(grads, self.flow.trainable_variables))\\n self.state.update(self.get_state())\",\n \"def SGD(self, training_data, epochs, mini_batch_size, eta,\\r\\n test_data=None):\\r\\n if test_data: n_test = len(test_data)\\r\\n n = len(training_data)\\r\\n for j in range(epochs):\\r\\n random.shuffle(training_data)\\r\\n mini_batches = [\\r\\n training_data[k:k+mini_batch_size]\\r\\n for k in range(0, n, mini_batch_size)]\\r\\n for mini_batch in mini_batches:\\r\\n self.update_mini_batch(mini_batch, eta)\\r\\n if test_data:\\r\\n print('Epoch {0}: {1} / {2}'.format(j, self.evaluate(test_data), n_test))\\r\\n else:\\r\\n print(\\\"Epoch {0} complete\\\".format(j))\",\n \"def train_network(self, data_x, data_y, optimizer_generator, num_epochs, batch_size, out_name, validation_split = 0.05, shuffle_data = True, loss=\\\"mse\\\", metrics=None, center_out=True): \\n training_process = multiprocessing.Process(target = self.train_network_process, args = (data_x, data_y, optimizer_generator, num_epochs, batch_size, out_name, validation_split, shuffle_data, loss, metrics, center_out))\\n training_process.start()\\n history = training_process.join()\\n \\n # Set model source to out_name so that next operation will run on the new model\\n self.model_source = out_name\\n \\n return history\",\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_func(self, data):\\n self.net.train()\\n\\n outputs, losses = self.forward(data)\\n\\n self.update_network(losses)\\n self.record_losses(losses, 'train')\\n\\n return outputs, losses\",\n \"def train_neural_network(x, y, n_nodes_hl, n_classes, n_epochs, batch_size):\\r\\n\\r\\n # Tensorflow optimizer and cost functions.\\r\\n prediction = neural_network_model(x, n_nodes_hl, n_classes)\\r\\n cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=prediction[0], labels=y))\\r\\n optimizer = tf.train.AdamOptimizer().minimize(cost)\\r\\n\\r\\n with tf.Session() as sess:\\r\\n sess.run(tf.global_variables_initializer())\\r\\n\\r\\n for epoch in range(n_epochs):\\r\\n epoch_loss = 0\\r\\n for _ in range(int(mnist.train.num_examples/batch_size)):\\r\\n batch_x, batch_y = mnist.train.next_batch(batch_size)\\r\\n batch_x = np.heaviside(batch_x - 0.5, 1) # Pre-processing.\\r\\n _, c = sess.run([optimizer, cost], feed_dict={x: batch_x, y: batch_y})\\r\\n epoch_loss += c\\r\\n\\r\\n print(\\\"Epoch\\\", epoch, 'completed out of', n_epochs, \\\"loss:\\\", epoch_loss)\\r\\n\\r\\n correct = tf.equal(tf.argmax(prediction[0], 1), tf.argmax(y, 1))\\r\\n accuracy = tf.reduce_mean(tf.cast(correct, 'float'))\\r\\n print('Accuracy:', accuracy.eval({x: np.heaviside(mnist.test.images - 0.5, 1), y: mnist.test.labels}))\\r\\n\\r\\n # The trained matrices.\\r\\n trained_hidden_layer, trained_output_layer = sess.run(prediction[1]), sess.run(prediction[2])\\r\\n\\r\\n return trained_hidden_layer, trained_output_layer\",\n \"def train(self, trainingData, trainingLabels, testData, testLabels, validate): \\n\\t\\t \\n\\t\\tself.features = trainingData[0].keys() # this could be useful for your code later...\\n\\n\\t\\tif (self.automaticTuning):\\n\\t\\t\\tCgrid = [0.001, 0.002, 0.003, 0.004, 0.005]\\n\\t\\telse:\\n\\t\\t\\tCgrid = [self.C]\\n\\t\\t\\t\\n\\t\\treturn self.trainAndTune(trainingData, trainingLabels, testData, testLabels, Cgrid, validate)\",\n \"def train(self, training_steps=10):\",\n \"def train(train_iter, test_iter, net, loss, trainer, ctx, num_epochs):\\n # 加入学习曲线显示\\n weight_url = '//home//jim//shanghai_index//data//weights.params'\\n logdir_url = '//home//jim//shanghai_index//log'\\n sw = SummaryWriter(logdir = logdir_url, flush_secs=10)\\n # 提取已有参数\\n if os.path.exists(weight_url):\\n print(u'已含有旧权重文件，正在载入继续训练并更新')\\n net.load_parameters(weight_url, allow_missing = True, ignore_extra = True)\\n # 训练\\n for epoch in range(num_epochs):\\n train_loss, train_acc, train_step, start = 0.0, 0.0, 0, time.time()\\n for x1, x2, y in train_iter:\\n batch_size = x1.shape[0]\\n with autograd.record():\\n y_hats = net(x1, x2)\\n print('y_hat = {}'.format(y_hats))\\n print('y = {}'.format(y))\\n ls = loss(y_hats, y)\\n print('loss:{}'.format(ls))\\n ls.backward()\\n trainer.step(batch_size)\\n train_loss += np.mean(ls.asnumpy())\\n train_acc += acc(y_hats, y)\\n train_step += 1\\n \\n print('epoch {}, loss {}, train acc {}, time {} sec'.format(epoch + 1,\\n train_loss/train_step,\\n train_acc/train_step,\\n time.time() - start))\\n # 向tensorboard填数据\\n sw.add_scalar(tag = 'Loss_and_acc', \\\\\\n value = {'train_loss': train_loss/train_step, 'train_acc': train_acc/train_step}, \\\\\\n global_step = epoch)\\n # 加入某个层权重分布变化等高图\\n grads = [i.grad() for i in net.collect_params('.*weight|.*bias').values()]\\n param_names = [name for name in net.collect_params('.*weight|.*bias').keys()]\\n assert len(grads) == len(param_names)\\n # logging the gradients of parameters for checking convergence\\n for i, name in enumerate(param_names):\\n sw.add_histogram(tag = name, values = grads[i], global_step = epoch, bins = 20)\\n\\n # 加入保存参数\\n net.save_parameters(weight_url)\",\n \"def train(self, dat_in, dat_out):\\n self.net.fit(dat_in, dat_out)\\n # Oftentimes, the training log statements do not end with a newline.\\n print()\",\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]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72270536","0.71475214","0.7036032","0.7021487","0.69404864","0.69394267","0.69327646","0.69167167","0.6907639","0.6885638","0.68781966","0.6866682","0.68590695","0.68407106","0.68397886","0.6797864","0.6782636","0.67748296","0.6770139","0.676445","0.67625505","0.6747097","0.67439944","0.6738566","0.67376333","0.67360395","0.67343724","0.6734335","0.67314225","0.6724346","0.6721283","0.67164975","0.6690945","0.6656863","0.6644104","0.6643717","0.66340005","0.66299516","0.66221374","0.6618444","0.6617157","0.66114205","0.6605542","0.6595079","0.6594673","0.65905684","0.6585442","0.65851897","0.6574393","0.65729684","0.6566665","0.65652025","0.6564537","0.65634876","0.6557014","0.655444","0.6553323","0.6552105","0.6549556","0.6534581","0.65280944","0.6526057","0.65236574","0.6513455","0.6513292","0.65118766","0.6505611","0.6505413","0.64911735","0.6489865","0.64897114","0.6480604","0.64756393","0.6474149","0.64710534","0.64694667","0.6469314","0.64687276","0.6468524","0.64666146","0.6466314","0.64617443","0.64613026","0.6457854","0.6455376","0.6454685","0.64543617","0.64532894","0.64500463","0.64500296","0.64495516","0.64487845","0.64435023","0.64382946","0.6436837","0.6431791","0.6431075","0.6429707","0.6429281","0.64271194","0.64263433"],"string":"[\n \"0.72270536\",\n \"0.71475214\",\n \"0.7036032\",\n \"0.7021487\",\n \"0.69404864\",\n \"0.69394267\",\n \"0.69327646\",\n \"0.69167167\",\n \"0.6907639\",\n \"0.6885638\",\n \"0.68781966\",\n \"0.6866682\",\n \"0.68590695\",\n \"0.68407106\",\n \"0.68397886\",\n \"0.6797864\",\n \"0.6782636\",\n \"0.67748296\",\n \"0.6770139\",\n \"0.676445\",\n \"0.67625505\",\n \"0.6747097\",\n \"0.67439944\",\n \"0.6738566\",\n \"0.67376333\",\n \"0.67360395\",\n \"0.67343724\",\n \"0.6734335\",\n \"0.67314225\",\n \"0.6724346\",\n \"0.6721283\",\n \"0.67164975\",\n \"0.6690945\",\n \"0.6656863\",\n \"0.6644104\",\n \"0.6643717\",\n \"0.66340005\",\n \"0.66299516\",\n \"0.66221374\",\n \"0.6618444\",\n \"0.6617157\",\n \"0.66114205\",\n \"0.6605542\",\n \"0.6595079\",\n \"0.6594673\",\n \"0.65905684\",\n \"0.6585442\",\n \"0.65851897\",\n \"0.6574393\",\n \"0.65729684\",\n \"0.6566665\",\n \"0.65652025\",\n \"0.6564537\",\n \"0.65634876\",\n \"0.6557014\",\n \"0.655444\",\n \"0.6553323\",\n \"0.6552105\",\n \"0.6549556\",\n \"0.6534581\",\n \"0.65280944\",\n \"0.6526057\",\n \"0.65236574\",\n \"0.6513455\",\n \"0.6513292\",\n \"0.65118766\",\n \"0.6505611\",\n \"0.6505413\",\n \"0.64911735\",\n \"0.6489865\",\n \"0.64897114\",\n \"0.6480604\",\n \"0.64756393\",\n \"0.6474149\",\n \"0.64710534\",\n \"0.64694667\",\n \"0.6469314\",\n \"0.64687276\",\n \"0.6468524\",\n \"0.64666146\",\n \"0.6466314\",\n \"0.64617443\",\n \"0.64613026\",\n \"0.6457854\",\n \"0.6455376\",\n \"0.6454685\",\n \"0.64543617\",\n \"0.64532894\",\n \"0.64500463\",\n \"0.64500296\",\n \"0.64495516\",\n \"0.64487845\",\n \"0.64435023\",\n \"0.64382946\",\n \"0.6436837\",\n \"0.6431791\",\n \"0.6431075\",\n \"0.6429707\",\n \"0.6429281\",\n \"0.64271194\",\n \"0.64263433\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":80994,"cells":{"query":{"kind":"string","value":"Update the biases and weights according to the minibatch"},"document":{"kind":"string","value":"def update_mini_batch(self, mini_batch: list, eta: float):\n # Create a set of biases and weights that are zeros\n nabla_b = [np.zeros(b.shape) for b in self.biases]\n nabla_w = [np.zeros(w.shape) for w in self.weights]\n\n # Update gradients for biases and weights\n for x, y in mini_batch:\n delta_nabla_b, delta_nabla_w = self.backprop(x, y)\n nabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\n nabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\n\n # Update biases and weights\n self.biases = [b - eta / len(mini_batch) * nb for b, nb in zip(self.biases, nabla_b)]\n self.weights = [w - eta / len(mini_batch) * nw for w, nw in zip(self.weights, nabla_w)]"},"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 update_weights(self):\n\t\tpass","def update_weights(self):\n self._weights = self._weights + self.update_weights_value\n self.weights_clipping()","def update_mini_batch2_4(self, mini_batch, eta):\r\n nabla_b = [np.zeros(b.shape) for b in self.biases]\r\n nabla_w = [np.zeros(w.shape) for w in self.weights]\r\n #backup_b = [np.zeros(b.shape) for b in self.biases]\r\n backup_w = [np.zeros(w.shape) for w in self.weights]\r\n rand = [list(set([np.random.randint(0,y) for i in range(int(y/2))])) for y in self.sizes]\r\n \r\n\r\n for i in range(len(self.biases)):\r\n bi=self.biases[i]\r\n we = self.weights[i]\r\n ra = rand[i]\r\n ra2 = rand[i+1]\r\n #bab = backup_b[i]\r\n baw = backup_w[i]\r\n for j in range(len(ra)):\r\n for a in range(len(we)):\r\n baw[a][ra[j]]=we[a][ra[j]]\r\n we[a][ra[j]]=np.zeros(baw[a][ra[j]].shape)\r\n #for j in range(len(ra2)):\r\n #bab[ra2[j]]=bi[ra2[j]]\r\n #bi[ra2[j]]=np.zeros(bab[ra2[j]].shape)\r\n\r\n \r\n for x, y in mini_batch:\r\n delta_nabla_b, delta_nabla_w = self.backprop(x, y)\r\n #print('w')\r\n #print(delta_nabla_w)\r\n nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\r\n nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\r\n\r\n self.weights = [w-(eta/len(mini_batch))*nw\r\n for w, nw in zip(self.weights, nabla_w)]\r\n self.biases = [b-(eta/len(mini_batch))*nb\r\n for b, nb in zip(self.biases, nabla_b)]\r\n\r\n for i in range(len(self.biases)):\r\n bi=self.biases[i]\r\n we = self.weights[i]\r\n ra = rand[i]\r\n ra2 = rand[i+1]\r\n #bab = backup_b[i]\r\n baw = backup_w[i]\r\n\r\n for j in range(len(ra)):\r\n for a in range(len(we)):\r\n we[a][ra[j]]=baw[a][ra[j]]\r\n \r\n #for j in range(len(ra2)):\r\n #bi[ra2[j]]=bab[ra2[j]]\r","def update_weights(self):\n self._weights = self._weights + self.update_weights_value","def update_weights(self):\n\n self.weights -= self.loss_grads\n self.loss_grads = np.zeros(self.weights.shape)","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_weights(self, BMU, currentIteration, input_data, lambda1):\n # Learning rate selection for each epoch\n lr = self.currentLearningRate(currentIteration, lambda1)\n \n # Neighborhood radius selection for each epoch\n radius = self.currentNeighbourhoodRadius(currentIteration, lambda1)\n \n # Iterating through randomly initialized weights and update weights\n for i in range(len(self.weights[0])):\n for j in range(len(self.weights)):\n tmpDist = np.power(BMU[0] - i, 2) + np.power(BMU[1] - j, 2)\n theta = np.exp(-tmpDist / (2*np.power(radius, 2)))\n for k in range(self.input_dimension):\n self.weights[i][j][k] = self.weights[i][j][k] + lr * theta * (input_data[k] - self.weights[i][j][k])","def update(self,mini_batch,eta):\r\n\t\tnabla_b=[np.zeros(b.shape) for b in self.biases]\r\n\t\tnabla_w=[np.zeros(w.shape) for w in self.weights]\r\n\t\tfor x,y in mini_batch:\r\n\t\t\tdelta_nabla_b, delta_nabla_w=self.backprop(x,y)\r\n\t\t\tnabla_b= [nb+dnb for nb,dnb in zip(nabla_b,delta_nabla_b)]\r\n\t\t\tnabla_w= [nw+dnw for nw,dnw in zip(nabla_w,delta_nabla_w)]\r\n\t\tself.weights=[w-(eta/len(mini_batch))*nw for \r\n\t\tw, nw in zip (self.weights, nabla_w)]\r\n\t\tself.biases=[b-(eta/len(mini_batch))*nb for\r\n\t\tb, nb in zip (self.biases, nabla_b)]","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 trainOnDataset(self, dataset):\n cfg = self.cfg\n for rows in dataset.randomBatches(self.datasetField, cfg.batchSize):\n olduw, olduhb, olduvb = \\\n zeros((self.rbm.visibleDim, self.rbm.hiddenDim)), \\\n zeros(self.rbm.hiddenDim), zeros(self.rbm.visibleDim)\n\n for t in range(cfg.maxIter):\n #print(\"*** Iteration %2d **************************************\" % t)\n\n params = self.rbm.params\n params = params.reshape((self.rbm.visibleDim, self.rbm.hiddenDim))\n biasParams = self.rbm.biasParams\n\n mm = cfg.iniMm if t < cfg.mmSwitchIter else cfg.finMm\n\n w, hb, vb = self.calcUpdateByRows(rows)\n\n #print(\"Delta: \")\n #print(\"Weight: \",)\n #print(w)\n #print(\"Visible bias: \",)\n #print(vb)\n #print(\"Hidden bias: \",)\n #print(hb)\n #print(\"\")\n\n olduw = uw = olduw * mm + \\\n \tcfg.rWeights * (w - cfg.weightCost * params)\n olduhb = uhb = olduhb * mm + cfg.rHidBias * hb\n olduvb = uvb = olduvb * mm + cfg.rVisBias * vb\n\n #print(\"Delta after momentum: \")\n #print(\"Weight: \",)\n #print(uw)\n #print(\"Visible bias: \",)\n #print(uvb)\n #print(\"Hidden bias: \",)\n #print(uhb)\n #print(\"\")\n\n # update the parameters of the original rbm\n params += uw\n biasParams += uhb\n\n # Create a new inverted rbm with correct parameters\n invBiasParams = self.invRbm.biasParams\n invBiasParams += uvb\n self.invRbm = self.rbm.invert()\n self.invRbm.biasParams[:] = invBiasParams\n\n #print(\"Updated \")\n #print(\"Weight: \",)\n #print(self.rbm.connections[self.rbm['visible']][0].params.reshape( \\)\n # (self.rbm.indim, self.rbm.outdim))\n #print(\"Visible bias: \",)\n #print(self.invRbm.connections[self.invRbm['bias']][0].params)\n #print(\"Hidden bias: \",)\n #print(self.rbm.connections[self.rbm['bias']][0].params)\n #print(\"\")","def update(self, x_dict, y_dict, weight):\n assert len(x_dict) == len(y_dict), \"invalid # of qids\"\n \n qids = self.__get_shuffled_qids(x_dict, y_dict, weight.epoch)\n w = weight.get_dense_weight()\n for qid in tqdm(qids):\n w = approx_ap(x_dict[qid].toarray(), y_dict[qid], w, self.eta, self.alpha, self.beta)\n weight.set_weight(sp.csr_matrix(w.reshape((1, weight.dims))))\n weight.epoch += 1","def updateWeights(self,weightUpdate):\n\t\n\t\tbranches = self.collectAllBranches()\n\n\t\tfor i in range(self.nBranches):\n\n\t\t\tbranches[i].weight -= weightUpdate[i]","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(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 set_weights_to_layers(self, candidate):\r\n last_idx = 0\r\n\r\n # Iterate over every layer\r\n for layer_idx in range(0, self.num_layers, 1):\r\n if layer_idx %2 == 0 : \r\n # Get layer dimensions\r\n w_shape = self.layers[layer_idx].weight.shape\r\n w_numel = np.prod(w_shape)\r\n if self.bias :\r\n b_shape = self.layers[layer_idx].bias.shape\r\n b_numel = np.prod(b_shape)\r\n # Decode the candidate and get weight, bias matrices\r\n weight = candidate[last_idx:last_idx + w_numel].reshape(w_shape)\r\n last_idx += w_numel\r\n if self.bias :\r\n bias = candidate[last_idx:last_idx + b_numel].reshape(b_shape)\r\n last_idx += b_numel\r\n else :\r\n bias = []\r\n\r\n# if self.gpu:\r\n# weight = weight.to(device='cuda:'+str(model.rank))\r\n# if self.bias:\r\n# bias = bias.to(device='cuda:'+str(model.rank))\r\n# # Set layer weight, bias\r\n self.layers[layer_idx].weight = torch.nn.Parameter(weight)\r\n if self.bias :\r\n self.layers[layer_idx].bias = torch.nn.Parameter(bias)","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 _step(self):\n # Make a minibatch of training data\n num_train = self.X_train.shape[0]\n # random choose the samples\n batch_mask = np.random.choice(num_train, self.batch_size)\n X_batch = self.X_train[batch_mask]\n y_batch = self.y_train[batch_mask]\n\n # Compute loss and gradient\n loss, grads = self.model.loss(X_batch, y_batch)\n self.loss_history.append(loss)\n\n # Perform a parameter update\n for p, w in self.model.params.items():\n dw = grads[p]\n config = self.optim_configs[p]\n next_w, next_config = self.update_rule(w, dw, config)\n self.model.params[p] = next_w\n self.optim_configs[p] = next_config","def update_mini_batch(self, mini_batch, eta):\n nabla_b, nabla_w = self.back_propagate_matrix_based(mini_batch)\n\n # Gradient descent: update weights\n self.weights = [w - (eta / len(mini_batch)) * nw\n for w, nw in zip(self.weights, nabla_w)]\n # Gradient descent: update biases\n self.biases = [b - (eta / len(mini_batch)) * np.asarray(nb)\n for b, nb in zip(self.biases, nabla_b)]","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_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)","def update_mini_batch(self, mini_batch, eta):\n xs, ys = mini_batch.T\n xs = cp.array(cp.vstack(xs).astype(np.float64).reshape((-1, self.sizes[0], 1)))\n ys = cp.array(cp.vstack(ys).astype(np.float64).reshape((-1, self.sizes[-1], 1)))\n delta_nabla_b, delta_nabla_w = self.backprop_batch(xs, ys)\n self.weights = [w - eta * cp.mean(nw, axis=0) for w, nw in zip(self.weights, delta_nabla_w)]\n self.biases = [b - eta * cp.mean(nb, axis=0) for b, nb in zip(self.biases, delta_nabla_b)]","def _update_parameter(self, dWxh, dbh, dWhy, dby):\n # Add code to update all the weights and biases here","def update_masks(self, index, weight):\n # determine number of updates without actually updating the count\n if index not in self._index_update_count:\n num_update = self.begin_num_update\n else:\n num_update = self._index_update_count[index]\n num_update += 1\n num_update = max(num_update, self.num_update)\n\n # calculate epoch\n epoch = int((num_update - 1) / self.batches_per_epoch) + 1\n\n # determine if masks need to be updated, and get corresponding parameters\n if index == 0:\n self.masks_updated = True\n if self.epoch != epoch:\n self.epoch = epoch\n if epoch == 1:\n self.masks_updated = False\n if self.weight_sparsity is not None:\n logging.info(log + 'bias-sparsity={}, weight-sparsity={}'.format(self.bias_sparsity[0], self.weight_sparsity[0]))\n else:\n logging.info(log + 'bias-threshold={}, weight-threshold={}'.format(self.bias_threshold[0], self.weight_threshold[0]))\n if self.pruning_switch_epoch[0] + 1 == epoch:\n self.masks_updated = False\n self.pruning_switch_epoch.pop(0)\n if self.weight_sparsity is not None:\n self.weight_sparsity.pop(0)\n self.bias_sparsity.pop(0)\n logging.info(log + 'bias-sparsity={}, weight-sparsity={}'.format(self.bias_sparsity[0], self.weight_sparsity[0]))\n else:\n self.weight_threshold.pop(0)\n self.bias_threshold.pop(0)\n logging.info(log + 'bias-threshold={}, weight-threshold={}'.format(self.bias_threshold[0], self.weight_threshold[0]))\n\n # update masks if needed\n if not self.masks_updated:\n # initialize masks\n if epoch == 1:\n self.masks.append(None)\n # if percentages are given\n if self.weight_sparsity is not None:\n if len(weight.shape) == 1:\n sparsity = self.bias_sparsity[0]\n else:\n sparsity = self.weight_sparsity[0]\n number_unpruned = int((100.0 - sparsity) * weight.size / 100.0)\n self.masks[index] = topk(NDabs(weight), axis=None, ret_typ='mask',\n k=number_unpruned)\n # if thresholds are given\n else:\n if len(weight.shape) == 1:\n threshold = self.bias_threshold[0]\n else:\n threshold = self.weight_threshold[0]\n self.masks[index] = NDabs(weight) >= threshold\n\n return not self.masks_updated","def update_mini_batch(self,mini_batch,eta):\n\t\t#Shape returns the dimensions of the given array.\n\t\t#Zeros returns an array of 0's of specified dimensions\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\t\tfor x,y in mini_batch:\n\t\t\tdelta_nabla_b,delta_nabla_w = self.backprop(x,y)\n\t\t\tnabla_b = [nb+dnb for nb,dnb in zip(nabla_b,delta_nabla_b)]\n\t\t\tnabla_w = [nw+dnw for nw,dnw in zip(nabla_w,delta_nabla_w)]\n\t\t#Updating weights and biases after backprop alg\n\t\tself.weights = [w-eta/len(mini_batch)*nw\n\t\t\t\t\t\tfor w,nw in zip(self.weights,nabla_w)]\n\t\tself.biases = [b-eta/len(mini_batch)*nb\n\t\t\t\t\t\tfor b,nb in zip(self.biases,nabla_b)]","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 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 minibatch_fit(self):\r\n self.init_plot(self.FEATURES)\r\n\r\n # YOUR CODE HERE\r\n max_batch_nr = self.DATAPOINTS // self.MINIBATCH_SIZE\r\n batch_nr = 1\r\n\r\n while not self.converged() or self.training_iteration == 0:\r\n print('Processing batch nr: ', batch_nr)\r\n self.compute_gradient_minibatch(batch_nr)\r\n self.upd_theta()\r\n self.update_plot(np.sum(np.square(self.gradient)))\r\n\r\n batch_nr += 1\r\n # start over on first batch if processed all data\r\n batch_nr = batch_nr % max_batch_nr\r\n self.training_iteration += 1","def _update_mini_batch(self, data_batch, labs_batch, eta, lmbda, n):\n # forward data through the net\n affines, activations = self._propagate(data_batch)\n # back propagate and calculate gradient on the whole batch\n nabla_b, nabla_w = self._backprop(affines, activations, labs_batch)\n\n # TODO add momentum\n self.weights = [w - eta * nw\n for w, nw in zip(self.weights, nabla_w)]\n self.biases = [b - eta * nb\n for b, nb in zip(self.biases, nabla_b)]","def _initialize_weights(self):\n stddev = 1.0 / math.sqrt(self._hidden_size)\n for layer_id, param_id in itertools.product(\n range(self._num_layers * (self._bidirectional + 1)),\n range(self._num_gates * 2)):\n i = layer_id * 2 + (param_id // self._num_gates)\n j = i + len(self._weights_shapes) // 2\n matrix_shape = self._weights_shapes[i][:]\n bias_shape = self._weights_shapes[j][:]\n matrix_shape[0] //= self._num_gates\n bias_shape[0] //= self._num_gates\n self._set_parameter(\n init_ops.random_uniform(matrix_shape, -stddev, stddev),\n layer_id, param_id, 'matrix')\n self._set_parameter(\n init_ops.random_uniform(bias_shape, -stddev, stddev),\n layer_id, param_id, 'bias')","def update(self, x_train_single, updated_h):\n # x_row = cp.array(x_train_single.toarray())\n # cp.cuda.Stream.null.synchronize()\n updater(x_train_single,updated_h,self.weights,self.num_features,self.num_models,self.learning_rate)\n # self.biases += updated_h * self.learning_rate","def update_bias(self):\n self._bias = self._bias + self.update_bias_value\n self.bias_clipping()","def __init__(self, in_features, out_features):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n mean = 0\n std_dev = 0.0001\n #print(in_features)\n #print(out_features)\n # create weight matrices\n weight = np.random.normal(mean, std_dev, (out_features, in_features))\n #print(weight.shape)\n grad_weight = np.zeros((in_features, out_features))\n\n # create biases (in batches)\n bias = np.zeros(out_features)\n grad_bias = np.zeros(out_features)\n\n self.params = {'weight': weight, 'bias': bias}\n self.grads = {'weight': bias, 'bias': grad_bias}\n\n ########################\n # END OF YOUR CODE #\n #######################","def _initialize_weights(self):\n pass","def init_weight(self):\n init_bn(self.norm0)","def set_weights(self,weights):\n for i,layer in enumerate(weights):\n #checking for any values equal to minval\n if np.any(layer==self.minval):\n weights[i]=np.where(weights[i]==self.minval,self.replace_min,weights[i])\n super().set_weights(list(weights))","def update_mini_batch(self, mini_batch, eta):\n nabla_b = [np.zeros(b.shape) for b in self.biases] #按照偏置矩阵大小生成一个为0的矩阵\n nabla_w = [np.zeros(w.shape) for w in self.weights]\n for x, y in mini_batch: #循环全部最小样本集后，再进行权重和偏置值的调整 \n delta_nabla_b, delta_nabla_w = self.backprop(x, y)\n nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\n nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\n self.weights = [w-(eta/len(mini_batch))*nw\n for w, nw in zip(self.weights, nabla_w)]\n self.biases = [b-(eta/len(mini_batch))*nb\n for b, nb in zip(self.biases, nabla_b)]","def minibatcher(inputs, targets, batchsize, shuffle=False):","def init_weights(self):\n # Initialize weights\n self.apply(self._init_weights)\n # Tie weights if needed\n self.tie_weights()","def init_weights(self):\n # Initialize weights\n self.apply(self._init_weights)","def train_minibatch(self, **kwargs):\n raise NotImplementedError","def initialize_weights(self):\n weights_initializer.WeightsInitializer.initialize_layer_or_model(\n self._batch)","def update_mini_batch(self, mini_batch, eta):\r\n nabla_b = [np.zeros(b.shape) for b in self.biases]\r\n nabla_w = [np.zeros(w.shape) for w in self.weights]\r\n for x, y in mini_batch:\r\n delta_nabla_b, delta_nabla_w = self.backprop(x, y)\r\n nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\r\n nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\r\n self.weights = [w-(eta/len(mini_batch))*nw\r\n for w, nw in zip(self.weights, nabla_w)]\r\n self.biases = [b-(eta/len(mini_batch))*nb\r\n for b, nb in zip(self.biases, nabla_b)]","def __train_hebbs__(self):\n\n rho = self.__get_rho__()\n\n copied_train_data = np.copy(self.train_data)\n\n for curr_train_sample in tqdm(copied_train_data,\n disable=not self.verbose,\n postfix=f'Model training...'):\n\n train_sample_norm = curr_train_sample - rho\n\n assert len(train_sample_norm.shape) == 1, \\\n f'Flatten your input! Now dim is: {train_sample_norm.shape}'\n\n self.weights += np.outer(train_sample_norm, train_sample_norm)\n\n diagonal_values = np.diag(self.weights) # extracts diagonal values from matrix\n diagonal_weights = np.diag(diagonal_values) # creates diagonal matrix from diagonal values for weights\n\n self.weights = self.weights - diagonal_weights\n self.weights = self.weights / len(self.train_data)","def _set_weights(self, weights):\r\n self.weights = weights.reshape(self.output_size, self.input_size+1)","def init_weights(self):\n\n params = torch.load(self.resnet_weight)\n\n self.fc1.weight.data = params['state_dict']['module.fc.weight'].clone()\n self.fc1.bias.data = params['state_dict']['module.fc.bias'].clone()\n\n\n r = np.sqrt(1.) / np.sqrt(self.fc3.in_features +\n self.fc3.out_features)\n self.fc3.weight.data.uniform_(-r, r)\n self.fc3.bias.data.fill_(0)\n r = np.sqrt(1.) / np.sqrt(self.fc2.in_features +\n self.fc2.out_features)\n self.fc2.weight.data.uniform_(-r, r)\n self.fc2.bias.data.fill_(0)\n r = np.sqrt(1.) / np.sqrt(self.fc4.in_features +\n self.fc4.out_features)\n self.fc4.weight.data.uniform_(-r, r)\n self.fc4.bias.data.fill_(0)","def _train_pattern(self, matrix, input, current, bmu):\n\n for input_neuron in range(self.input_neuron_count):\n current_weight = matrix[current][input_neuron]\n input_value = input[input_neuron]\n\n new_weight = self._determine_new_weight(current_weight,\n input_value, current, bmu)\n\n self.correction_matrix[current][input_neuron] = new_weight","def update_bias(self):\n self._bias = self._bias + self.update_bias_value","def reassignWeights(self,weights):\n\t\n\t\tbranches = self.collectAllBranches()\n\n\t\tfor i in range(self.nBranches):\n\n\t\t\tbranches[i].weight = weights[i]","def init_weights(self):\n self.transformer.init_weights()\n if self.loss_cls.use_sigmoid:\n bias_init = bias_init_with_prob(0.01)\n for m in self.cls_branches:\n nn.init.constant_(m[-1].bias, bias_init)","def update_mini_batch2_6(self, mini_batch):\r\n nabla_b = [np.zeros(b.shape) for b in self.biases]\r\n nabla_w = [np.zeros(w.shape) for w in self.weights]\r\n for x, y in mini_batch:\r\n delta_nabla_b, delta_nabla_w = self.backprop(x, y)\r\n nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\r\n nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\r\n mysum = sum([sum([sum(j) for j in nabla_w[i]]) for i in range(len(nabla_w))])\r\n if mysum*self.sign<0:\r\n if(self.eta>0.5):\r\n self.eta=self.eta/2\r\n self.sign=self.sign*(-1)\r\n else:\r\n if(self.eta<10):\r\n self.eta=self.eta*2\r\n self.weights = [w-(self.eta/len(mini_batch))*nw\r\n for w, nw in zip(self.weights, nabla_w)]\r\n self.biases = [b-(self.eta/len(mini_batch))*nb\r\n for b, nb in zip(self.biases, nabla_b)]","def mutate(self):\n \n # Mutate each weight\n self.w1 = self.w1 + np.random.normal(0, 1, 8).reshape((2,4))\n self.b1 = self.b1 + np.random.normal(0, 1, 2).reshape((2,1))\n self.w2 = self.w2 + np.random.normal(0, 1, 4).reshape((2,2))\n self.b2 = self.b2 + np.random.normal(0, 1, 2).reshape((2,1))\n self.w3 = self.w3 + np.random.normal(0, 1, 2).reshape((1,2))\n self.b3 = self.b3 + np.random.normal(0, 1, 1)\n \n # Return thyself\n return self","def set_weights(self, W):\r\n if self.weights.shape!=W.shape:\r\n return -1\r\n self.weights = W","def _modify_updates(self, updates):\n\n if self.max_kernel_norm is not None:\n W, = self.transformer.get_params()\n if W in updates:\n updated_W = updates[W]\n row_norms = T.sqrt(T.sum(T.sqr(updated_W), axis=(0, 1, 2)))\n desired_norms = T.clip(row_norms, 0, self.max_kernel_norm)\n scales = desired_norms / (1e-7 + row_norms)\n updates[W] = (updated_W * scales.dimshuffle('x', 'x', 'x', 0))","def test_net_weight_update(self):\n nn = NeuralNet(0, 0, '', '', blank=True)\n nn.create_net(2, 1, 2, 2)\n nn.eta = 0.1\n\n # Override weights to static value for reproducibility\n for node in nn.layers[2].nodes:\n node.weights = [0.6, 0.6]\n\n for node in nn.layers[3].nodes:\n node.weights = [1.0, 1.0]\n\n nn.update_weights([2, 3], [0], test=True)\n\n test_weight = nn.layers[-1].nodes[0].weights[0]\n self.assertEqual(round(test_weight, 4), 0.9901)","def initialize_weights(self, weights_initializer, bias_initializer):\n wshapes = [\n [self.input_size, self.hidden_size[0]],\n [self.hidden_size[0], self.hidden_size[1]],\n [self.hidden_size[1], self.output_size]\n ]\n\n bshapes = [\n [1, self.hidden_size[0]],\n [1, self.hidden_size[1]],\n [1, self.output_size]\n ]\n\n self.weights = [init_weights(s, weights_initializer) for s in wshapes]\n self.biases = [init_weights(s, bias_initializer) for s in bshapes]\n\n self.trainable_variables = self.weights + self.biases","def init_weights_(self):\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 update(self):\n\n self._eps_count += 1\n if self._replay.size >= self._min_replay_size:\n for _ in range(self._learning_updates):\n samples_indices, minibatch = self._replay.sample(self._batch_size)\n tf_minibatch = [tf.constant(mat, dtype=tf_type) for mat, tf_type in zip(minibatch, [tf.float32, tf.int32, tf.float32, tf.float32, tf.float32])]\n self._learn(*tf_minibatch)\n\n self._learn_iter_counter += 1\n if (self._target_update_period > 1) and (self._learn_iter_counter % self._target_update_period == 0):\n self._update_target_nets()","def update_weight(self,ctr,new_weight):\n self.sum1 -= self.data_set[ctr].weight\n self.data_set[ctr].weight = new_weight\n self.sum1 += new_weight","def my_assign_weights(context, data):\n pass","def update_network(self, a, batch_size):\n for layer in self.layers:\n layer.weights_update(a, self.alpha, self.l2_lambda, batch_size)\n a = layer.a","def initialize_weights(self):\n for layer in self._cnn_layers:\n weights_initializer.WeightsInitializer.initialize_layer_or_model(layer)","def initWeights(self):\n self.weights = []\n self.bias = []\n for i, dim in enumerate(self.dimensions[1:]):\n self.weights.append(np.random.uniform(-1,1,(self.dimensions[i],dim)))\n self.bias.append(np.random.uniform(-1,1,dim))","def init_weights(self) -> None:\n nn.init.kaiming_normal_(self._U)\n nn.init.kaiming_normal_(self._W)\n nn.init.kaiming_normal_(self._V)\n\n nn.init.normal_(self._b)","def change_weight(self, new_weight_arr):\n self.weights = new_weight_arr","def _train(self, bmu, matrix, input):\n # adjust the weight for the BMU and its neighborhood\n for output_neuron in range(self.output_neuron_count):\n self._train_pattern(matrix, input, output_neuron, bmu)","def init_weights(self):\n r = np.sqrt(6.) / np.sqrt(self.fc1.in_features +\n self.fc1.out_features)\n self.fc1.weight.data.uniform_(-r, r)\n self.fc1.bias.data.fill_(0)\n r = np.sqrt(6.) / np.sqrt(self.fc2.in_features +\n self.fc2.out_features)\n self.fc2.weight.data.uniform_(-r, r)\n self.fc2.bias.data.fill_(0)","def _reweight(self):\n self._seed_weights = [self._graph.degree(seed) for seed in self._seeds]\n weight_sum = np.sum(self._seed_weights)\n self._seed_weights = [float(weight)/weight_sum for weight in self._seed_weights]","def hard_update_target_network(self,step):\n \n if step % self.C == 0:\n pars = self.model.get_weights()\n self.target_model.set_weights(pars)","def hard_update_target_network(self,step):\n \n if step % self.C == 0:\n pars = self.model.get_weights()\n self.target_model.set_weights(pars)","def set_weights(self, weights):\n tuples = []\n for layer in self.layers:\n num_param = len(layer.weights)\n layer_weights = weights[:num_param]\n for sw, w in zip(layer.weights, layer_weights):\n tuples.append((sw, w))\n weights = weights[num_param:]\n K.batch_set_value(tuples)","def normalizeWeights(self):\n for wt in self.weights:\n wt[wt>1] = 1\n wt[wt<-1] = -1\n for bs in self.bias:\n bs[bs>1] = 1\n bs[bs<-1] = -1","def _set_weights(self, weights):\n i = iter(weights)\n\n for param in self.params:\n param.set_value(i.next())","def _set_weights(self, weights):\n i = iter(weights)\n\n for param in self.params:\n param.set_value(i.next())","def update_mini_batch1_7(self, mini_batch, eta):\r\n nabla_b = [np.zeros(b.shape) for b in self.biases]\r\n nabla_w = [np.zeros(w.shape) for w in self.weights]\r\n for x, y in mini_batch:\r\n delta_nabla_b, delta_nabla_w = self.backprop1_7(x, y)\r\n nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\r\n nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\r\n self.weights = [w-(eta/len(mini_batch))*nw\r\n for w, nw in zip(self.weights, nabla_w)]\r\n self.biases = [b-(eta/len(mini_batch))*nb\r\n for b, nb in zip(self.biases, nabla_b)]","def set_weights(self, weights):\r\n self.weights = weights","def update_target_model(self):\n self.target_model.set_weights(self.model.get_weights())","def update_target_model(self):\n self.target_model.set_weights(self.model.get_weights())","def update_target_model(self):\n self.target_model.set_weights(self.model.get_weights())","def init_weights(model):\n ...","def InitWeights(self):\n self.w = -1 + 2 * np.random.rand(self.num_of_inputs,)\n self.w0 = -1 + 2 * np.random.rand()","def update_generate_params(self,inps,trgs,preds):\n batch_size = np.shape(trgs)[0]\n\n self.delta_weight_h_to_v = self.learning_rate / batch_size * np.transpose(trgs) @ (inps - preds)\n self.delta_bias_v = self.learning_rate * np.mean(inps - preds)\n \n self.weight_h_to_v += self.delta_weight_h_to_v\n self.bias_v += self.delta_bias_v \n \n return","def prepare_weights(self, pre_exist_words, hs, negative, wv, sentences,\n nonce, update=False, replication=False,\n sum_over_set=False, weighted=False, beta=1000):\n # set initial input/projection and hidden weights\n if not update:\n raise Exception('prepare_weight on Nonce2VecTrainables should '\n 'always be used with update=True')\n else:\n self.update_weights(pre_exist_words, hs, negative, wv, sentences,\n nonce, replication, sum_over_set, weighted,\n beta)","def set_weights(self, w):\n self.nn.set_param_values(w)","def _update(self, x: np.ndarray, y: int):\n decision = self.weights.dot(x)\n v_t = x @ np.diag(np.diag(self._sigma)) @ x.T\n m_t = y * decision\n loss = (self._phi * math.sqrt(v_t) - m_t)\n #print(loss)\n if loss > 0:\n # We scale our learning rate (alpha) using the weight/cost\n alpha_t = self.class_weight_[y] * self._get_alpha(m_t, v_t)\n u_t = 0.25 * (-alpha_t * v_t * self._phi + math.sqrt(\n alpha_t ** 2 * v_t ** 2 * self._phi ** 2 + 4 * v_t)) ** 2\n beta_t = alpha_t * self._phi / (math.sqrt(u_t) +\n alpha_t * self._phi * v_t)\n sigma = np.expand_dims(x @ self._sigma, axis=0)\n self.weights += alpha_t * y * np.squeeze(sigma)\n self._sigma -= beta_t * sigma.T @ sigma","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_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 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 _minibatch_sgd(self, X_train, y_train):\n n_samples, n_features = np.shape(X_train)\n\n indices = np.arange(n_samples)\n\n if self.shuffle:\n self.random.shuffle(indices)\n\n for idx in range(0, n_samples, self.batch_size):\n\n batch_idx = indices[idx:idx + self.batch_size]\n\n # Forwardpropagation.\n Z_hidden, A_hidden, Z_out, A_out = self._forwardprop(\n X_train[batch_idx, :]\n )\n\n # Backpropagation.\n self._backprop(\n y_train, X_train, A_hidden, Z_hidden, A_out, Z_out, batch_idx\n )\n\n return self","def update_mini_batch(self, mini_batch, eta):\n nabla_b = [np.zeros(b.shape) for b in self.biases]\n nabla_w = [np.zeros(w.shape) for w in self.weights]\n\n for x, y in mini_batch:\n delta_nabla_b, delta_nabla_w = self.backprop(x, y)\n nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\n nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\n\n weights = [w-(eta/len(mini_batch))*nw\n for w, nw in zip(self.weights, nabla_w)]\n\n biases = [b-(eta/len(mini_batch))*nb\n for b, nb in zip(self.biases, nabla_b)]\n\n return Network(self.sizes, weights=weights, biases=biases)","def rebalance_weightings(context):\r\n total_ratio = 0\r\n log.info(\"*******Rebalancing weightings********\")\r\n print(context.up_ratios)\r\n \r\n for asset, ratio in context.up_ratios.items():\r\n total_ratio += ratio\r\n \r\n for asset, ratio in context.up_ratios.items():\r\n context.max_weights[asset] = ratio/total_ratio\r\n \r\n log.info(context.max_weights)","def update_weights(self, example):\n pred = self.predict(example)\n if pred != example.label:\n self.weights[example.label] = self.weights[example.label] + example.fvector\n self.weights[pred] = self.weights[pred] - example.fvector","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 sgd(self):\n for i, j, r in self.samples:\n # Computer prediction and error\n if (self.type=='bias'):\n prediction = self.get_rating_bias(i, j)\n elif(self.type=='nonbias') :\n prediction = self.get_rating(i, j)\n # print(i, j, r,prediction)\n e = (r - prediction)\n\n # Update biases\n self.b_u[i] =self.b_u[i]+ self.alpha * (e - self.beta * self.b_u[i])\n self.b_i[j] = self.b_i[j] + self.alpha * (e - self.beta * self.b_i[j])\n\n # Create copy of row of P since we need to update it but use older values for update on Q\n P_i = self.P[i, :][:]\n\n # Update user and item latent feature matrices\n # print(self.alpha * (e * self.Q[j, :] - self.beta * self.P[i, :]))\n # print(self.P[i, :])\n self.P[i, :] =self.P[i, :] + self.alpha * (e * self.Q[j, :] - self.beta * self.P[i, :])\n # print(self.P[i, :],\"&&&&&&\")\n self.Q[j, :] = self.Q[j, :] + self.alpha * (e * P_i - self.beta * self.Q[j, :])\n # print(self.Q[j, :])","def _initialize_weights(self):\n for _, cell in self.cells_and_names():\n if isinstance(cell, nn.Conv2d):\n cell.weight.set_data(orthogonal(cell.weight.shape, 0.6))\n if cell.bias is not None:\n cell.bias.set_data(\n init.initializer(init.Constant(0.01), cell.bias.shape,\n cell.bias.dtype))","def init_weights(self, input_size=None, min_w=WEIGHT_MIN,\n max_w=WEIGHT_MAX):\n if input_size is None:\n input_size = self.INPUT_SIZE\n\n # Add a bias weight to each neuron\n weights_per_neuron = input_size + 1\n\n self.weights = np.random.rand(self.size, weights_per_neuron) \\\n * (max_w - min_w) + min_w","def init_weights(self):\n for i in range(5):\n default_init_weights(getattr(self, f'conv{i+1}'), 0.1)","def init_weights(self):\r\n self.embedding.weight.data.uniform_(-0.1, 0.1)\r\n self.fc.bias.data.fill_(0)\r\n self.fc.weight.data.uniform_(-0.1, 0.1)","def trainFreezeBN(self):\n\t\tprint(\"Freezing Mean/Var of BatchNorm2D.\")\n\t\tprint(\"Freezing Weight/Bias of BatchNorm2D.\")\n\t\tfor m in self.modules():\n\t\t\tif isinstance(m, nn.BatchNorm2d):\n\t\t\t\tm.eval()\n\t\t\t\tm.weight.requires_grad = False\n\t\t\t\tm.bias.requires_grad = False","def trainFreezeBN(self):\n\t\tprint(\"Freezing Mean/Var of BatchNorm2D.\")\n\t\tprint(\"Freezing Weight/Bias of BatchNorm2D.\")\n\t\tfor m in self.modules():\n\t\t\tif isinstance(m, nn.BatchNorm2d):\n\t\t\t\tm.eval()\n\t\t\t\tm.weight.requires_grad = False\n\t\t\t\tm.bias.requires_grad = False"],"string":"[\n \"def update_weights(self):\\n\\t\\tpass\",\n \"def update_weights(self):\\n self._weights = self._weights + self.update_weights_value\\n self.weights_clipping()\",\n \"def update_mini_batch2_4(self, mini_batch, eta):\\r\\n nabla_b = [np.zeros(b.shape) for b in self.biases]\\r\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\r\\n #backup_b = [np.zeros(b.shape) for b in self.biases]\\r\\n backup_w = [np.zeros(w.shape) for w in self.weights]\\r\\n rand = [list(set([np.random.randint(0,y) for i in range(int(y/2))])) for y in self.sizes]\\r\\n \\r\\n\\r\\n for i in range(len(self.biases)):\\r\\n bi=self.biases[i]\\r\\n we = self.weights[i]\\r\\n ra = rand[i]\\r\\n ra2 = rand[i+1]\\r\\n #bab = backup_b[i]\\r\\n baw = backup_w[i]\\r\\n for j in range(len(ra)):\\r\\n for a in range(len(we)):\\r\\n baw[a][ra[j]]=we[a][ra[j]]\\r\\n we[a][ra[j]]=np.zeros(baw[a][ra[j]].shape)\\r\\n #for j in range(len(ra2)):\\r\\n #bab[ra2[j]]=bi[ra2[j]]\\r\\n #bi[ra2[j]]=np.zeros(bab[ra2[j]].shape)\\r\\n\\r\\n \\r\\n for x, y in mini_batch:\\r\\n delta_nabla_b, delta_nabla_w = self.backprop(x, y)\\r\\n #print('w')\\r\\n #print(delta_nabla_w)\\r\\n nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\\r\\n nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\\r\\n\\r\\n self.weights = [w-(eta/len(mini_batch))*nw\\r\\n for w, nw in zip(self.weights, nabla_w)]\\r\\n self.biases = [b-(eta/len(mini_batch))*nb\\r\\n for b, nb in zip(self.biases, nabla_b)]\\r\\n\\r\\n for i in range(len(self.biases)):\\r\\n bi=self.biases[i]\\r\\n we = self.weights[i]\\r\\n ra = rand[i]\\r\\n ra2 = rand[i+1]\\r\\n #bab = backup_b[i]\\r\\n baw = backup_w[i]\\r\\n\\r\\n for j in range(len(ra)):\\r\\n for a in range(len(we)):\\r\\n we[a][ra[j]]=baw[a][ra[j]]\\r\\n \\r\\n #for j in range(len(ra2)):\\r\\n #bi[ra2[j]]=bab[ra2[j]]\\r\",\n \"def update_weights(self):\\n self._weights = self._weights + self.update_weights_value\",\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(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_weights(self, BMU, currentIteration, input_data, lambda1):\\n # Learning rate selection for each epoch\\n lr = self.currentLearningRate(currentIteration, lambda1)\\n \\n # Neighborhood radius selection for each epoch\\n radius = self.currentNeighbourhoodRadius(currentIteration, lambda1)\\n \\n # Iterating through randomly initialized weights and update weights\\n for i in range(len(self.weights[0])):\\n for j in range(len(self.weights)):\\n tmpDist = np.power(BMU[0] - i, 2) + np.power(BMU[1] - j, 2)\\n theta = np.exp(-tmpDist / (2*np.power(radius, 2)))\\n for k in range(self.input_dimension):\\n self.weights[i][j][k] = self.weights[i][j][k] + lr * theta * (input_data[k] - self.weights[i][j][k])\",\n \"def update(self,mini_batch,eta):\\r\\n\\t\\tnabla_b=[np.zeros(b.shape) for b in self.biases]\\r\\n\\t\\tnabla_w=[np.zeros(w.shape) for w in self.weights]\\r\\n\\t\\tfor x,y in mini_batch:\\r\\n\\t\\t\\tdelta_nabla_b, delta_nabla_w=self.backprop(x,y)\\r\\n\\t\\t\\tnabla_b= [nb+dnb for nb,dnb in zip(nabla_b,delta_nabla_b)]\\r\\n\\t\\t\\tnabla_w= [nw+dnw for nw,dnw in zip(nabla_w,delta_nabla_w)]\\r\\n\\t\\tself.weights=[w-(eta/len(mini_batch))*nw for \\r\\n\\t\\tw, nw in zip (self.weights, nabla_w)]\\r\\n\\t\\tself.biases=[b-(eta/len(mini_batch))*nb for\\r\\n\\t\\tb, nb in zip (self.biases, nabla_b)]\",\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 trainOnDataset(self, dataset):\\n cfg = self.cfg\\n for rows in dataset.randomBatches(self.datasetField, cfg.batchSize):\\n olduw, olduhb, olduvb = \\\\\\n zeros((self.rbm.visibleDim, self.rbm.hiddenDim)), \\\\\\n zeros(self.rbm.hiddenDim), zeros(self.rbm.visibleDim)\\n\\n for t in range(cfg.maxIter):\\n #print(\\\"*** Iteration %2d **************************************\\\" % t)\\n\\n params = self.rbm.params\\n params = params.reshape((self.rbm.visibleDim, self.rbm.hiddenDim))\\n biasParams = self.rbm.biasParams\\n\\n mm = cfg.iniMm if t < cfg.mmSwitchIter else cfg.finMm\\n\\n w, hb, vb = self.calcUpdateByRows(rows)\\n\\n #print(\\\"Delta: \\\")\\n #print(\\\"Weight: \\\",)\\n #print(w)\\n #print(\\\"Visible bias: \\\",)\\n #print(vb)\\n #print(\\\"Hidden bias: \\\",)\\n #print(hb)\\n #print(\\\"\\\")\\n\\n olduw = uw = olduw * mm + \\\\\\n \\tcfg.rWeights * (w - cfg.weightCost * params)\\n olduhb = uhb = olduhb * mm + cfg.rHidBias * hb\\n olduvb = uvb = olduvb * mm + cfg.rVisBias * vb\\n\\n #print(\\\"Delta after momentum: \\\")\\n #print(\\\"Weight: \\\",)\\n #print(uw)\\n #print(\\\"Visible bias: \\\",)\\n #print(uvb)\\n #print(\\\"Hidden bias: \\\",)\\n #print(uhb)\\n #print(\\\"\\\")\\n\\n # update the parameters of the original rbm\\n params += uw\\n biasParams += uhb\\n\\n # Create a new inverted rbm with correct parameters\\n invBiasParams = self.invRbm.biasParams\\n invBiasParams += uvb\\n self.invRbm = self.rbm.invert()\\n self.invRbm.biasParams[:] = invBiasParams\\n\\n #print(\\\"Updated \\\")\\n #print(\\\"Weight: \\\",)\\n #print(self.rbm.connections[self.rbm['visible']][0].params.reshape( \\\\)\\n # (self.rbm.indim, self.rbm.outdim))\\n #print(\\\"Visible bias: \\\",)\\n #print(self.invRbm.connections[self.invRbm['bias']][0].params)\\n #print(\\\"Hidden bias: \\\",)\\n #print(self.rbm.connections[self.rbm['bias']][0].params)\\n #print(\\\"\\\")\",\n \"def update(self, x_dict, y_dict, weight):\\n assert len(x_dict) == len(y_dict), \\\"invalid # of qids\\\"\\n \\n qids = self.__get_shuffled_qids(x_dict, y_dict, weight.epoch)\\n w = weight.get_dense_weight()\\n for qid in tqdm(qids):\\n w = approx_ap(x_dict[qid].toarray(), y_dict[qid], w, self.eta, self.alpha, self.beta)\\n weight.set_weight(sp.csr_matrix(w.reshape((1, weight.dims))))\\n weight.epoch += 1\",\n \"def updateWeights(self,weightUpdate):\\n\\t\\n\\t\\tbranches = self.collectAllBranches()\\n\\n\\t\\tfor i in range(self.nBranches):\\n\\n\\t\\t\\tbranches[i].weight -= weightUpdate[i]\",\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(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 set_weights_to_layers(self, candidate):\\r\\n last_idx = 0\\r\\n\\r\\n # Iterate over every layer\\r\\n for layer_idx in range(0, self.num_layers, 1):\\r\\n if layer_idx %2 == 0 : \\r\\n # Get layer dimensions\\r\\n w_shape = self.layers[layer_idx].weight.shape\\r\\n w_numel = np.prod(w_shape)\\r\\n if self.bias :\\r\\n b_shape = self.layers[layer_idx].bias.shape\\r\\n b_numel = np.prod(b_shape)\\r\\n # Decode the candidate and get weight, bias matrices\\r\\n weight = candidate[last_idx:last_idx + w_numel].reshape(w_shape)\\r\\n last_idx += w_numel\\r\\n if self.bias :\\r\\n bias = candidate[last_idx:last_idx + b_numel].reshape(b_shape)\\r\\n last_idx += b_numel\\r\\n else :\\r\\n bias = []\\r\\n\\r\\n# if self.gpu:\\r\\n# weight = weight.to(device='cuda:'+str(model.rank))\\r\\n# if self.bias:\\r\\n# bias = bias.to(device='cuda:'+str(model.rank))\\r\\n# # Set layer weight, bias\\r\\n self.layers[layer_idx].weight = torch.nn.Parameter(weight)\\r\\n if self.bias :\\r\\n self.layers[layer_idx].bias = torch.nn.Parameter(bias)\",\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 _step(self):\\n # Make a minibatch of training data\\n num_train = self.X_train.shape[0]\\n # random choose the samples\\n batch_mask = np.random.choice(num_train, self.batch_size)\\n X_batch = self.X_train[batch_mask]\\n y_batch = self.y_train[batch_mask]\\n\\n # Compute loss and gradient\\n loss, grads = self.model.loss(X_batch, y_batch)\\n self.loss_history.append(loss)\\n\\n # Perform a parameter update\\n for p, w in self.model.params.items():\\n dw = grads[p]\\n config = self.optim_configs[p]\\n next_w, next_config = self.update_rule(w, dw, config)\\n self.model.params[p] = next_w\\n self.optim_configs[p] = next_config\",\n \"def update_mini_batch(self, mini_batch, eta):\\n nabla_b, nabla_w = self.back_propagate_matrix_based(mini_batch)\\n\\n # Gradient descent: update weights\\n self.weights = [w - (eta / len(mini_batch)) * nw\\n for w, nw in zip(self.weights, nabla_w)]\\n # Gradient descent: update biases\\n self.biases = [b - (eta / len(mini_batch)) * np.asarray(nb)\\n for b, nb in zip(self.biases, nabla_b)]\",\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_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)\",\n \"def update_mini_batch(self, mini_batch, eta):\\n xs, ys = mini_batch.T\\n xs = cp.array(cp.vstack(xs).astype(np.float64).reshape((-1, self.sizes[0], 1)))\\n ys = cp.array(cp.vstack(ys).astype(np.float64).reshape((-1, self.sizes[-1], 1)))\\n delta_nabla_b, delta_nabla_w = self.backprop_batch(xs, ys)\\n self.weights = [w - eta * cp.mean(nw, axis=0) for w, nw in zip(self.weights, delta_nabla_w)]\\n self.biases = [b - eta * cp.mean(nb, axis=0) for b, nb in zip(self.biases, delta_nabla_b)]\",\n \"def _update_parameter(self, dWxh, dbh, dWhy, dby):\\n # Add code to update all the weights and biases here\",\n \"def update_masks(self, index, weight):\\n # determine number of updates without actually updating the count\\n if index not in self._index_update_count:\\n num_update = self.begin_num_update\\n else:\\n num_update = self._index_update_count[index]\\n num_update += 1\\n num_update = max(num_update, self.num_update)\\n\\n # calculate epoch\\n epoch = int((num_update - 1) / self.batches_per_epoch) + 1\\n\\n # determine if masks need to be updated, and get corresponding parameters\\n if index == 0:\\n self.masks_updated = True\\n if self.epoch != epoch:\\n self.epoch = epoch\\n if epoch == 1:\\n self.masks_updated = False\\n if self.weight_sparsity is not None:\\n logging.info(log + 'bias-sparsity={}, weight-sparsity={}'.format(self.bias_sparsity[0], self.weight_sparsity[0]))\\n else:\\n logging.info(log + 'bias-threshold={}, weight-threshold={}'.format(self.bias_threshold[0], self.weight_threshold[0]))\\n if self.pruning_switch_epoch[0] + 1 == epoch:\\n self.masks_updated = False\\n self.pruning_switch_epoch.pop(0)\\n if self.weight_sparsity is not None:\\n self.weight_sparsity.pop(0)\\n self.bias_sparsity.pop(0)\\n logging.info(log + 'bias-sparsity={}, weight-sparsity={}'.format(self.bias_sparsity[0], self.weight_sparsity[0]))\\n else:\\n self.weight_threshold.pop(0)\\n self.bias_threshold.pop(0)\\n logging.info(log + 'bias-threshold={}, weight-threshold={}'.format(self.bias_threshold[0], self.weight_threshold[0]))\\n\\n # update masks if needed\\n if not self.masks_updated:\\n # initialize masks\\n if epoch == 1:\\n self.masks.append(None)\\n # if percentages are given\\n if self.weight_sparsity is not None:\\n if len(weight.shape) == 1:\\n sparsity = self.bias_sparsity[0]\\n else:\\n sparsity = self.weight_sparsity[0]\\n number_unpruned = int((100.0 - sparsity) * weight.size / 100.0)\\n self.masks[index] = topk(NDabs(weight), axis=None, ret_typ='mask',\\n k=number_unpruned)\\n # if thresholds are given\\n else:\\n if len(weight.shape) == 1:\\n threshold = self.bias_threshold[0]\\n else:\\n threshold = self.weight_threshold[0]\\n self.masks[index] = NDabs(weight) >= threshold\\n\\n return not self.masks_updated\",\n \"def update_mini_batch(self,mini_batch,eta):\\n\\t\\t#Shape returns the dimensions of the given array.\\n\\t\\t#Zeros returns an array of 0's of specified dimensions\\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\\t\\tfor x,y in mini_batch:\\n\\t\\t\\tdelta_nabla_b,delta_nabla_w = self.backprop(x,y)\\n\\t\\t\\tnabla_b = [nb+dnb for nb,dnb in zip(nabla_b,delta_nabla_b)]\\n\\t\\t\\tnabla_w = [nw+dnw for nw,dnw in zip(nabla_w,delta_nabla_w)]\\n\\t\\t#Updating weights and biases after backprop alg\\n\\t\\tself.weights = [w-eta/len(mini_batch)*nw\\n\\t\\t\\t\\t\\t\\tfor w,nw in zip(self.weights,nabla_w)]\\n\\t\\tself.biases = [b-eta/len(mini_batch)*nb\\n\\t\\t\\t\\t\\t\\tfor b,nb in zip(self.biases,nabla_b)]\",\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 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 minibatch_fit(self):\\r\\n self.init_plot(self.FEATURES)\\r\\n\\r\\n # YOUR CODE HERE\\r\\n max_batch_nr = self.DATAPOINTS // self.MINIBATCH_SIZE\\r\\n batch_nr = 1\\r\\n\\r\\n while not self.converged() or self.training_iteration == 0:\\r\\n print('Processing batch nr: ', batch_nr)\\r\\n self.compute_gradient_minibatch(batch_nr)\\r\\n self.upd_theta()\\r\\n self.update_plot(np.sum(np.square(self.gradient)))\\r\\n\\r\\n batch_nr += 1\\r\\n # start over on first batch if processed all data\\r\\n batch_nr = batch_nr % max_batch_nr\\r\\n self.training_iteration += 1\",\n \"def _update_mini_batch(self, data_batch, labs_batch, eta, lmbda, n):\\n # forward data through the net\\n affines, activations = self._propagate(data_batch)\\n # back propagate and calculate gradient on the whole batch\\n nabla_b, nabla_w = self._backprop(affines, activations, labs_batch)\\n\\n # TODO add momentum\\n self.weights = [w - eta * nw\\n for w, nw in zip(self.weights, nabla_w)]\\n self.biases = [b - eta * nb\\n for b, nb in zip(self.biases, nabla_b)]\",\n \"def _initialize_weights(self):\\n stddev = 1.0 / math.sqrt(self._hidden_size)\\n for layer_id, param_id in itertools.product(\\n range(self._num_layers * (self._bidirectional + 1)),\\n range(self._num_gates * 2)):\\n i = layer_id * 2 + (param_id // self._num_gates)\\n j = i + len(self._weights_shapes) // 2\\n matrix_shape = self._weights_shapes[i][:]\\n bias_shape = self._weights_shapes[j][:]\\n matrix_shape[0] //= self._num_gates\\n bias_shape[0] //= self._num_gates\\n self._set_parameter(\\n init_ops.random_uniform(matrix_shape, -stddev, stddev),\\n layer_id, param_id, 'matrix')\\n self._set_parameter(\\n init_ops.random_uniform(bias_shape, -stddev, stddev),\\n layer_id, param_id, 'bias')\",\n \"def update(self, x_train_single, updated_h):\\n # x_row = cp.array(x_train_single.toarray())\\n # cp.cuda.Stream.null.synchronize()\\n updater(x_train_single,updated_h,self.weights,self.num_features,self.num_models,self.learning_rate)\\n # self.biases += updated_h * self.learning_rate\",\n \"def update_bias(self):\\n self._bias = self._bias + self.update_bias_value\\n self.bias_clipping()\",\n \"def __init__(self, in_features, out_features):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n mean = 0\\n std_dev = 0.0001\\n #print(in_features)\\n #print(out_features)\\n # create weight matrices\\n weight = np.random.normal(mean, std_dev, (out_features, in_features))\\n #print(weight.shape)\\n grad_weight = np.zeros((in_features, out_features))\\n\\n # create biases (in batches)\\n bias = np.zeros(out_features)\\n grad_bias = np.zeros(out_features)\\n\\n self.params = {'weight': weight, 'bias': bias}\\n self.grads = {'weight': bias, 'bias': grad_bias}\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def _initialize_weights(self):\\n pass\",\n \"def init_weight(self):\\n init_bn(self.norm0)\",\n \"def set_weights(self,weights):\\n for i,layer in enumerate(weights):\\n #checking for any values equal to minval\\n if np.any(layer==self.minval):\\n weights[i]=np.where(weights[i]==self.minval,self.replace_min,weights[i])\\n super().set_weights(list(weights))\",\n \"def update_mini_batch(self, mini_batch, eta):\\n nabla_b = [np.zeros(b.shape) for b in self.biases] #按照偏置矩阵大小生成一个为0的矩阵\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\n for x, y in mini_batch: #循环全部最小样本集后，再进行权重和偏置值的调整 \\n delta_nabla_b, delta_nabla_w = self.backprop(x, y)\\n nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\\n nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\\n self.weights = [w-(eta/len(mini_batch))*nw\\n for w, nw in zip(self.weights, nabla_w)]\\n self.biases = [b-(eta/len(mini_batch))*nb\\n for b, nb in zip(self.biases, nabla_b)]\",\n \"def minibatcher(inputs, targets, batchsize, shuffle=False):\",\n \"def init_weights(self):\\n # Initialize weights\\n self.apply(self._init_weights)\\n # Tie weights if needed\\n self.tie_weights()\",\n \"def init_weights(self):\\n # Initialize weights\\n self.apply(self._init_weights)\",\n \"def train_minibatch(self, **kwargs):\\n raise NotImplementedError\",\n \"def initialize_weights(self):\\n weights_initializer.WeightsInitializer.initialize_layer_or_model(\\n self._batch)\",\n \"def update_mini_batch(self, mini_batch, eta):\\r\\n nabla_b = [np.zeros(b.shape) for b in self.biases]\\r\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\r\\n for x, y in mini_batch:\\r\\n delta_nabla_b, delta_nabla_w = self.backprop(x, y)\\r\\n nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\\r\\n nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\\r\\n self.weights = [w-(eta/len(mini_batch))*nw\\r\\n for w, nw in zip(self.weights, nabla_w)]\\r\\n self.biases = [b-(eta/len(mini_batch))*nb\\r\\n for b, nb in zip(self.biases, nabla_b)]\",\n \"def __train_hebbs__(self):\\n\\n rho = self.__get_rho__()\\n\\n copied_train_data = np.copy(self.train_data)\\n\\n for curr_train_sample in tqdm(copied_train_data,\\n disable=not self.verbose,\\n postfix=f'Model training...'):\\n\\n train_sample_norm = curr_train_sample - rho\\n\\n assert len(train_sample_norm.shape) == 1, \\\\\\n f'Flatten your input! Now dim is: {train_sample_norm.shape}'\\n\\n self.weights += np.outer(train_sample_norm, train_sample_norm)\\n\\n diagonal_values = np.diag(self.weights) # extracts diagonal values from matrix\\n diagonal_weights = np.diag(diagonal_values) # creates diagonal matrix from diagonal values for weights\\n\\n self.weights = self.weights - diagonal_weights\\n self.weights = self.weights / len(self.train_data)\",\n \"def _set_weights(self, weights):\\r\\n self.weights = weights.reshape(self.output_size, self.input_size+1)\",\n \"def init_weights(self):\\n\\n params = torch.load(self.resnet_weight)\\n\\n self.fc1.weight.data = params['state_dict']['module.fc.weight'].clone()\\n self.fc1.bias.data = params['state_dict']['module.fc.bias'].clone()\\n\\n\\n r = np.sqrt(1.) / np.sqrt(self.fc3.in_features +\\n self.fc3.out_features)\\n self.fc3.weight.data.uniform_(-r, r)\\n self.fc3.bias.data.fill_(0)\\n r = np.sqrt(1.) / np.sqrt(self.fc2.in_features +\\n self.fc2.out_features)\\n self.fc2.weight.data.uniform_(-r, r)\\n self.fc2.bias.data.fill_(0)\\n r = np.sqrt(1.) / np.sqrt(self.fc4.in_features +\\n self.fc4.out_features)\\n self.fc4.weight.data.uniform_(-r, r)\\n self.fc4.bias.data.fill_(0)\",\n \"def _train_pattern(self, matrix, input, current, bmu):\\n\\n for input_neuron in range(self.input_neuron_count):\\n current_weight = matrix[current][input_neuron]\\n input_value = input[input_neuron]\\n\\n new_weight = self._determine_new_weight(current_weight,\\n input_value, current, bmu)\\n\\n self.correction_matrix[current][input_neuron] = new_weight\",\n \"def update_bias(self):\\n self._bias = self._bias + self.update_bias_value\",\n \"def reassignWeights(self,weights):\\n\\t\\n\\t\\tbranches = self.collectAllBranches()\\n\\n\\t\\tfor i in range(self.nBranches):\\n\\n\\t\\t\\tbranches[i].weight = weights[i]\",\n \"def init_weights(self):\\n self.transformer.init_weights()\\n if self.loss_cls.use_sigmoid:\\n bias_init = bias_init_with_prob(0.01)\\n for m in self.cls_branches:\\n nn.init.constant_(m[-1].bias, bias_init)\",\n \"def update_mini_batch2_6(self, mini_batch):\\r\\n nabla_b = [np.zeros(b.shape) for b in self.biases]\\r\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\r\\n for x, y in mini_batch:\\r\\n delta_nabla_b, delta_nabla_w = self.backprop(x, y)\\r\\n nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\\r\\n nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\\r\\n mysum = sum([sum([sum(j) for j in nabla_w[i]]) for i in range(len(nabla_w))])\\r\\n if mysum*self.sign<0:\\r\\n if(self.eta>0.5):\\r\\n self.eta=self.eta/2\\r\\n self.sign=self.sign*(-1)\\r\\n else:\\r\\n if(self.eta<10):\\r\\n self.eta=self.eta*2\\r\\n self.weights = [w-(self.eta/len(mini_batch))*nw\\r\\n for w, nw in zip(self.weights, nabla_w)]\\r\\n self.biases = [b-(self.eta/len(mini_batch))*nb\\r\\n for b, nb in zip(self.biases, nabla_b)]\",\n \"def mutate(self):\\n \\n # Mutate each weight\\n self.w1 = self.w1 + np.random.normal(0, 1, 8).reshape((2,4))\\n self.b1 = self.b1 + np.random.normal(0, 1, 2).reshape((2,1))\\n self.w2 = self.w2 + np.random.normal(0, 1, 4).reshape((2,2))\\n self.b2 = self.b2 + np.random.normal(0, 1, 2).reshape((2,1))\\n self.w3 = self.w3 + np.random.normal(0, 1, 2).reshape((1,2))\\n self.b3 = self.b3 + np.random.normal(0, 1, 1)\\n \\n # Return thyself\\n return self\",\n \"def set_weights(self, W):\\r\\n if self.weights.shape!=W.shape:\\r\\n return -1\\r\\n self.weights = W\",\n \"def _modify_updates(self, updates):\\n\\n if self.max_kernel_norm is not None:\\n W, = self.transformer.get_params()\\n if W in updates:\\n updated_W = updates[W]\\n row_norms = T.sqrt(T.sum(T.sqr(updated_W), axis=(0, 1, 2)))\\n desired_norms = T.clip(row_norms, 0, self.max_kernel_norm)\\n scales = desired_norms / (1e-7 + row_norms)\\n updates[W] = (updated_W * scales.dimshuffle('x', 'x', 'x', 0))\",\n \"def test_net_weight_update(self):\\n nn = NeuralNet(0, 0, '', '', blank=True)\\n nn.create_net(2, 1, 2, 2)\\n nn.eta = 0.1\\n\\n # Override weights to static value for reproducibility\\n for node in nn.layers[2].nodes:\\n node.weights = [0.6, 0.6]\\n\\n for node in nn.layers[3].nodes:\\n node.weights = [1.0, 1.0]\\n\\n nn.update_weights([2, 3], [0], test=True)\\n\\n test_weight = nn.layers[-1].nodes[0].weights[0]\\n self.assertEqual(round(test_weight, 4), 0.9901)\",\n \"def initialize_weights(self, weights_initializer, bias_initializer):\\n wshapes = [\\n [self.input_size, self.hidden_size[0]],\\n [self.hidden_size[0], self.hidden_size[1]],\\n [self.hidden_size[1], self.output_size]\\n ]\\n\\n bshapes = [\\n [1, self.hidden_size[0]],\\n [1, self.hidden_size[1]],\\n [1, self.output_size]\\n ]\\n\\n self.weights = [init_weights(s, weights_initializer) for s in wshapes]\\n self.biases = [init_weights(s, bias_initializer) for s in bshapes]\\n\\n self.trainable_variables = self.weights + self.biases\",\n \"def init_weights_(self):\\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 update(self):\\n\\n self._eps_count += 1\\n if self._replay.size >= self._min_replay_size:\\n for _ in range(self._learning_updates):\\n samples_indices, minibatch = self._replay.sample(self._batch_size)\\n tf_minibatch = [tf.constant(mat, dtype=tf_type) for mat, tf_type in zip(minibatch, [tf.float32, tf.int32, tf.float32, tf.float32, tf.float32])]\\n self._learn(*tf_minibatch)\\n\\n self._learn_iter_counter += 1\\n if (self._target_update_period > 1) and (self._learn_iter_counter % self._target_update_period == 0):\\n self._update_target_nets()\",\n \"def update_weight(self,ctr,new_weight):\\n self.sum1 -= self.data_set[ctr].weight\\n self.data_set[ctr].weight = new_weight\\n self.sum1 += new_weight\",\n \"def my_assign_weights(context, data):\\n pass\",\n \"def update_network(self, a, batch_size):\\n for layer in self.layers:\\n layer.weights_update(a, self.alpha, self.l2_lambda, batch_size)\\n a = layer.a\",\n \"def initialize_weights(self):\\n for layer in self._cnn_layers:\\n weights_initializer.WeightsInitializer.initialize_layer_or_model(layer)\",\n \"def initWeights(self):\\n self.weights = []\\n self.bias = []\\n for i, dim in enumerate(self.dimensions[1:]):\\n self.weights.append(np.random.uniform(-1,1,(self.dimensions[i],dim)))\\n self.bias.append(np.random.uniform(-1,1,dim))\",\n \"def init_weights(self) -> None:\\n nn.init.kaiming_normal_(self._U)\\n nn.init.kaiming_normal_(self._W)\\n nn.init.kaiming_normal_(self._V)\\n\\n nn.init.normal_(self._b)\",\n \"def change_weight(self, new_weight_arr):\\n self.weights = new_weight_arr\",\n \"def _train(self, bmu, matrix, input):\\n # adjust the weight for the BMU and its neighborhood\\n for output_neuron in range(self.output_neuron_count):\\n self._train_pattern(matrix, input, output_neuron, bmu)\",\n \"def init_weights(self):\\n r = np.sqrt(6.) / np.sqrt(self.fc1.in_features +\\n self.fc1.out_features)\\n self.fc1.weight.data.uniform_(-r, r)\\n self.fc1.bias.data.fill_(0)\\n r = np.sqrt(6.) / np.sqrt(self.fc2.in_features +\\n self.fc2.out_features)\\n self.fc2.weight.data.uniform_(-r, r)\\n self.fc2.bias.data.fill_(0)\",\n \"def _reweight(self):\\n self._seed_weights = [self._graph.degree(seed) for seed in self._seeds]\\n weight_sum = np.sum(self._seed_weights)\\n self._seed_weights = [float(weight)/weight_sum for weight in self._seed_weights]\",\n \"def hard_update_target_network(self,step):\\n \\n if step % self.C == 0:\\n pars = self.model.get_weights()\\n self.target_model.set_weights(pars)\",\n \"def hard_update_target_network(self,step):\\n \\n if step % self.C == 0:\\n pars = self.model.get_weights()\\n self.target_model.set_weights(pars)\",\n \"def set_weights(self, weights):\\n tuples = []\\n for layer in self.layers:\\n num_param = len(layer.weights)\\n layer_weights = weights[:num_param]\\n for sw, w in zip(layer.weights, layer_weights):\\n tuples.append((sw, w))\\n weights = weights[num_param:]\\n K.batch_set_value(tuples)\",\n \"def normalizeWeights(self):\\n for wt in self.weights:\\n wt[wt>1] = 1\\n wt[wt<-1] = -1\\n for bs in self.bias:\\n bs[bs>1] = 1\\n bs[bs<-1] = -1\",\n \"def _set_weights(self, weights):\\n i = iter(weights)\\n\\n for param in self.params:\\n param.set_value(i.next())\",\n \"def _set_weights(self, weights):\\n i = iter(weights)\\n\\n for param in self.params:\\n param.set_value(i.next())\",\n \"def update_mini_batch1_7(self, mini_batch, eta):\\r\\n nabla_b = [np.zeros(b.shape) for b in self.biases]\\r\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\r\\n for x, y in mini_batch:\\r\\n delta_nabla_b, delta_nabla_w = self.backprop1_7(x, y)\\r\\n nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\\r\\n nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\\r\\n self.weights = [w-(eta/len(mini_batch))*nw\\r\\n for w, nw in zip(self.weights, nabla_w)]\\r\\n self.biases = [b-(eta/len(mini_batch))*nb\\r\\n for b, nb in zip(self.biases, nabla_b)]\",\n \"def set_weights(self, weights):\\r\\n self.weights = weights\",\n \"def update_target_model(self):\\n self.target_model.set_weights(self.model.get_weights())\",\n \"def update_target_model(self):\\n self.target_model.set_weights(self.model.get_weights())\",\n \"def update_target_model(self):\\n self.target_model.set_weights(self.model.get_weights())\",\n \"def init_weights(model):\\n ...\",\n \"def InitWeights(self):\\n self.w = -1 + 2 * np.random.rand(self.num_of_inputs,)\\n self.w0 = -1 + 2 * np.random.rand()\",\n \"def update_generate_params(self,inps,trgs,preds):\\n batch_size = np.shape(trgs)[0]\\n\\n self.delta_weight_h_to_v = self.learning_rate / batch_size * np.transpose(trgs) @ (inps - preds)\\n self.delta_bias_v = self.learning_rate * np.mean(inps - preds)\\n \\n self.weight_h_to_v += self.delta_weight_h_to_v\\n self.bias_v += self.delta_bias_v \\n \\n return\",\n \"def prepare_weights(self, pre_exist_words, hs, negative, wv, sentences,\\n nonce, update=False, replication=False,\\n sum_over_set=False, weighted=False, beta=1000):\\n # set initial input/projection and hidden weights\\n if not update:\\n raise Exception('prepare_weight on Nonce2VecTrainables should '\\n 'always be used with update=True')\\n else:\\n self.update_weights(pre_exist_words, hs, negative, wv, sentences,\\n nonce, replication, sum_over_set, weighted,\\n beta)\",\n \"def set_weights(self, w):\\n self.nn.set_param_values(w)\",\n \"def _update(self, x: np.ndarray, y: int):\\n decision = self.weights.dot(x)\\n v_t = x @ np.diag(np.diag(self._sigma)) @ x.T\\n m_t = y * decision\\n loss = (self._phi * math.sqrt(v_t) - m_t)\\n #print(loss)\\n if loss > 0:\\n # We scale our learning rate (alpha) using the weight/cost\\n alpha_t = self.class_weight_[y] * self._get_alpha(m_t, v_t)\\n u_t = 0.25 * (-alpha_t * v_t * self._phi + math.sqrt(\\n alpha_t ** 2 * v_t ** 2 * self._phi ** 2 + 4 * v_t)) ** 2\\n beta_t = alpha_t * self._phi / (math.sqrt(u_t) +\\n alpha_t * self._phi * v_t)\\n sigma = np.expand_dims(x @ self._sigma, axis=0)\\n self.weights += alpha_t * y * np.squeeze(sigma)\\n self._sigma -= beta_t * sigma.T @ sigma\",\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_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 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 _minibatch_sgd(self, X_train, y_train):\\n n_samples, n_features = np.shape(X_train)\\n\\n indices = np.arange(n_samples)\\n\\n if self.shuffle:\\n self.random.shuffle(indices)\\n\\n for idx in range(0, n_samples, self.batch_size):\\n\\n batch_idx = indices[idx:idx + self.batch_size]\\n\\n # Forwardpropagation.\\n Z_hidden, A_hidden, Z_out, A_out = self._forwardprop(\\n X_train[batch_idx, :]\\n )\\n\\n # Backpropagation.\\n self._backprop(\\n y_train, X_train, A_hidden, Z_hidden, A_out, Z_out, batch_idx\\n )\\n\\n return self\",\n \"def update_mini_batch(self, mini_batch, eta):\\n nabla_b = [np.zeros(b.shape) for b in self.biases]\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\n\\n for x, y in mini_batch:\\n delta_nabla_b, delta_nabla_w = self.backprop(x, y)\\n nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\\n nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\\n\\n weights = [w-(eta/len(mini_batch))*nw\\n for w, nw in zip(self.weights, nabla_w)]\\n\\n biases = [b-(eta/len(mini_batch))*nb\\n for b, nb in zip(self.biases, nabla_b)]\\n\\n return Network(self.sizes, weights=weights, biases=biases)\",\n \"def rebalance_weightings(context):\\r\\n total_ratio = 0\\r\\n log.info(\\\"*******Rebalancing weightings********\\\")\\r\\n print(context.up_ratios)\\r\\n \\r\\n for asset, ratio in context.up_ratios.items():\\r\\n total_ratio += ratio\\r\\n \\r\\n for asset, ratio in context.up_ratios.items():\\r\\n context.max_weights[asset] = ratio/total_ratio\\r\\n \\r\\n log.info(context.max_weights)\",\n \"def update_weights(self, example):\\n pred = self.predict(example)\\n if pred != example.label:\\n self.weights[example.label] = self.weights[example.label] + example.fvector\\n self.weights[pred] = self.weights[pred] - example.fvector\",\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 sgd(self):\\n for i, j, r in self.samples:\\n # Computer prediction and error\\n if (self.type=='bias'):\\n prediction = self.get_rating_bias(i, j)\\n elif(self.type=='nonbias') :\\n prediction = self.get_rating(i, j)\\n # print(i, j, r,prediction)\\n e = (r - prediction)\\n\\n # Update biases\\n self.b_u[i] =self.b_u[i]+ self.alpha * (e - self.beta * self.b_u[i])\\n self.b_i[j] = self.b_i[j] + self.alpha * (e - self.beta * self.b_i[j])\\n\\n # Create copy of row of P since we need to update it but use older values for update on Q\\n P_i = self.P[i, :][:]\\n\\n # Update user and item latent feature matrices\\n # print(self.alpha * (e * self.Q[j, :] - self.beta * self.P[i, :]))\\n # print(self.P[i, :])\\n self.P[i, :] =self.P[i, :] + self.alpha * (e * self.Q[j, :] - self.beta * self.P[i, :])\\n # print(self.P[i, :],\\\"&&&&&&\\\")\\n self.Q[j, :] = self.Q[j, :] + self.alpha * (e * P_i - self.beta * self.Q[j, :])\\n # print(self.Q[j, :])\",\n \"def _initialize_weights(self):\\n for _, cell in self.cells_and_names():\\n if isinstance(cell, nn.Conv2d):\\n cell.weight.set_data(orthogonal(cell.weight.shape, 0.6))\\n if cell.bias is not None:\\n cell.bias.set_data(\\n init.initializer(init.Constant(0.01), cell.bias.shape,\\n cell.bias.dtype))\",\n \"def init_weights(self, input_size=None, min_w=WEIGHT_MIN,\\n max_w=WEIGHT_MAX):\\n if input_size is None:\\n input_size = self.INPUT_SIZE\\n\\n # Add a bias weight to each neuron\\n weights_per_neuron = input_size + 1\\n\\n self.weights = np.random.rand(self.size, weights_per_neuron) \\\\\\n * (max_w - min_w) + min_w\",\n \"def init_weights(self):\\n for i in range(5):\\n default_init_weights(getattr(self, f'conv{i+1}'), 0.1)\",\n \"def init_weights(self):\\r\\n self.embedding.weight.data.uniform_(-0.1, 0.1)\\r\\n self.fc.bias.data.fill_(0)\\r\\n self.fc.weight.data.uniform_(-0.1, 0.1)\",\n \"def trainFreezeBN(self):\\n\\t\\tprint(\\\"Freezing Mean/Var of BatchNorm2D.\\\")\\n\\t\\tprint(\\\"Freezing Weight/Bias of BatchNorm2D.\\\")\\n\\t\\tfor m in self.modules():\\n\\t\\t\\tif isinstance(m, nn.BatchNorm2d):\\n\\t\\t\\t\\tm.eval()\\n\\t\\t\\t\\tm.weight.requires_grad = False\\n\\t\\t\\t\\tm.bias.requires_grad = False\",\n \"def trainFreezeBN(self):\\n\\t\\tprint(\\\"Freezing Mean/Var of BatchNorm2D.\\\")\\n\\t\\tprint(\\\"Freezing Weight/Bias of BatchNorm2D.\\\")\\n\\t\\tfor m in self.modules():\\n\\t\\t\\tif isinstance(m, nn.BatchNorm2d):\\n\\t\\t\\t\\tm.eval()\\n\\t\\t\\t\\tm.weight.requires_grad = False\\n\\t\\t\\t\\tm.bias.requires_grad = False\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7421371","0.6991882","0.6848822","0.67945004","0.67168677","0.66101074","0.65153664","0.65024835","0.64673924","0.64332306","0.64307845","0.63667667","0.63380885","0.6334833","0.6333449","0.63224673","0.6308737","0.63058054","0.6305587","0.6304924","0.62940425","0.62931585","0.6277687","0.62573534","0.6256859","0.6245771","0.6198139","0.6196149","0.61832815","0.6162908","0.61595875","0.6134184","0.6127472","0.61202943","0.6119717","0.61163205","0.6100196","0.6097296","0.6094432","0.60891765","0.60883445","0.6080717","0.6075486","0.60651803","0.6058342","0.6057683","0.6046446","0.6040893","0.6031536","0.6026279","0.6024341","0.6021241","0.6010585","0.6005012","0.60043645","0.6002807","0.5997904","0.5988971","0.5987137","0.598131","0.59689945","0.59688276","0.5959891","0.59598887","0.5940765","0.59354985","0.59228724","0.5921511","0.59182155","0.59182155","0.591427","0.5912656","0.59110487","0.59110487","0.5900486","0.58950925","0.58909833","0.58909833","0.58909833","0.5889718","0.588874","0.5887086","0.5882035","0.58780134","0.5871512","0.58654565","0.5864505","0.58620954","0.5861156","0.58567566","0.5848493","0.58445346","0.5843685","0.58427775","0.58413017","0.5837357","0.5830861","0.58279514","0.582574","0.582574"],"string":"[\n \"0.7421371\",\n \"0.6991882\",\n \"0.6848822\",\n \"0.67945004\",\n \"0.67168677\",\n \"0.66101074\",\n \"0.65153664\",\n \"0.65024835\",\n \"0.64673924\",\n \"0.64332306\",\n \"0.64307845\",\n \"0.63667667\",\n \"0.63380885\",\n \"0.6334833\",\n \"0.6333449\",\n \"0.63224673\",\n \"0.6308737\",\n \"0.63058054\",\n \"0.6305587\",\n \"0.6304924\",\n \"0.62940425\",\n \"0.62931585\",\n \"0.6277687\",\n \"0.62573534\",\n \"0.6256859\",\n \"0.6245771\",\n \"0.6198139\",\n \"0.6196149\",\n \"0.61832815\",\n \"0.6162908\",\n \"0.61595875\",\n \"0.6134184\",\n \"0.6127472\",\n \"0.61202943\",\n \"0.6119717\",\n \"0.61163205\",\n \"0.6100196\",\n \"0.6097296\",\n \"0.6094432\",\n \"0.60891765\",\n \"0.60883445\",\n \"0.6080717\",\n \"0.6075486\",\n \"0.60651803\",\n \"0.6058342\",\n \"0.6057683\",\n \"0.6046446\",\n \"0.6040893\",\n \"0.6031536\",\n \"0.6026279\",\n \"0.6024341\",\n \"0.6021241\",\n \"0.6010585\",\n \"0.6005012\",\n \"0.60043645\",\n \"0.6002807\",\n \"0.5997904\",\n \"0.5988971\",\n \"0.5987137\",\n \"0.598131\",\n \"0.59689945\",\n \"0.59688276\",\n \"0.5959891\",\n \"0.59598887\",\n \"0.5940765\",\n \"0.59354985\",\n \"0.59228724\",\n \"0.5921511\",\n \"0.59182155\",\n \"0.59182155\",\n \"0.591427\",\n \"0.5912656\",\n \"0.59110487\",\n \"0.59110487\",\n \"0.5900486\",\n \"0.58950925\",\n \"0.58909833\",\n \"0.58909833\",\n \"0.58909833\",\n \"0.5889718\",\n \"0.588874\",\n \"0.5887086\",\n \"0.5882035\",\n \"0.58780134\",\n \"0.5871512\",\n \"0.58654565\",\n \"0.5864505\",\n \"0.58620954\",\n \"0.5861156\",\n \"0.58567566\",\n \"0.5848493\",\n \"0.58445346\",\n \"0.5843685\",\n \"0.58427775\",\n \"0.58413017\",\n \"0.5837357\",\n \"0.5830861\",\n \"0.58279514\",\n \"0.582574\",\n \"0.582574\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58211875"},"document_rank":{"kind":"string","value":"100"}}},{"rowIdx":80995,"cells":{"query":{"kind":"string","value":"Return a tuple (nabla_b, nabla_w) representing the gradient for the cost function C_x Each of and are lists of NumPy arrays similar in structure to and"},"document":{"kind":"string","value":"def backprop(self, x, y):\n nabla_b = [np.zeros(b.shape) for b in self.biases]\n nabla_w = [np.zeros(w.shape) for w in self.weights]\n\n # Feed forward\n activation = x\n activations = [x]\n zs = [] # Store the weighted inputs of each layer (z before activation function)\n for b, w in zip(self.biases, self.weights):\n z = np.dot(w, activation) + b\n zs.append(z)\n activation = sigmoid(z)\n activations.append(activation)\n\n # Backward pass\n delta = self.cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])\n nabla_b[-1] = delta\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\n\n # Back propagate (l index starts with last layer being 1)\n for l in range(2, self.num_layers):\n z = zs[-l]\n delta = np.dot(self.weights[-l + 1].transpose(), delta) * sigmoid_prime(z)\n nabla_b[-l] = delta\n nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())\n\n return (nabla_b, nabla_w)"},"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 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 ComputeGradientsTest(X, Y, W, b, my_lambda):\n grad_W = [np.zeros(w.shape) for w in W]\n grad_b = [np.zeros(bi.shape) for bi in b]\n P, _, _ = EvaluateClassifier(X, W, b)\n cost, _ = ComputeCost(Y, W, P, my_lambda)\n for k in range(len(W)):\n\n w = W[k]\n for i in range(w.shape[0]):\n for j in range(w.shape[1]):\n W[k][i][j] += epsilon\n P1, _, _ = EvaluateClassifier(X, W, b)\n cost1, _ = ComputeCost(Y, W, P1, my_lambda)\n W[k][i][j] -= epsilon\n grad_W[k][i][j] = (cost1 - cost) / epsilon\n\n for i in range(b[k].shape[0]):\n b[k][i] += epsilon\n P1, _, _ = EvaluateClassifier(X, W, b)\n cost1, _ = ComputeCost(Y, W, P1, my_lambda)\n b[k][i] -= epsilon\n grad_b[k][i] = (cost1 - cost) / epsilon\n\n return grad_W, grad_b","def ComputeGradsNum(X, Y, P, W, b, lamda, h):\n\tno \t= \tW.shape[0]\n\td \t= \tX.shape[0]\n\n\tgrad_W = np.zeros(W.shape);\n\tgrad_b = np.zeros((no, 1));\n\n\tc = ComputeCost(X, Y, W, b, lamda);\n\t\n\tfor i in range(len(b)):\n\t\tprint(i)\n\t\tb_try = b\n\t\tb_try[i] += h\n\t\tc2 = ComputeCost(X, Y, W, b_try, lamda)\n\t\tgrad_b[i] = (c2-c) / h\n\n\tfor i in range(W.shape[0]):\n\t\tprint(i)\n\t\tfor j in range(W.shape[1]):\n\t\t\tW_try = W\n\t\t\tW_try[i,j] += h\n\t\t\tc2 = ComputeCost(X, Y, W_try, b, lamda)\n\t\t\tgrad_W[i,j] = (c2-c) / h\n\n\treturn [grad_W, grad_b]","def get_cost_updates(self,learning_rate, beta=0.9):\n max_x = T.max(self.x)\n min_x = T.min(self.x)\n self.x = (self.x - min_x) / (max_x - min_x)\n y = self.get_hidden_values(self.x)\n z = self.get_reconstructed_input(y)\n # note : we sum over the size of a datapoint; if we are using\n # minibatches, L will be a vector, with one entry per\n # example in minibatch\n # L = - T.sum(self.x * T.log(z) + (1 - self.x) * T.log(1 - z), axis=1)\n L_prime = T.sum(T.square(z - self.x), axis=1)\n # note : L is now a vector, where each element is the\n # cross-entropy cost of the reconstruction of the\n # corresponding example of the minibatch. We need to\n # compute the average of all these to get the cost of\n # the minibatch\n cost = T.mean(L_prime)\n\n # compute the gradients of the cost of the `dA` with respect\n # to its parameters\n gparams = T.grad(cost, self.params)\n # generate the list of updates\n updates = []\n for momen, gparm1 in zip(self.mom, gparams):\n updates.append((momen, momen * beta + (1 - beta) * gparm1))\n for param, momen in zip(self.params, self.mom):\n updates.append((param, param - learning_rate * momen))\n\n return (cost, updates)","def costFun(self, x):\n\ttmp = x.reshape(self.inp_shape)\n\tc = np.float64(self.calcCost(np.asarray(tmp,dtype=np.float32))) + self.alpha * np.dot(x.T, x)\n\treturn c","def gradient(C, w, b):\n return list(partial_deriv(C, b)) + list(partial_deriv(C, wi) for wi in w)","def get_cost_updates(self):\n\n y = self.get_hidden_values()\n z = self.get_reconstructed_input(y)\n\n L = T.sum((self.x-z)**2, axis=1)\n\n cost = T.mean(L)\n\n return cost","def get_cost_updates(self, contraction_level, learning_rate):\r\n\r\n y = self.get_hidden_values(self.x)\r\n z = self.get_reconstructed_input(y)\r\n J = self.get_jacobian(y, self.W)\r\n # note : we sum over the size of a datapoint; if we are using\r\n # minibatches, L will be a vector, with one entry per\r\n # example in minibatch\r\n self.L_rec = - T.sum(self.x * T.log(z) +\r\n (1 - self.x) * T.log(1 - z),\r\n axis=1)\r\n\r\n # Compute the jacobian and average over the number of samples/minibatch\r\n self.L_jacob = T.sum(J ** 2) / self.n_batchsize\r\n\r\n # note : L is now a vector, where each element is the\r\n # cross-entropy cost of the reconstruction of the\r\n # corresponding example of the minibatch. We need to\r\n # compute the average of all these to get the cost of\r\n # the minibatch\r\n cost = T.mean(self.L_rec) + contraction_level * T.mean(self.L_jacob)\r\n\r\n # compute the gradients of the cost of the `cA` with respect\r\n # to its parameters\r\n gparams = T.grad(cost, self.params)\r\n # generate the list of updates\r\n updates = []\r\n for param, gparam in zip(self.params, gparams):\r\n updates.append((param, param - learning_rate * gparam))\r\n\r\n return (cost, updates)","def get_cost_updates(self, contraction_level, learning_rate):\n self.n_batchsize = 20\n y = self.get_hidden_values(self.x)\n z = self.get_reconstructed_input(y)\n J = self.get_jacobian(y, self.W)\n # note : we sum over the size of a datapoint; if we are using\n # minibatches, L will be a vector, with one entry per\n # example in minibatch\n self.L_rec = - T.sum(self.x * T.log(z) +\n (1 - self.x) * T.log(1 - z),\n axis=1)\n\n # Compute the jacobian and average over the number of samples/minibatch\n self.L_jacob = T.sum(J ** 2) / self.n_batchsize\n\n # note : L is now a vector, where each element is the\n # cross-entropy cost of the reconstruction of the\n # corresponding example of the minibatch. We need to\n # compute the average of all these to get the cost of\n # the minibatch\n cost = T.mean(self.L_rec) + contraction_level * T.mean(self.L_jacob)\n\n # compute the gradients of the cost of the `cA` with respect\n # to its parameters\n gparams = T.grad(cost, self.params)\n # generate the list of updates\n updates = []\n for param, gparam in zip(self.params, gparams):\n updates.append((param, param - learning_rate * gparam))\n\n return (cost, updates)","def backprop_batch(self, xs, ys):\n nabla_b = [cp.zeros(b.shape) for b in self.biases]\n nabla_w = [cp.zeros(w.shape) for w in self.weights]\n\n # forward pass\n activation = xs\n activations = [xs] # list to store all the activations, layer by layer\n zs = [] # list to store all the z vectors, layer by layer\n for b, w in zip(self.biases, self.weights):\n zs.append(w @ activation + b)\n activation = sigmoid(zs[-1])\n activations.append(activation)\n\n # backward pass\n delta = self.cost_derivative(activations[-1], ys) * f_sigmoid_prime(activations[-1])\n nabla_w[-1] = delta @ activations[-2].transpose((0, 2, 1))\n nabla_b[-1] = delta\n for t in range(self.num_layers - 2, 0, -1):\n delta = f_sigmoid_prime(activations[t]) * (self.weights[t].T @ delta)\n nabla_w[t - 1] = delta @ activations[t - 1].transpose((0, 2, 1))\n nabla_b[t - 1] = delta\n return nabla_b, nabla_w","def jacobian(self, xs):\n rx_list = []\n for nx,x in enumerate(xs):\n \n numpy.testing.assert_array_almost_equal(self.independentVariableShapeList[nx], numpy.shape(x), err_msg = '\\ntaped xs[%d].shape != forward xs[%d]\\n'%(nx,nx))\n rx = numpy.ravel(x)\n rx_list.append(rx)\n self.x = numpy.concatenate(rx_list)\n return wrapped_functions.jacobian(self.tape_tag, self.x)","def compute_cost(X, y, theta, lambd):\n assert(theta.shape[0] == X.shape[1])\n \n m = X.shape[0]\n grad = np.zeros(y.shape)\n J = 0\n \n output = sigmoid(np.dot(X, theta))\n\n J = np.sum(- y * np.log(output) - (1 - y) * np.log(1 - output)) / m + lambd / (2 * m) * np.sum(np.square(theta[1:]))\n\n grad = np.dot(X.T, (output - y)) / m\n \n grad[1:] = grad[1:] + lambd / m * theta[1:]\n\n return J, grad","def get_constraint_gradient_array(self, x):\n all_constraint_grads = self.constraint.get_gradient(x)\n constraint_grads = 1. * all_constraint_grads[0]\n for i in range(1, len(all_constraint_grads)):\n constraint_grads = np.column_stack((constraint_grads, 1. * all_constraint_grads[i]))\n return constraint_grads","def backprop(self, x, y):\n nabla_b = [np.zeros(b.shape) for b in self.biases] #返回一个给定形状和类型的用0填充的数组 shape:形状\n nabla_w = [np.zeros(w.shape) for w in self.weights]\n # feedforward\n activation = x\n activations = [x] # list to store all the activations, layer by layer\n zs = [] # list to store all the z vectors, layer by layer\n for b, w in zip(self.biases, self.weights):\n z = np.dot(w, activation)+b # 计算每一个节点的值\n zs.append(z)\n activation = sigmoid(z) # 加入激活函数\n activations.append(activation)\n\n ''' backward pass 最后一层的 w和b \n 因为最后一层没有权重weights因此单独计算，没有放在循环中\n '''\n delta = self.cost_derivative(activations[-1], y) * \\\n sigmoid_prime(zs[-1])\n nabla_b[-1] = delta\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\n # Note that the variable l in the loop below is used a little\n # differently to the notation in Chapter 2 of the book. Here,\n # l = 1 means the last layer of neurons, l = 2 is the\n # second-last layer, and so on. It's a renumbering of the\n # scheme in the book, used here to take advantage of the fact\n # that Python can use negative indices in lists.\n for l in range(2, self.num_layers):\n z = zs[-l]\n sp = sigmoid_prime(z)\n delta = np.dot(self.weights[-l+1].transpose(), delta) * sp\n nabla_b[-l] = delta\n nabla_w[-l] = np.dot(delta, activations[-l-1].transpose()) \n return (nabla_b, nabla_w)","def get_updates(self):\n\n\t\tda_cost = self.get_cost()\n\n\t\tweight_gradient = theano.tensor.grad(da_cost, self.weights)\n\t\tbias_gradient = theano.tensor.grad(da_cost, self.bias)\n\t\treverse_bias_gradient = theano.tensor.grad(da_cost, self.reverse_bias)\n\n\t\tlr_cost = self.get_lr_cost()\n\t\tlr_weight_gradient = theano.tensor.grad(lr_cost, self.label_weights)\n\t\tlr_bias_gradient = theano.tensor.grad(lr_cost, self.label_bias)\n\n\t\tupdates = [\n\t\t\t(self.weights, self.weights - self.learning_rate*weight_gradient),\n\t\t\t(self.bias, self.bias - self.learning_rate*bias_gradient),\n\t\t\t(self.reverse_bias, self.reverse_bias -\n\t\t\t\tself.learning_rate*reverse_bias_gradient),\n\t\t\t(self.label_weights, self.label_weights -\n\t\t\t\tself.learning_rate*lr_weight_gradient),\n\t\t\t(self.label_bias, self.label_bias -\n\t\t\t\tself.learning_rate*lr_bias_gradient)]\n\n\t\treturn updates","def compute_gradient(c, x, y):\n\n vectors = np.array([[0, 1], [0, -1], [1, 0], [-1, 0]])\n rows, cols = c.shape\n\n result = np.empty_like(x)\n\n for i in nb.prange(rows):\n for j in nb.prange(cols):\n c_remainder = c[i, j] % 4\n gradient_co = vectors[c_remainder]\n result[i, j] = gradient_co[0] * x[i, j] + gradient_co[1] * y[i, j]\n\n return result","def compute_cost_gradient1(x, y0, W, b):\n # compute cost\n A = x @ W + b\n y = sigmoid(A)\n if y0 is None:\n return y\n cost = -1 * np.sum(y0 * np.log(y) + (1 - y0) * np.log(1 - y))\n # compute gradients\n dy = -(y0 * (y ** -1) - (1 - y0) * ((1 - y) ** -1))\n dA = dy * (y * (1 - y))\n dW = x.T @ dA\n db = np.sum(dA)\n return cost, dW, db","def b_gradient_descent(self, LB,UB,eta, tol,iter):\n bgd=[]\n bgd_x=[LB]\n iteration=0\n # current_pt=X\n first_derivative=sym.diff(self.gdfunc)\n #print(first_derivative)\n x=sym.Symbol('x')\n first_derivative=sym.lambdify(x,first_derivative)\n learn_rate=eta\n \n new_x=LB\n bgd_x.append(LB)\n \n for i in range(iter):\n for j in np.arange(LB,UB,0.1):\n prev_x=new_x\n new_x=prev_x-(learn_rate*first_derivative(prev_x))\n #print(\"i = \",j,\"gradient =\",(learn_rate*first_derivative(j)),iteration)\n iteration=iteration+1\n #print(iteration)\n if iteration >=iter:\n break \n if new_x <= tol:\n #print(\"new_x = \",new_x,\"gradient =\",(learn_rate*first_derivative(prev_x)), iteration) \n break\n \n \n \n \n #print(new_x)\n bgd_x.append(new_x)\n \n \n bgd.append(bgd_x)\n bgd.append(new_x)\n bgd.append(iteration)\n\n return bgd","def compute_cost_gradient2(x, y0, W, V, U, b0, b1, b2):\n # compute cost\n A1 = x @ W + b0\n A2 = x @ V + b1\n z0 = sigmoid(A1)\n z1 = sigmoid(A2)\n z = np.array([z0, z1]).T\n A3 = z @ U + b2\n y = sigmoid(A3)\n if y0 is None:\n return y\n cost = np.sum((y - y0) ** 2)\n # compute gradient\n dy = 2 * (y - y0)\n dA3 = dy * (y * (1 - y))\n dz0 = dA3 * U[0]\n dz1 = dA3 * U[1]\n dA1 = dz0 * (z0 * (1 - z0))\n dA2 = dz1 * (z1 * (1 - z1))\n dW = x.T @ dA1\n dV = x.T @ dA2\n dU = z.T @ dA3\n db0 = np.sum(dA1)\n db1 = np.sum(dA2)\n db2 = np.sum(dA3)\n return cost, dW, dV, dU, db0, db1, db2","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 ComputeGradsNumSlow(X, Y, P, W, b, lamda, h, classifier):\n no = W.shape[0]\n d = X.shape[0]\n\n grad_W = np.zeros(W.shape);\n grad_b = np.zeros((no, 1));\n\n for i in range(len(b)):\n b_try = np.array(b)\n b_try[i] -= h\n c1 = classifier.ComputeCost(X, Y, W, b_try, lamda)\n\n b_try = np.array(b)\n b_try[i] += h\n c2 = classifier.ComputeCost(X, Y, W, b_try, lamda)\n\n grad_b[i] = (c2 - c1) / (2 * h)\n\n for i in range(W.shape[0]):\n for j in range(W.shape[1]):\n W_try = np.array(W)\n W_try[i, j] -= h\n c1 = classifier.ComputeCost(X, Y, W_try, b, lamda)\n\n W_try = np.array(W)\n W_try[i, j] += h\n c2 = classifier.ComputeCost(X, Y, W_try, b, lamda)\n\n grad_W[i, j] = (c2 - c1) / (2 * h)\n\n return [grad_W, grad_b]","def gradient_descent(x, y, theta=[[0], [0]]):\n m = y.size\n j_history = []\n for i in range(ITERATIONS):\n h = x.dot(theta)\n theta = theta - (ALPHA / m) * (x.T.dot(h - y))\n j_history.append(compute_cost(x, y, theta))\n return theta, j_history","def backprop1_6(self, x, y):\r\n \r\n nabla_b = [np.zeros(b.shape) for b in self.biases]\r\n nabla_w = [np.zeros(w.shape) for w in self.weights]\r\n # feedforward\r\n activation = x\r\n activations = [x] # list to store all the activations, layer by layer\r\n zs = [] # list to store all the z vectors, layer by layer\r\n\r\n for b, w in list(zip(self.biases, self.weights))[:len(self.biases)-1]:\r\n z = np.dot(w, activation)+b\r\n zs.append(z)\r\n activation = relu(z)\r\n #print(activation)\r\n activations.append(activation)\r\n\r\n b = self.biases[-1]\r\n w = self.weights[-1]\r\n z = np.dot(w, activation)+b\r\n zs.append(z)\r\n activation = softmax(z)\r\n activations.append(activation)\r\n\r\n # backward pass\r\n delta = self.cost_derivative(activations[-1], y)\r\n\r\n nabla_b[-1] = delta\r\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\r\n # Note about the variable l: Here,\r\n # l = 1 means the last layer of neurons, l = 2 is the\r\n # second-last layer, and so on. This numbering takes advantage of the fact\r\n # that Python can use negative indices in lists.\r\n for l in range(2, self.num_layers):\r\n z = zs[-l]\r\n sp = reluDerivative(z)\r\n delta = np.dot(self.weights[-l+1].transpose(), delta) * sp\r\n nabla_b[-l] = delta\r\n nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())\r\n return (nabla_b, nabla_w)","def backprop(x, y):\n nabla_b = [np.zeros(b.shape) for b in self.biases]\n nabla_w = [np.zeros(w.shape) for w in self.weights]\n # feedforward\n activation = x\n activations = [x] # list to store all the activations, layer by layer\n zs = [] # list to store all the z vectors, layer by layer\n for b, w in zip(self.biases, self.weights):\n z = np.dot(w, activation) + b\n zs.append(z)\n activation = sigmoid(z)\n activations.append(activation)\n # backward pass\n delta = cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])\n nabla_b[-1] = delta\n nabla_w[-1] = np.dot(delta, np.array(activations[-2]).transpose())\n # Note that the variable l in the loop below is used a little\n # differently to the notation in Chapter 2 of the book. Here,\n # l = 1 means the last layer of neurons, l = 2 is the\n # second-last layer, and so on. It's a renumbering of the\n # scheme in the book, used here to take advantage of the fact\n # that Python can use negative indices in lists.\n for l in xrange(2, self.num_layers):\n z = zs[-l]\n sp = sigmoid_prime(z)\n delta = np.dot(self.weights[-l + 1].transpose(), delta) * sp\n nabla_b[-l] = delta\n nabla_w[-l] = np.dot(delta, np.array(activations[-l - 1]).transpose())\n return (nabla_b, nabla_w)","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 fun(x, *args):\n distance = a.normalized_distance(x.reshape(shape))\n return distance.value, distance.gradient.reshape(-1)","def individual_cost_function(gp, output_trajectory, output_times):\r\n # GET RIGHT PART OF ARRAY\r\n # REFORMAT\r\n # NOISE DATA\r\n # PREDICT NEW VALUES\r\n # GET COST.\r\n X_reshaped = output_times[:,None]\r\n # X_list = GPy_reformat_3D(output_times)\r\n # Y_list = GPy_reformat_3D(output_trajectory)\r\n\r\n # X_list = np.concatenate((X_reshaped,X_reshaped,X_reshaped), axis=1)\r\n X_list = X_reshaped\r\n array1 = output_trajectory.T[:, 0, None]\r\n array2 = output_trajectory.T[:, 1, None]\r\n array3 = output_trajectory.T[:, 2, None]\r\n Y_list = np.concatenate((array1,array2,array3),axis=1)\r\n Y_list = array1\r\n X_list = np.concatenate((X_reshaped,np.zeros_like(X_reshaped)),axis=1)\r\n\r\n\r\n Times_pred_1 = np.concatenate((X_reshaped, np.ones_like(X_reshaped)-1), axis=1)\r\n noise_dict1 = {'output_index': Times_pred_1[:, 1:].astype(int)}\r\n Xpred, Xvar = gp.predict(Times_pred_1,Y_metadata=noise_dict1)\r\n\r\n Times_pred_2 = np.concatenate((X_reshaped, np.ones_like(X_reshaped)), axis=1)\r\n noise_dict2 = {'output_index': Times_pred_2[:, 1:].astype(int)}\r\n Ypred, Yvar = gp.predict(Times_pred_2,Y_metadata=noise_dict2)\r\n\r\n Times_pred_3 = np.concatenate((X_reshaped, np.ones_like(X_reshaped)+1), axis=1)\r\n noise_dict3 = {'output_index': Times_pred_3[:, 1:].astype(int)}\r\n Zpred, Zvar = gp.predict(Times_pred_3,Y_metadata=noise_dict3)\r\n\r\n return gp.log_predictive_density(X_list,Y_list) # ,Y_metadata=noise_dict1) # ARRAY OF ROW INDICES, ARRAY OF COLUMN INDICES, COST\r","def cofiCostFunc(params, Y, R, num_users, num_movies, num_features, lbd):\n X = np.reshape(params[:num_movies*num_features], (num_movies, num_features))\n Theta = np.reshape(params[num_movies*num_features:], (num_users, num_features))\n\n # J=sum((X*Theta'-Y)^2) where R[i,j]==1\n h = X.dot(Theta.T)-Y\n M = h**2\n J = (M*R).sum()/2\n reg = lbd/2*((X**2).sum()+(Theta**2).sum())\n J = J+reg\n\n X_grad = (h*R).dot(Theta)+lbd*X\n Theta_grad = (h*R).T.dot(X)+lbd*Theta\n\n grad = np.r_[X_grad.flatten(), Theta_grad.flatten()]\n return J, grad","def gradient(self, x):\n u = np.asarray([x[0]])\n C = self.C_func(u)\n dC = self.dC_func(u, order=1)\n P = self.P\n numerator = np.sum((C - P) * dC, axis=0)\n denominator = np.sum(np.sum((C - P) ** 2, axis=0) ** (1 / 2))\n if np.abs(denominator) > 0:\n gradient = numerator/denominator\n else:\n gradient = np.asarray(0)[np.newaxis]\n return gradient","def output_error(self, zs, activations, y):\n nabla_b = [np.zeros(b.shape) for b in self.biases]\n nabla_w = [np.zeros(w.shape) for w in self.weights]\n\n delta = self.cost_derivative_for_output(activations[-1], y) * sigmoid_prime(zs[-1])\n nabla_b[-1] = delta\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\n return delta, nabla_b, nabla_w","def get_cost(self) -> numpy.ndarray:\n def product(*args, repeat=1):\n # product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy\n # product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111\n pools = [list(pool) for pool in args] * repeat\n result = [[]]\n for pool in pools:\n result = [x + [y] for x in result for y in pool]\n for prod in result:\n yield list(prod)\n\n # Number of edges\n M = self.num_edges\n # Number of nodes\n N = self.num_nodes\n # Adjacency matrix\n A = networkx.adjacency_matrix(self.graph).todense()\n\n # Generate a list of all possible n‐tuples of elements from {1,-1} and\n # organize them as a (2^n x n) matrix. In other words create all\n # possible solutions to the problem.\n s = numpy.array(list(product([1, -1], repeat=N)))\n\n # Construct the the cost function for Max Cut: C=1/2*Sum(Z_i*Z_j)-M/2\n # Note: This is the minimization version\n return 1 / 2 * (numpy.diag(s@numpy.triu(A)@s.T) - M)","def evaluate(self, X: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:\n\n output = self.fct(X, *self.args)\n\n Y = output[0].reshape(X.shape[0], self.ydim)\n C = (\n output[1].reshape(X.shape[0], self.cdim)\n if self.cdim > 0\n else np.zeros((X.shape[0], self.cdim))\n )\n\n # Build penalty function\n Py = Optimizer.boundaryCheck(Y, self.ylb, self.yub)\n Px = Optimizer.boundaryCheck(X, self.xlb, self.xub)\n Pc = Optimizer.boundaryCheck(C, self.clb, self.cub)\n\n # Assemble all penalties\n P = Py + Px + Pc\n\n # callback:\n if self.callback is not None:\n self.callback(X, Y, C, self.currentIteration)\n\n # Return to optimizer\n return Y, C, P","def gradient_descent(X, Y, iterations, alpha, l = 0):\n \n # initialize B0, B1, ..., Bp\n betas = np.array([0.0]*(len(X[0])+1))\n \n # initialize list of cost vs iterations; should see a gradual descent\n costs = np.array([0.0]*iterations)\n \n # number of observations\n m = len(X)\n \n for i in range(iterations):\n sumterms = 1.0/m * ([estimation(xvec,betas) for xvec in X] - Y)\n errors = np.array([0.0]*len(betas))\n errors[0] = sum(sumterms) # error term for B0 has no multiplier\n for k in range(1,len(betas)):\n errors[k] = np.dot(sumterms, [row[k-1] for row in X]) + l/m*betas[k]\n \n betas = betas - alpha * errors\n costs[i] = cost(X, Y, betas, l)\n \n return betas, costs","def get_params_grad(self, X, output_grad):\n JW = X.T.dot(output_grad)\n Jb = np.sum(output_grad, axis=0)\n return [g for g in itertools.chain(np.nditer(JW), np.nditer(Jb))]","def gradient_of_selection(f_jk,benefit_function,b,c=1,*params):\n f_jk['gos'] = f_jk.A*(b*benefit_function(f_jk.j+1,f_jk.k+1,*params)-c) - f_jk.B*b*benefit_function(f_jk.j,f_jk.k+1,*params)\n gos = f_jk.groupby('n')['gos'].sum() \n gos = gos*(Z-gos.index.values)*gos.index.values/(Z**2)*DELTA\n gos.loc[0]=gos.loc[100]=0\n return gos","def backprop1_7(self, x, y):\r\n \r\n nabla_b = [np.zeros(b.shape) for b in self.biases]\r\n nabla_w = [np.zeros(w.shape) for w in self.weights]\r\n # feedforward\r\n activation = x\r\n activations = [x] # list to store all the activations, layer by layer\r\n zs = [] # list to store all the z vectors, layer by layer\r\n\r\n for b, w in list(zip(self.biases, self.weights))[:len(self.biases)-1]:\r\n z = np.dot(w, activation)+b\r\n zs.append(z)\r\n activation = relu(z)\r\n #print(activation)\r\n activations.append(activation)\r\n\r\n b = self.biases[-1]\r\n w = self.weights[-1]\r\n z = np.dot(w, activation)+b\r\n zs.append(z)\r\n activation = softmax(z)\r\n activations.append(activation)\r\n\r\n # backward pass\r\n delta = self.cost_derivative(activations[-1], y)\r\n\r\n nabla_b[-1] = delta\r\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\r\n # Note about the variable l: Here,\r\n # l = 1 means the last layer of neurons, l = 2 is the\r\n # second-last layer, and so on. This numbering takes advantage of the fact\r\n # that Python can use negative indices in lists.\r\n for l in range(2, self.num_layers):\r\n z = zs[-l]\r\n sp = leakyreluDerivative(z)\r\n delta = np.dot(self.weights[-l+1].transpose(), delta) * sp\r\n nabla_b[-l] = delta\r\n nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())\r\n return (nabla_b, nabla_w)","def cost_function(self, X, y, theta_list, bias):\n total_samples = len(y)\n loss = 0\n\n for i in range(total_samples):\n hypothesis = bias\n hypothesis += np.matmul(X[i], np.array(theta_list).T)\n \n de = 1.0 + np.exp(-hypothesis)\n sigmoidhypothesis = 1.0/de\n\n loss += (y[i]*np.log(sigmoidhypothesis)) + ((1-y[i])*(np.log(1 - sigmoidhypothesis)))\n\n return -1 * (loss/total_samples) #loss calculation","def gradient_descent(initial_theta, X, y, niter, alpha, Lambda=0.0):\n theta_list = []\n cost_list = []\n\n theta = initial_theta\n for i in range(0, niter):\n theta -= alpha*gradient(theta, X, y, Lambda)\n theta_list.append(theta)\n cost_list.append(cost(theta, X, y, Lambda))\n\n return theta_list, cost_list","def grad(self, x):\n beta_flat = x.ravel()\n Ab = np.vstack([Ai.dot(beta_flat) for Ai in self.A]).T\n Ab_norm2 = np.sqrt(np.sum(Ab ** 2.0, axis=1))\n\n upper = Ab_norm2 > utils.TOLERANCE\n grad_Ab_norm2 = Ab\n grad_Ab_norm2[upper] = (Ab[upper].T / Ab_norm2[upper]).T\n\n lower = Ab_norm2 <= utils.TOLERANCE\n n_lower = lower.sum()\n\n if n_lower:\n D = len(self.A)\n vec_rnd = (self.rng(n_lower, D) * 2.0) - 1.0\n norm_vec = np.sqrt(np.sum(vec_rnd ** 2.0, axis=1))\n a = self.rng(n_lower)\n grad_Ab_norm2[lower] = (vec_rnd.T * (a / norm_vec)).T\n\n grad = np.vstack([self.A[i].T.dot(grad_Ab_norm2[:, i])\n for i in xrange(len(self.A))])\n grad = grad.sum(axis=0)\n\n return self.l * grad.reshape(x.shape)","def Gradient(self):\n \n OutList = []\n for dim in range(0,Dimension):\n X = self._CreateSameType()\n \n for Ind in self.IndList():\n \n Factor = -1j * Ind[dim]\n \n X[Ind] = Factor * self[Ind]\n \n OutList.append(X)\n \n return BZO(array(OutList))","def compute_grad(self, w0, w, data_type):\n\t\tdw0 = 0\n\t\tdw = [0]*len(w)\n\t\tnum_data = 0\n\t\tfor x_dict, y in dl.data_gen(self.data_file, \n\t\t\t\t\t\t\t\t\tself.int_minmax, \n\t\t\t\t\t\t\t\t\tself.category_dicts, \n\t\t\t\t\t\t\t\t\tdata_type):\n\t\t\tprob = self.compute_prob(w0, w, x_dict)\n\t\t\tdw0 += -y + prob\n\t\t\tfor loc, x_val in x_dict.items():\n\t\t\t\tdw[loc] += x_val * (-y + prob)\n\t\t\tnum_data += 1\n\t\treturn dw0/num_data, [dwj/num_data for dwj in dw]","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 compute_grad(beta, lambdat, X, y):\n return -2/len(y)*(np.maximum(0, 1-(\n (y[:, np.newaxis]*X).dot(beta)))).dot(\n y[:, np.newaxis]*X) + 2 * lambdat * beta","def UpdateCostMatrix( self, extraXs ):\n for x in extraXs:\n newRow = [ self.EuclideanDistanceSq(x,y) for y in self.Y ]\n self.C.append(newRow)","def gradient(init_par, alpha, delta, obs, sigma_obs, ccoef, N):\n\n\n\t## Initial parameters\n\n\tparallax, v, sigma_v = init_par[:-4], init_par[-4:-1], init_par[-1] \n\tplx_obs, mualpha_obs, mudelta_obs = obs[:, 0], obs[:, 1], obs[:, 2]\n\n\t### Define normal triad and proper motions\n\tp, q, r = normalTriad(alpha, delta)\n\tmualpha_mod = np.dot(np.transpose(p),v)*parallax/_A\n\tmudelta_mod = np.dot(np.transpose(q),v)*parallax/_A\n\t\n\tplx_mod, mualpha_mod, mudelta_mod = parallax, mualpha_mod, mudelta_mod\n\tsigma_plx, sigma_mualpha, sigma_mudelta = np.transpose(sigma_obs)\n\ta,like, expo, detD = np.ones(N),np.ones(N),np.ones(N), np.ones(N) \n\n\t### Eq. 8 in Lindegren+2000 (Covariance Matrix)\n\tC = np.zeros((3,3,N),dtype=np.float64)\n\tC[0,0,:],C[1,1,:],C[2,2,:] = sigma_plx**2.,sigma_mualpha**2., sigma_mudelta**2.\n\tcorr_coefficient_plx_mualpha, corr_coefficient_plx_mudelta, corr_coefficient_mualpha_mudelta = np.zeros(N), np.zeros(N), np.zeros(N)\n\tcorr_coefficient_plx_mualpha[:], corr_coefficient_plx_mudelta[:], corr_coefficient_mualpha_mudelta[:] = ccoef[:, 0], ccoef[:, 1], ccoef[:, 2] \n\t\n\tC[0,1,:], C[0,2,:] = corr_coefficient_plx_mualpha*sigma_plx*sigma_mualpha, corr_coefficient_plx_mudelta*sigma_plx*sigma_mudelta\n\tC[1,0,:], C[1,2,:] = corr_coefficient_plx_mualpha*sigma_plx*sigma_mualpha, corr_coefficient_mualpha_mudelta*sigma_mualpha*sigma_mudelta\n\tC[2,0,:], C[2,1,:] = corr_coefficient_plx_mudelta*sigma_plx*sigma_mudelta, corr_coefficient_mualpha_mudelta*sigma_mualpha*sigma_mudelta\n\n\t### Eq. 16 in Lindegren+2000 (Definition of D matrix)\t\n\tE = np.zeros((3,3,N),dtype=np.float64)\n\tE[1,1,:],E[2,2,:] = (sigma_v*parallax[:]/_A)**2., (sigma_v*parallax[:]/_A)**2.\n\tD,invD = np.zeros((3,3,N),dtype=np.float64),np.zeros((3,3,N),dtype=np.float64)\n\tD = np.add(E,C)\n\tfor i in range(N):\n\t\tdetD[i] = matrix_det(D[:,:,i]) \n\t\tinvD[:,:,i] = matrix_inv(D[:,:,i])\n\t\t\n\t\n\ta_c = np.ones((3,N))\n\ta_c = [plx_obs - plx_mod, mualpha_obs - mualpha_mod, mudelta_obs-mudelta_mod]\n\t\n\t### First derivatives in Eq. A3 \n\tcprime_pi, cprime_vx, cprime_vy, cprime_vz, = np.ones((3,N)), np.ones((3,N)), \\\n\t\t\t\t\t\t\tnp.ones((3,N)), np.ones((3,N)), \n\tcprime_pi[0,:] = 1.\n\tcprime_pi[1,:] = np.dot(np.transpose(p),v)/_A\n\tcprime_pi[2,:] = np.dot(np.transpose(q),v)/_A\n\t\n\tcprime_vx[0,:] = 0.\n\tcprime_vx[1,:] = -np.sin(alpha)*plx_mod/_A \n\tcprime_vx[2,:] = -np.sin(delta)*np.cos(alpha)*plx_mod/_A\n\n\t\n\tcprime_vy[0,:] = 0.\n\tcprime_vy[1,:] = np.cos(alpha)*plx_mod/_A \n\tcprime_vy[2,:] = -np.sin(delta)*np.sin(alpha)*plx_mod/_A\n\n\tcprime_vz[0,:] = 0.\n\tcprime_vz[1,:] = 0. \n\tcprime_vz[2,:] = np.cos(delta)*plx_mod/_A\n\n\tdlnd_dpi, dlnd_dsigmav = np.zeros(N), np.zeros(N)\n\tde_dpi, de_dsigmav = np.zeros(N), np.zeros(N)\n\t\n\n\t### See Eq. A5 \n\tde_dpi[:] = ((sigma_v/_A)**2.)*2.*plx_mod[:]\n\tde_dsigmav[:] = ((plx_mod[:]/_A)**2.)*2.*sigma_v\n\t\n\tdlnd_dpi[:] = (invD[1,1,:] + invD[2,2,:])*de_dpi[:] \n\tdlnd_dsigmav[:] = (invD[1,1,:] + invD[2,2,:])*de_dsigmav[:]\n\t\n\t\n\t\n\t### See Eq. A6\n\tdG_dpi, dG_dsigmav = np.zeros((3,3,N)), np.zeros((3,3,N)) \n\t\n\tdG_dpi[0,0,:], dG_dpi[0,1,:], dG_dpi[0,2,:] = (-invD[0,1,:]*invD[1, 0, :] - invD[0, 2, :]*invD[2,0,:])*de_dpi[:], \\\n\t\t\t\t\t\t (-invD[0,1,:]*invD[1, 1, :] - invD[0,2,:]*invD[2, 1, :])*de_dpi[:], \\\n\t\t\t\t\t\t (-invD[0,1,:]*invD[1,2,:] - invD[0,2,:]*invD[2,2,:])*de_dpi[:]\n\tdG_dpi[1,0,:], dG_dpi[1,1,:], dG_dpi[1,2,:] = (-invD[1,1,:]*invD[1, 0, :] - invD[1, 2, :]*invD[2,0,:])*de_dpi[:], \\\n\t\t\t\t\t\t (-invD[1,1,:]*invD[1, 1, :] - invD[1,2,:]*invD[2, 1, :])*de_dpi[:], \\\n\t\t\t\t\t\t (-invD[1,1,:]*invD[1,2,:] - invD[1,2,:]*invD[2,2,:])*de_dpi[:]\n\tdG_dpi[2,0,:], dG_dpi[2,1,:], dG_dpi[2,2,:] = (-invD[2,1,:]*invD[1, 0, :] - invD[2, 2, :]*invD[2,0,:])*de_dpi[:], \\\n\t\t\t\t\t\t (-invD[2,1,:]*invD[1, 1, :] - invD[2,2,:]*invD[2, 1, :])*de_dpi[:], \\\n\t\t\t\t\t\t (-invD[2,1,:]*invD[1,2,:] - invD[2,2,:]*invD[2,2,:])*de_dpi[:]\n\t\n\n\tdG_dsigmav[0,0,:], dG_dsigmav[0,1,:], dG_dsigmav[0,2,:] = (-invD[0,1,:]*invD[1, 0, :] - invD[0, 2, :]*invD[2,0,:])*de_dsigmav[:], \\\n\t\t\t\t\t\t\t\t (-invD[0,1,:]*invD[1, 1, :] - invD[0,2,:]*invD[2, 1, :])*de_dsigmav[:], \\\n\t\t\t\t\t\t\t\t (-invD[0,1,:]*invD[1,2,:] - invD[0,2,:]*invD[2,2,:])*de_dsigmav[:]\n\tdG_dsigmav[1,0,:], dG_dsigmav[1,1,:], dG_dsigmav[1,2,:] = (-invD[1,1,:]*invD[1, 0, :] - invD[1, 2, :]*invD[2,0,:])*de_dsigmav[:], \\\n\t\t\t\t\t\t\t\t (-invD[1,1,:]*invD[1, 1, :] - invD[1,2,:]*invD[2, 1, :])*de_dsigmav[:], \\\n\t\t\t\t\t\t\t\t (-invD[1,1,:]*invD[1,2,:] - invD[1,2,:]*invD[2,2,:])*de_dsigmav[:]\n\tdG_dsigmav[2,0,:], dG_dsigmav[2,1,:], dG_dsigmav[2,2,:] = (-invD[2,1,:]*invD[1, 0, :] - invD[2, 2, :]*invD[2,0,:])*de_dsigmav[:], \\\n\t\t\t\t\t\t\t\t (-invD[2,1,:]*invD[1, 1, :] - invD[2,2,:]*invD[2, 1, :])*de_dsigmav[:], \\\n\t\t\t\t\t\t\t\t (-invD[2,1,:]*invD[1,2,:] - invD[2,2,:]*invD[2,2,:])*de_dsigmav[:]\n\n\tf_dpi = np.zeros((N), dtype=np.float64) \n\t\n\t\n\tfor i in range(N):\n\t\tf_dpi_1, f_dpi_3 = 0., 0.0 \n\t\tfor ia in range(3):\n\t\t\tfor ib in range(3):\n\t\t\t\tf_dpi_1 += invD[ia,ib,i]*cprime_pi[ia,i]*a_c[ib][i]\n\t\t\t\tf_dpi_3 += (-0.5)*(dG_dpi[ia,ib,i]*a_c[ia][i]*a_c[ib][i])\n\t\t\t\t\t\n\t\tf_dpi_2 = (-0.5)*dlnd_dpi[i]\n\t\tf_dpi[i] = f_dpi_1 + f_dpi_2 + f_dpi_3\n\t\t\n\n\tf_vx, f_vy, f_vz, f_sigmav = np.zeros(N), np.zeros(N), np.zeros(N), np.zeros(N) \n\n\tf_vx = np.sum(invD[0,0,:]*cprime_vx[0,:]*a_c[0][:] + invD[0,1,:]*cprime_vx[0,:]*a_c[1][:] + invD[0,2,:]*cprime_vx[0,:]*a_c[2][:] + \\\n\t\t invD[1,0,:]*cprime_vx[1,:]*a_c[0][:] + invD[1,1,:]*cprime_vx[1,:]*a_c[1][:] + invD[1,2,:]*cprime_vx[1,:]*a_c[2][:] + \\\n\t\t invD[2,0,:]*cprime_vx[2,:]*a_c[0][:] + invD[2,1,:]*cprime_vx[2,:]*a_c[1][:] + invD[2,2,:]*cprime_vx[2,:]*a_c[2][:])\n\t\n\tf_vy = np.sum(invD[0,0,:]*cprime_vy[0,:]*a_c[0][:] + invD[0,1,:]*cprime_vy[0,:]*a_c[1][:] + invD[0,2,:]*cprime_vy[0,:]*a_c[2][:] + \\\n\t\t invD[1,0,:]*cprime_vy[1,:]*a_c[0][:] + invD[1,1,:]*cprime_vy[1,:]*a_c[1][:] + invD[1,2,:]*cprime_vy[1][:]*a_c[2][:] + \\\n\t\t invD[2,0,:]*cprime_vy[2,:]*a_c[0][:] + invD[2,1,:]*cprime_vy[2,:]*a_c[1][:] + invD[2,2,:]*cprime_vy[2,:]*a_c[2][:])\n\n\tf_vz = np.sum(invD[0,0,:]*cprime_vz[0,:]*a_c[0][:] + invD[0,1,:]*cprime_vz[0,:]*a_c[1][:] + invD[0,2,:]*cprime_vz[0,:]*a_c[2][:] + \\\n\t\t invD[1,0,:]*cprime_vz[1,:]*a_c[0][:] + invD[1,1,:]*cprime_vz[1,:]*a_c[1][:] + invD[1,2,:]*cprime_vz[1,:]*a_c[2][:] + \\\n\t\t invD[2,0,:]*cprime_vz[2,:]*a_c[0][:] + invD[2,1,:]*cprime_vz[2,:]*a_c[1][:] + invD[2,2,:]*cprime_vz[2,:]*a_c[2][:])\n\t\n\tf_sigmav = np.sum(-0.5*(dG_dsigmav[0,0,:]*a_c[0][:]*a_c[0][:] + dG_dsigmav[0,1,:]*a_c[1][:]*a_c[0][:]+ dG_dsigmav[0,2,:]*a_c[2][:]*a_c[0][:] + \\\n\t\t dG_dsigmav[1,0,i]*a_c[1][:]*a_c[0][:] + dG_dsigmav[1,1,:]*a_c[1][:]*a_c[1][:]+ dG_dsigmav[1,2,:]*a_c[1][:]*a_c[2][:] + \t\n\t\t dG_dsigmav[2,0,i]*a_c[2][:]*a_c[0][:] + dG_dsigmav[2,1,:]*a_c[2][:]*a_c[1][:]+ dG_dsigmav[2,2,:]*a_c[2][:]*a_c[2][:]))\n\t\n\n\tf_sigmav = f_sigmav - 0.5*np.sum(dlnd_dsigmav)\t\n\tf = np.concatenate((f_dpi, np.array([f_vx, f_vy, f_vz, f_sigmav]))) ### Grad L(theta), see Eq. 17\n\treturn -2.*f \t\t\t\t\t\t ### Grad U(theta), see Eq. 18","def validation_cost(model, X_vala, L_vala, Y_vala):\n vala_costs = []\n for i in range(0,8-1+1):\n X_v, L_v, Y_v = X_vala[i], L_vala[i], Y_vala[i]\n c_v_s = model.get_cost(X_v,L_v,Y_v)\n vala_costs.append(c_v_s)\n return np.mean(vala_costs)","def checkCostFunction(lbd=0):\n # Create small problem\n X_t = np.random.rand(4, 3)\n Theta_t = np.random.rand(5, 3)\n\n # Zap out most entries\n Y = X_t.dot(Theta_t.T)\n Y[np.random.rand(Y.shape[0], Y.shape[1]) > .5] = 0\n R = np.zeros(Y.shape)\n R[Y == 0] = 1\n\n # Run Gradient Checking\n X = np.random.randn(X_t.shape[0], X_t.shape[1])\n Theta = np.random.randn(Theta_t.shape[0], Theta_t.shape[1])\n num_users = Y.shape[1]\n num_movies = Y.shape[0]\n num_features = Theta_t.shape[1]\n\n def Jfunc(t):\n return cofiCostFunc(t, Y, R, num_users, num_movies, num_features, lbd)\n\n numgrad = computeNumericalGradient(Jfunc, np.r_[X.flatten(), Theta.flatten()])\n\n cost, grad = cofiCostFunc(np.r_[X.flatten(), Theta.flatten()], Y, R, num_users, num_movies, num_features, lbd)\n\n print(np.c_[numgrad, grad])\n print('The above two columns you get should be very similar.')\n print('(Left-Your Numerical Gradient, Right-Analytical Gradient)\\n')\n\n diff = np.linalg.norm(numgrad-grad)/np.linalg.norm(numgrad+grad)\n print('If your cost function implementation is correct, then')\n print('the relative difference will be small (less than 1e-9).')\n print('Relative Difference: %g\\n' % diff)","def get_cost_updates(self, corruption_level, learning_rate):\r\n\r\n tilde_x = self.get_corrupted_input(self.x, corruption_level)\r\n y = self.get_hidden_values(tilde_x)\r\n z = self.get_reconstructed_input(y)\r\n # note : we sum over the size of a datapoint; if we are using\r\n # minibatches, L will be a vector, with one entry per\r\n # example in minibatch\r\n L = - T.sum(self.x * T.log(z) + (1 - self.x) * T.log(1 - z), axis=1)\r\n # note : L is now a vector, where each element is the\r\n # cross-entropy cost of the reconstruction of the\r\n # corresponding example of the minibatch. We need to\r\n # compute the average of all these to get the cost of\r\n # the minibatch\r\n cost = T.mean(L)\r\n\r\n # compute the gradients of the cost of the `dA` with respect\r\n # to its parameters\r\n gparams = T.grad(cost, self.params)\r\n # generate the list of updates\r\n updates = []\r\n for param, gparam in zip(self.params, gparams):\r\n updates.append((param, param - learning_rate * gparam))\r\n\r\n return (cost, updates)","def compute_cost(AL, Y, parameters ,lambd):\n L = len(parameters) // 2\n m = Y.shape[1]\n cost = -1 / m * np.sum(np.nan_to_num(Y * np.log(AL) + (1-Y) * np.log(1-AL)))\n cost+= 0.5*(lambd/m)*sum(np.linalg.norm(parameters['W' + str(i)])**2 for i in range(1,L))\n return cost","def ComputeCostMatrix( self, A, B ):\n #return [[EuclideanDistance(a,b) for b in B] for a in A]\n return [[self.EuclideanDistanceSq(a,b) for b in B] for a in A] # skip the sqrt operation until later","def cost_grad_log_reg(w, b, X, y, Multicalss=False):\n if not len(X.shape) == 2:\n X_flattened = X.reshape(X.shape[1] * X.shape[2], -1).T\n else:\n X_flattened = X\n m = X_flattened.shape[1]\n print(m)\n if Multicalss:\n # Multi-class\n\n y_train_reshaped = y.reshape(len(y), 1)\n ohe = OneHotEncoder(categories='auto')\n y_train_reshaped = ohe.fit_transform(y_train_reshaped).toarray()\n print(y_train_reshaped.shape)\n A = softmax(np.dot(X_flattened, w) + b)\n print(A.shape)\n xentropy = -np.sum(y_train_reshaped * np.log(A))\n cost = np.mean(-1 / m * np.sum(y_train_reshaped * np.log(A) + (1 - y_train_reshaped) * np.log(1 - A), axis=1,\n keepdims=True))\n\n dw = 1 / m * np.dot(X_flattened.T, (A - y_train_reshaped))\n db = 1 / m * np.sum(A - y_train_reshaped)\n else:\n # Binary\n A = sigmoid(np.dot(w.T, X_flattened) + b)\n cost = -1 / m * np.sum(y * np.log(A) + (1 - y) * np.log(1 - A), axis=1, keepdims=True)\n\n dw = 1 / m * np.dot(X_flattened, (A - y).T)\n db = 1 / m * np.sum(A - y)\n\n # grads/derivatives\n cost = np.squeeze(cost)\n\n return dw, db, cost","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 costFunction(theta,X,y):\n m = X.shape[0]\n J = 0\n h = sigmoid (np.dot(X,theta))\n \n J = (1/m)* ((-np.dot(y.T,(np.log(h)))) - np.dot((1 - y).T,(np.log(1-h))))\n \n #grad = (1/m) * np.dot(X.T,(h-y))\n grad = (1/m) * np.dot((h.T - y), X).T\n \n return J, grad","def cost_func(plist):\n\t\tgamma, alpha = plist\n\t\tk = ac.Moffat2DKernel(gamma, alpha, x_size=nx, y_size=ny)\n\n\t\tarr_out_predict = ac.convolve(arr_in, k)\n\n\t\tarr_out_fit, arr_out_predict_fit = match_dimension(arr_out, arr_out_predict)\n\t\tdiff = (arr_out_fit - arr_out_predict_fit)*scale_factor\n\n\t\treturn np.sum(diff**2)/diff.size","def b_coefficients(x1,x2,x3,y1,y2,y3,CCoefficients,DCoefficients):\n\tBCoefficients = np.array([\t((y2-y1)/(x2-x1)-CCoefficients[0]*(x2-x1) - DCoefficients[0]*((x2-x1)**2)), \\\n\t\t\t\t\t\t\t\t((y3-y2)/(x3-x2)-CCoefficients[1]*(x3-x2) - DCoefficients[1]*((x3-x2)**2)) \t]).astype(float)\n\treturn(BCoefficients)","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","def getVals(cdli):\n \n \n swh = calcOutProd(np.reshape(cdli.datain_h, (cdli.datain_h.shape[0],1)), np.reshape(cdli.wh, (1, cdli.wh.shape[0])))\n swl = calcOutProd(np.reshape(cdli.datain_l, (cdli.datain_l.shape[0],1)), np.reshape(cdli.wl, (1, cdli.wl.shape[0]))) \n phi_h = [cdli.wh[i]*cdli.wh[i] for i in range(0,len(cdli.wh))] \n phi_l = [cdli.wl[i]*cdli.wl[i] for i in range(0,len(cdli.wl))]\n \n return [[swh, swl], [phi_h, phi_l]]","def _calc_gradients(self, X, y, y_hat):\n # calculate gradient of weight and bias\n grad_b = 2 * np.mean(y_hat - y)\n grad_W = 2 * np.mean(np.matmul((y_hat - y), X))\n return grad_W, grad_b","def compute_gradient(self, grad=None):\n if grad is None:\n grad = backend.ones_like(self.output_value)\n x, y = [node.output_value for node in self.input_nodes]\n grad_wrt_x = grad\n while backend.ndim(grad_wrt_x) > len(backend.shape(x)):\n grad_wrt_x = backend.sum(grad_wrt_x, axis=0)\n for axis, size in enumerate(backend.shape(x)):\n if size == 1:\n grad_wrt_x = backend.sum(grad_wrt_x, axis=axis, keepdims=True)\n\n grad_wrt_y = grad\n while backend.ndim(grad_wrt_y) > len(backend.shape(y)):\n grad_wrt_y = backend.sum(grad_wrt_y, axis=0)\n for axis, size in enumerate(backend.shape(y)):\n if size == 1:\n grad_wrt_y = backend.sum(grad_wrt_y, axis=axis, keepdims=True)\n return [grad_wrt_x, grad_wrt_y]","def backprop(self, x, y):\n nabla_b = [np.zeros(b.shape) for b in self.biases]\n nabla_w = [np.zeros(w.shape) for w in self.weights]\n\n # feedforward\n activation = x\n\n # list to store all the activations, layer by layer\n activations = [x]\n\n # list to store all the z vectors, layer by layer\n zs = []\n for activ_func, b, w in zip(self._activation_funcs, self.biases, self.weights):\n z = np.dot(w, activation) + b\n zs.append(z)\n activation = activ_func.fn(z)\n activations.append(activation)\n\n # backward pass\n delta = self.cost.delta(zs[-1], activations[-1], y)\n\n nabla_b[-1] = delta\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\n\n # Note that the variable l in the loop below is used a little\n # differently to the notation in Chapter 2 of the book. Here,\n # l = 1 means the last layer of neurons, l = 2 is the\n # second-last layer, and so on. It's a renumbering of the\n # scheme in the book, used here to take advantage of the fact\n # that Python can use negative indices in lists.\n for l in xrange(2, self.num_layers):\n z = zs[-l]\n activ_func = self._activation_funcs[-l]\n sp = activ_func.fprime(z)\n delta = np.dot(self.weights[-l+1].transpose(), delta) * sp\n nabla_b[-l] = delta\n nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())\n return (nabla_b, nabla_w)","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 \r\n h = numpy.dot(features, theta)\r\n \r\n theta = theta - alpha / m * numpy.dot((h-values),features)\r\n \r\n cost = compute_cost(features, values, theta)\r\n \r\n cost_history.append(cost)\r\n\r\n return theta, pandas.Series(cost_history) # leave this line for the grader\r","def backprop(self, x, y):\r\n #print(np.shape(x))\r\n nabla_b = [np.zeros(b.shape) for b in self.biases]\r\n nabla_w = [np.zeros(w.shape) for w in self.weights]\r\n # feedforward\r\n activation = x\r\n activations = [x] # list to store all the activations, layer by layer\r\n zs = [] # list to store all the z vectors, layer by layer\r\n #print(\"en\")\r\n for b, w in zip(self.biases, self.weights):\r\n z = np.dot(w, activation)+b\r\n zs.append(z)\r\n activation = sigmoid(z)\r\n activations.append(activation)\r\n\r\n # backward pass\r\n delta = self.cost_derivative(activations[-1], y) * \\\r\n sigmoid_prime(zs[-1])\r\n nabla_b[-1] = delta\r\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\r\n # Note about the variable l: Here,\r\n # l = 1 means the last layer of neurons, l = 2 is the\r\n # second-last layer, and so on. This numbering takes advantage of the fact\r\n # that Python can use negative indices in lists.\r\n for l in range(2, self.num_layers):\r\n z = zs[-l]\r\n sp = sigmoid_prime(z)\r\n delta = np.dot(self.weights[-l+1].transpose(), delta) * sp\r\n nabla_b[-l] = delta\r\n nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())\r\n #print('2')\r\n #print(nabla_w[-l])\r\n return (nabla_b, nabla_w)","def gradFun(self, x):\n tmp = x.reshape(self.inp_shape)\n g = np.ravel(np.asarray(self.calcGrad(np.asarray(tmp,dtype=np.float32)),dtype=np.float64)) + 2*self.alpha*x\n return g","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 gradient_descent_for_n_layers(num_layers, W, B, X, Y, alpha, num_iterations):\n Z = [None] * (num_layers + 1)\n A = [None] * (num_layers + 1)\n dA = [None] * (num_layers + 1)\n dW = [None] * (num_layers + 1)\n dB = [None] * (num_layers + 1)\n for _ in range(0, num_iterations):\n\n A[0] = np.array(X, copy=True)\n for j in range(1, num_layers + 1):\n Z[j], A[j] = forward_propagation(A[j - 1], W[j], B[j])\n\n yhat = A[num_layers]\n dA[num_layers] = loss(yhat, Y)\n cost_value = cost(dA[num_layers])\n print(\"cost\", cost_value)\n\n for j in reversed(range(1, num_layers + 1)):\n dA[j-1], dW[j], dB[j] = both_relu_and_linear_transform_and_chain_rule(\n dA[j], Z[j], A[j-1], W[j])\n W[j] = W[j] - (alpha * dW[j])\n B[j] = B[j] - (alpha * dB[j])\n\n return W, B, yhat","def get_cost_updates(self, corruption_rate=0.3, learning_rate=0.1):\n tilde_x = self.get_corrupted_input(self.x, corruption_rate)\n y = self.get_hidden_values(tilde_x)\n z = self.get_reconstructed_input(y)\n l = cross_entropy(self.x, z)\n cost = T.mean(l)\n grads = T.grad(cost, self.params)\n updates = [\n (param, param - learning_rate * grad) for param, grad in zip(self.params, grads)\n ]\n return cost, updates","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 compute_gradient(self, grad=None):\n x, y = [node.output_value for node in self.input_nodes]\n\n if grad is None:\n grad = backend.ones_like(self.output_value)\n grad_wrt_x = grad * y\n while backend.ndim(grad_wrt_x) > len(backend.shape(x)):\n grad_wrt_x = backend.sum(grad_wrt_x, axis=0)\n for axis, size in enumerate(backend.shape(x)):\n if size == 1:\n grad_wrt_x = backend.sum(grad_wrt_x, axis=axis, keepdims=True)\n\n grad_wrt_y = grad * x\n while backend.ndim(grad_wrt_y) > len(backend.shape(y)):\n grad_wrt_y = backend.sum(grad_wrt_y, axis=0)\n for axis, size in enumerate(backend.shape(y)):\n if size == 1:\n grad_wrt_y = backend.sum(grad_wrt_y, axis=axis, keepdims=True)\n\n return [grad_wrt_x, grad_wrt_y]","def compute_gradient(X, t, w): # TODO: try to change to square loss since it's hessian is easier to obtain\n # TODO : print to console the max gradient in every run\n A = np.dot(X, w)\n m = t.shape[0]\n C = -1 * t * (1 / (1 + np.exp(A * t)))\n return (1 / m) * np.dot(X.T, C)","def ANN_functional_shape(x_data):\n\tx_data_Li_Lj= ANN_discriminants(x_data)\n\tx_data_Li = np.reshape(x_data[:,:20].flatten(),(-1,5,4,1))\n\treturn [x_data_Li, x_data_Li_Lj]","def _compute_gradient_list(x,\n x_shape,\n y,\n y_shape,\n x_init_value=None,\n delta=1e-3,\n init_targets=None,\n extra_feed_dict=None):\n assert isinstance(x, list)\n dx, dy = zip(*[_compute_dx_and_dy(xi, y, y_shape) for xi in x])\n\n if init_targets is not None:\n assert isinstance(init_targets, (list, tuple))\n for init in init_targets:\n init.run()\n if x_init_value is None:\n x_init_value = [None] * len(x)\n ret = [_compute_gradient(xi, x_shapei, dxi, y, y_shape, dyi, x_init_valuei,\n delta, extra_feed_dict=extra_feed_dict)\n for xi, x_shapei, dxi, dyi, x_init_valuei in zip(x, x_shape, dx, dy,\n x_init_value)]\n return ret","def deriv_costFunction(self, x, y):\n self.yEst = self.forward_propagate(x)\n\n delta_o = np.multiply( ( self.yEst - y ), self.deriv_sigmoid(self.z_o) )\n #partial deriv of cost wrt hidden -> output weights\n partial_J_w_ho = np.dot( self.a_h.T, delta_o )\n\n ones_o = np.ones( delta_o.shape[0] )\n #partial deriv of cost wrt output biases\n partial_J_b_o = np.dot( ones_o, delta_o )\n\n delta_h = np.dot( delta_o, self.w_ho.T ) * self.deriv_sigmoid( self.z_h )\n #partial deriv of cost wrt input -> hidden weights\n partial_J_w_ih = np.dot( x.T, delta_h )\n \n ones_h = np.ones( delta_h.shape[0] )\n #partial deriv of cost wrt hidden biases\n partial_J_b_h = np.dot( ones_h, delta_h)\n\n return partial_J_w_ih, partial_J_w_ho, partial_J_b_h, partial_J_b_o","def getGradients(T,x,y):\n\n # These are place holders, you will overwrite them in your code.\n dummy = torch.zeros(3,4)\n Tx = dummy\n Ty = dummy\n\n # TODO: your code here to compute Tx, Ty\n \n return Tx, Ty","def compute_grad(W, x, y, loss_c, config):\n\n # Lazy import of propper model\n if config.model_type == \"linear_svm\":\n from utils.linear_svm import model_grad\n elif config.model_type == \"logistic_regression\":\n from utils.logistic_regression import model_grad\n else:\n raise ValueError(\"Wrong model type {}\".format(\n config.model_type))\n\n dW, db = model_grad(loss_c, x, y)\n dW += config.reg_lambda * l2_grad(W)\n\n return dW, db","def compute_gradient(self, function, arguments):","def compute_cost(n: int,\n lam: float,\n dE: float,\n L: int,\n Lxi: int,\n chi: int,\n beta: int,\n stps: int,\n verbose: bool = False) -> Tuple[int, int, int]:\n\n # The number of bits used for the second register.\n nxi = np.ceil(np.log2(n // 2))\n\n # The number of bits for the contiguous register.\n nLxi = np.ceil(np.log2(Lxi + n // 2))\n\n # The number of bits used for the first register.\n nL = np.ceil(np.log2(L + 1))\n\n # The power of 2 that is a factor of L + 1\n eta = power_two(L + 1)\n\n oh = [0] * 20\n for p in range(20):\n # JJG note: arccos arg may be > 1\n v = np.round(np.power(2,p+1) / (2 * np.pi) * arccos(np.power(2,nL) /\\\n np.sqrt((L + 1)/2**eta)/2))\n oh[p] = np.real(stps * (1 / (np.sin(3 * arcsin(np.cos(v * 2 * np.pi / \\\n np.power(2,p+1)) * \\\n np.sqrt((L + 1)/2**eta) / np.power(2,nL)))**2) - 1) + 4 * (p + 1))\n\n # Bits of precision for rotation\n br = int(np.argmin(oh) + 1)\n\n # The following costs are from the list starting on page 50.\n\n # The cost for preparing an equal superposition for preparing the first\n # register in step 1 (a). We double this cost to account for the inverse.\n cost1a = 2 * (3 * nL + 2 * br - 3 * eta - 9)\n\n # The output size for the QROM for the first state preparation in Eq. (C27)\n bp1 = nL + chi\n\n # The cost of the QROM for the first state preparation in step 1 (b) and\n # its inverse.\n cost1b = QR(L + 1, bp1)[1] + QI(L + 1)[1]\n\n # The cost for the inequality test, controlled swap and their inverse in\n # steps 1 (c) and (d)\n cost1cd = 2 * (chi + nL)\n\n # The total cost for preparing the first register in step 1.\n cost1 = cost1a + cost1b + cost1cd\n\n # The output size for the QROM for the data to prepare the equal\n # superposition on the second register, as given in Eq. (C29).\n bo = nxi + nLxi + br + 1\n\n # This is step 2. This is the cost of outputting the data to prepare the\n # equal superposition on the second register. We will assume it is not\n # uncomputed, because we want to keep the offset for applying the QROM for\n # outputting the rotations.\n cost2 = QR(L + 1, bo)[1] + QI(L + 1)[1]\n\n # The number of bits for rotating the ancilla for the second preparation.\n # We are just entering this manually because it is a typical value.\n br = 7\n\n # The cost of preparing an equal superposition over the second register in\n # a controlled way. We pay this cost 4 times.\n cost3a = 4 * (7 * nxi + 2 * br - 6)\n\n # The cost of the offset to apply the QROM for state preparation on the\n # second register.\n cost3b = 4 * (nLxi - 1)\n\n bp2 = nxi + chi + 2\n\n # The cost of the QROMs and inverse QROMs for the state preparation, where\n # in the first one we need + n/2 to account for the one-electron terms.\n cost3c = QR(Lxi + n // 2, bp2)[1] + QI(Lxi + n // 2)[1] + QR(\n Lxi, bp2)[1] + QI(Lxi)[1]\n\n # The inequality test and state preparations.\n cost3d = 4 * (nxi + chi)\n\n # The total costs for state preparations on register 2.\n cost3 = cost3a + cost3b + cost3c + cost3d\n\n # The cost of adding offsets in steps 4 (a) and (h).\n cost4ah = 4 * (nLxi - 1)\n\n # The costs of the QROMs and their inverses in steps 4 (b) and (g).\n cost4bg = QR(Lxi + n // 2, n * beta // 2)[1] + QI(Lxi + n // 2)[1] + QR(\n Lxi, n * beta // 2)[1] + QI(Lxi)[1]\n\n # The cost of the controlled swaps based on the spin qubit in steps 4c and f\n cost4cf = 2 * n\n\n # The controlled rotations in steps 4 (d) and (f).\n cost4df = 4 * n * (beta - 2)\n\n # The controlled Z operations in the middle for step 4 (e).\n cost4e = 3\n\n # This is the cost of the controlled rotations for step 4.\n cost4 = cost4ah + cost4bg + cost4cf + cost4df + cost4e\n\n # This is the cost of the reflection on the second register from step 6.\n cost6 = nxi + chi + 2\n\n # The cost of the final reflection req'd to construct the step of the\n # quantum walk from step 9.\n cost9 = nL + nxi + chi + 1\n\n # The extra two qubits for unary iteration and making the rflxn controlled.\n cost10 = 2\n\n # The Toffoli cost for a single step\n cost = cost1 + cost2 + cost3 + cost4 + cost6 + cost9 + cost10\n\n # The number of steps needed\n iters = np.ceil(np.pi * lam / (2 * dE))\n\n # Now the number of qubits from the list on page 54.\n\n k1 = np.power(2, QR(Lxi + n // 2, n * beta // 2)[0])\n\n # The control register for phase estimation and iteration on it.\n ac1 = np.ceil(np.log2(iters + 1)) * 2 - 1\n\n # The system qubits\n ac2 = n\n\n # The first register prepared, a rotated qubit and a flag qubit.\n ac3 = nL + 2\n\n # The output of the QROM, the equal superposition state and a flag qubit.\n ac4 = nL + chi * 2 + 1\n\n # The data used for preparing the equal superposition state on the 2nd reg\n ac5 = bo\n\n # The second register, a rotated qubit and a flag qubit.\n ac6 = nxi + 2\n\n # The second preparation QROM output.\n ac8 = bp2\n\n # The equal superposition state and the result of the inequality test.\n ac9 = chi + 1\n\n # The angles for rotations.\n ac10 = k1 * n * beta // 2\n\n # The phase gradient state.\n ac11 = beta\n\n # A control qubit for the spin.\n ac12 = 1\n\n # A T state.\n ac13 = 1\n\n if verbose:\n print(\"[*] Top of routine\")\n print(\" [+] nxi = \", nxi)\n print(\" [+] nLxi = \", nLxi)\n print(\" [+] nL = \", nL)\n print(\" [+] eta = \", eta)\n print(\" [+] cost3 = \", cost3)\n print(\" [+] cost4 = \", cost4)\n print(\" [+] cost = \", cost)\n print(\" [+] iters = \", iters)\n\n ancilla_cost = ac1 + ac2 + ac3 + ac4 + ac5 + ac6 + ac8 + ac9 + ac10 + ac11\\\n + ac12 + ac13\n\n # Sanity checks before returning as int\n assert cost.is_integer()\n assert iters.is_integer()\n assert ancilla_cost.is_integer()\n\n step_cost = int(cost)\n total_cost = int(cost * iters)\n ancilla_cost = int(ancilla_cost)\n\n return step_cost, total_cost, ancilla_cost","def costFunction(theta, X, y):\n\n # Initialize some useful values\n m = y.size # number of training examples\n J = np.sum(np.array([inner(theta, xi, yi) for xi, yi in zip(X, y)]))\n J /= m\n\n\n return J","def backprop(self, x, y):\n\n ### YOUR CODE HERE\n nabla_output = np.zeros(self.params['nh'])\n del1 = self.aout - y\n nabla_output = del1 * self.ahidden\n #print (nabla_output)\n a1 = del1 * self.w_output\n a2 = np.multiply(self.ahidden, (1-self.ahidden))\n del2 = np.zeros(self.params['nh'])\n for i in range(0, self.params['nh']):\n del2[i] = self.w_output[i]* del1 * self.ahidden[i]*(1-self.ahidden[i])\n # del2 = np.multiply(a1,a2)\n # nabla_input = np.multiply(del2, x)\n nabla_input = np.zeros([x.shape[0],self.params['nh']])\n for i in range (0, x.shape[0]):\n for j in range(0, self.params['nh']):\n nabla_input[i][j] = x[i]*del2[j]\n #nabla_input = np.dot(x, np.transpose(del2))\n ### END YOUR CODE\n\n assert nabla_input.shape == self.w_input.shape\n assert nabla_output.shape == self.w_output.shape\n return (nabla_input, nabla_output)","def gradient_calculation(self, coefficients, x_values, y_values):\n gradient_coeffs = np.array([0]*len(coefficients))\n\n for xi in range(len(x_values)):\n x = x_values[xi]\n power_array = np.power(\n np.array([x]*len(coefficients)), np.array(range(len(coefficients))))\n\n diff = (2/len(x_values))*(self.f(x, coefficients) - y_values[xi])\n gradient_coeffs = gradient_coeffs + np.multiply(diff, power_array)\n\n return gradient_coeffs","def compute_gradients(self, logits, target):\n\n target_length = target.shape[0]\n num_time_steps = logits.shape[0]\n\n\t\t######################\n\t\t### YOUR CODE HERE ###\n\t\t######################\n\n # expand labels by inserting a blank between each pair\n normalized_logits = softmax(logits)\n blank_label = normalized_logits.shape[1] - 1\n l = add_blanks(target, blank_label)\n target_length = l.shape[0]\n\n alpha = self.compute_forward_variables(normalized_logits, target) \n beta = self.compute_backward_variables(normalized_logits, target)\n\n # rescale\n alpha = alpha / np.sum(alpha, axis=0)\n beta = beta / np.sum(beta, axis=0)\n alphabeta = alpha * beta\n print \"alpha\"\n print alpha\n\n # compute zt\n z = Counter()\n for t in xrange(num_time_steps):\n for s, k in enumerate(l):\n z[t] += alphabeta[s, t] / normalized_logits[t, k]\n \n # normalized_logits is time steps t by labels k\n # alpha is 2 * target_length - 1 by time steps\n lab_zk = np.zeros_like(normalized_logits)\n for s, k in enumerate(l):\n for t in xrange(num_time_steps):\n lab_zk[t, k] += alphabeta[s, t]\n\n grad = normalized_logits\n for k in xrange(target.shape[0]):\n for t in xrange(num_time_steps):\n ytk = normalized_logits[t, k]\n constant = 1.0 / (ytk * z[t])\n grad[t, k] = ytk - constant * lab_zk[t, k]\n \n return grad","def activate(self, inputs: Tuple[float, ...]) -> Tuple[float, ...]:\n self.z = [Math.dot(self.w[i], inputs) + self.b[i]\n for i in range(len(self.w))]\n self.a = [self.g(real) for real in self.z]\n return tuple(self.a)","def propagate(w, b, X, Y):\n\n m = X.shape[1];\n\n # A.shape should be (1, m), m -- number of training examples\n A = sigmoid(np.dot(w.T, X) + b);\n # print(\"A = \" +str(A))\n\n # single training exmaple cost = - (y * log(A) + (1-y) * log(1-A))\n # cost = (-1/m) * (np.dot(Y, np.log(A).T) + np.dot((1-Y), np.log(1-A).T));\n cost = (-1/m)*(np.dot(Y, np.log(A).T) + np.dot((1-Y), np.log(1-A).T));\n # print(\"cost in function: \" +str(cost))\n\n # Backward propagation \n dw = (1/m) * np.dot(X, (A - Y).T)\n # np.sum() : axis = 0 means along the column and axis = 1 means working along the row.\n db = (1/m) * ((A - Y).sum(1))\n\n # dw.shape should be (num_px * nump_px * 3, 1), db should be a scalar\n assert(dw.shape == w.shape)\n assert(db.dtype == float)\n\n # np.squeeze(arr) -- remove one dimentional entry from the shape of given array. \n # -- arr: input array\n cost = np.squeeze(cost)\n assert(cost.shape == ())\n \n grads = {\"dw\": dw, \"db\": db}\n \n return grads, cost","def compute_cost(Y, Y_hat):\n m = Y.shape[1]\n\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\n\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\n\n return cost, dY_hat","def compute_cost(Y, Y_hat):\n m = Y.shape[1]\n\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\n\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\n\n return cost, dY_hat","def get_gradient(self, output_name=None):\n \n return array([self.gradient[wrt][output_name] for wrt in self.param_names])","def ComputeGradsNumSlow(X, Y, P, W, b, lamda, h):\n\tno \t= \tW.shape[0]\n\td \t= \tX.shape[0]\n\n\tgrad_W = np.zeros(W.shape);\n\tgrad_b = np.zeros((no, 1));\n\t\n\tfor i in range(len(b)):\n\t\tb_try = b\n\t\tb_try[i] -= h\n\t\tc1 = ComputeCost(X, Y, W, b_try, lamda)\n\n\t\tb_try = b\n\t\tb_try[i] += h\n\t\tc2 = ComputeCost(X, Y, W, b_try, lamda)\n\n\t\tgrad_b[i] = (c2-c1) / (2*h)\n\n\tfor i in range(W.shape[0]):\n\t\tfor j in range(W.shape[1]):\n\t\t\tW_try = W\n\t\t\tW_try[i,j] -= h\n\t\t\tc1 = ComputeCost(X, Y, W_try, b, lamda)\n\n\t\t\tW_try = W\n\t\t\tW_try[i,j] += h\n\t\t\tc2 = ComputeCost(X, Y, W_try, b, lamda)\n\n\t\t\tgrad_W[i,j] = (c2-c1) / (2*h)\n\n\treturn [grad_W, grad_b]","def grad(self, inputs, cost_grad):\r\n a = inputs[0]\r\n n = inputs[1]\r\n axis = inputs[2]\r\n grad = cost_grad[0]\r\n if not isinstance(axis, tensor.TensorConstant):\r\n raise NotImplementedError('%s: gradient is currently implemented'\r\n ' only for axis being a Theano constant'\r\n % self.__class__.__name__)\r\n axis = int(axis.data)\r\n # notice that the number of actual elements in wrto is independent of\r\n # possible padding or truncation:\r\n elem = tensor.arange(0, tensor.shape(a)[axis], 1)\r\n # accounts for padding:\r\n freq = tensor.arange(0, n, 1)\r\n outer = tensor.outer(freq, elem)\r\n pow_outer = tensor.exp(((-2 * math.pi * 1j) * outer) / (1. * n))\r\n res = tensor.tensordot(grad, pow_outer, (axis, 0))\r\n\r\n # This would be simpler but not implemented by theano:\r\n # res = tensor.switch(tensor.lt(n, tensor.shape(a)[axis]),\r\n # tensor.set_subtensor(res[...,n::], 0, False, False), res)\r\n\r\n # Instead we resort to that to account for truncation:\r\n flip_shape = list(numpy.arange(0, a.ndim)[::-1])\r\n res = res.dimshuffle(flip_shape)\r\n res = tensor.switch(tensor.lt(n, tensor.shape(a)[axis]),\r\n tensor.set_subtensor(res[n::, ], 0, False, False), res)\r\n res = res.dimshuffle(flip_shape)\r\n\r\n # insures that gradient shape conforms to input shape:\r\n out_shape = list(numpy.arange(0, axis)) + [a.ndim - 1] +\\\r\n list(numpy.arange(axis, a.ndim - 1))\r\n res = res.dimshuffle(*out_shape)\r\n return [res, None, None]","def objective_grad(self, wb, X, y):\n N, D = X.shape\n w = wb[:-1]\n b = wb[-1]\n loss_grad = np.zeros(D+1) \n # grad wrt regularization\n loss_grad[-1] = 2 * self.reg_param * (b - self.b0) # grad_b\n loss_grad[:-1] = 2 * self.reg_param * (w - self.w0) # grad_w\n\n for i in range(N):\n tmpvar = np.exp(-1 * y[i] * (np.dot(w, X[i]) + b)) \n loss_grad[-1] += tmpvar/(1 + tmpvar) * -1 * y[i] # grad_b \n loss_grad[:-1] += tmpvar/(1 + tmpvar) * -1 * y[i] * X[i] # grad_w\n\n return loss_grad","def compute_cost(features, values, theta):\r\n \r\n # your code here\r\n error = (values - features.dot(theta))\r\n cost = error.dot(error) \r\n return cost","def compute_gradient(self): # TODO: try to change to square loss since it's hessian is easier to obtain\n A = np.dot(self.X, self.w)\n m = self.t.shape[0]\n C = -1 * self.t * (1 / (1 + np.exp(A * self.t)))\n return (1 / m) * np.dot(self.X.T, C)","def get_cost(self, logits_list):\n\n cost_list = []\n\n for dn, logits in zip(self.find_targetnodes(), logits_list):\n\n if len(dn.receives_from) == 0: continue\n _, y_ = dn.get_tensors()\n cost_list.append(self.cost_function(y_, logits))\n\n return cost_list","def calc_gradient(self, W, X, y, reg):\n\n N = X.shape[0]\n grad_W = np.zeros_like(W)\n I = np.ones((1,10))\n score = np.dot(X, W) # (N, C)\n out = np.exp(score-np.dot(np.max(score, axis=1, keepdims=True ),I))\n #print(\"out\", out)\n out /= np.sum(out, axis=1, keepdims=True) # (N, C)\n \n dout = np.copy(out) # (N, C)\n dout[np.arange(N), y] -= 1\n grad_W = np.dot(X.T, dout) # (D, C)\n grad_W /= N\n #grad_W += reg * W\n \n return grad_W","def compute_cost(features, values, theta):\r\n m = len(values)\r\n sum_of_square_errors = numpy.square(numpy.dot(features, theta) - values).sum()\r\n cost = sum_of_square_errors / (2*m)\r\n\r\n return cost","def grad(self, inputs, g_outputs):\r\n x, = inputs\r\n xi = self(x)\r\n gz, = g_outputs\r\n #TT.dot(gz.T,xi)\r\n return [-matrix_dot(xi, gz.T, xi).T]","def jacobian(self, x):\n x_ = np.atleast_2d(x)\n if self.normalize:\n x_ = (x_ - self.sample_mean) / self.sample_std\n s_ = (self.samples - self.sample_mean) / self.sample_std\n else:\n s_ = self.samples\n\n fx, jf = self.reg_model(x_)\n rx, drdx = self.corr_model(x=x_, s=s_, params=self.corr_model_params, dx=True)\n y_grad = np.einsum('ikj,jm->ik', jf, self.beta) + np.einsum('ijk,jm->ki', drdx.T, self.gamma)\n if self.normalize:\n y_grad = y_grad * self.value_std / self.sample_std\n if x_.shape[1] == 1:\n y_grad = y_grad.flatten()\n return y_grad","def backprop1_5(self, x, y):\r\n \r\n nabla_b = [np.zeros(b.shape) for b in self.biases]\r\n nabla_w = [np.zeros(w.shape) for w in self.weights]\r\n # feedforward\r\n activation = x\r\n activations = [x] # list to store all the activations, layer by layer\r\n zs = [] # list to store all the z vectors, layer by layer\r\n for b, w in list(zip(self.biases, self.weights))[:len(self.biases)-1]:\r\n z = np.dot(w, activation)+b\r\n zs.append(z)\r\n activation = sigmoid(z)\r\n activations.append(activation)\r\n\r\n b = self.biases[-1]\r\n w = self.weights[-1]\r\n z = np.dot(w, activation)+b\r\n zs.append(z)\r\n activation = softmax(z)\r\n activations.append(activation)\r\n\r\n # backward pass\r\n delta = self.cost_derivative(activations[-1], y)\r\n\r\n nabla_b[-1] = delta\r\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\r\n # Note about the variable l: Here,\r\n # l = 1 means the last layer of neurons, l = 2 is the\r\n # second-last layer, and so on. This numbering takes advantage of the fact\r\n # that Python can use negative indices in lists.\r\n for l in range(2, self.num_layers):\r\n z = zs[-l]\r\n sp = sigmoid_prime(z)\r\n delta = np.dot(self.weights[-l+1].transpose(), delta) * sp\r\n nabla_b[-l] = delta\r\n nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())\r\n return (nabla_b, nabla_w)","def _ci_grads(preds, dtrain):\n # predictions: np.array with shape of (n, )\n n = preds.shape[0]\n y_hat = preds\n\n # labels: np.array with shape of (n, )\n labels = dtrain.get_label().astype('int')\n E = (labels > 0).astype('int')\n T = np.abs(labels)\n\n # L2 Gradient Computation (Concordance Index Approximation)\n # gradients computation of numerator and denominator in L2\n # initialization\n num, den = .0, .0\n grad_den = np.zeros_like(y_hat)\n hess_den = np.zeros_like(y_hat) # 0\n grad_num = np.zeros_like(y_hat)\n hess_num = np.zeros_like(y_hat)\n\n # firstly, compute gradients of numerator(\\alpha) and denominator(\\beta) in L2\n for k in np.arange(n):\n ## gradients of denominator (\\beta)\n # For set s1 (i.e. \\omega 1 in the paper)\n # s1 = (k, i): E_k = 1 and T_k < T_i\n s1 = E[k] * np.sum(T > T[k])\n # For set s2 (i.e. \\omega 2 in the paper)\n # s2 = (i, k): E_i = 1 and T_i < T_k\n s2 = np.sum((E > 0) * (T < T[k]))\n # For grad_den (i.e. the first-order gradient of denominator)\n grad_den[k] = s2 - s1\n # hess_den[k] = 0\n\n ## gradients of numerator (\\alpha)\n\n # set S1\n # i.e. the first-order and second-order gradients related to set s1\n # s1 = (k, i): E_k = 1 and T_k < T_i\n g_s1, h_s1 = .0, .0\n if E[k] == 1:\n w = y_hat[k] - y_hat[T[k] < T]\n # For den and num\n den += np.sum(-w)\n num += np.sum((w < _GAMMA) * (-w) * (_GAMMA - w)**2)\n\n g_s1 = np.sum((w < _GAMMA) * (_GAMMA - w) * (3*w - _GAMMA))\n\n h_s1 = np.sum((w < _GAMMA) * (4*_GAMMA - 6*w))\n \n # set S2\n # i.e. the first-order and second-order gradients related to set s2\n w = y_hat[(E > 0) * (T < T[k])] - y_hat[k]\n g_s2 = np.sum((w < _GAMMA) * (_GAMMA - w) * (_GAMMA - 3*w))\n h_s2 = np.sum((w < _GAMMA) * (4*_GAMMA - 6*w))\n \n grad_num[k] = g_s2 + g_s1\n hess_num[k] = h_s2 + h_s1\n\n if den == 0:\n grad_f = np.zeros_like(y_hat)\n hess_f = np.zeros_like(y_hat)\n else:\n grad_f = grad_num / den - num * grad_den / (den ** 2)\n hess_f = (den * hess_num - num * hess_den) / (den ** 2) - 2 * grad_den / den * grad_f\n \n return grad_f, hess_f","def blrObjFunction(params, *args):\r\n train_data, labeli = args\r\n \r\n n_data = train_data.shape[0];\r\n n_feature = train_data.shape[1];\r\n error = 0;\r\n error_grad = np.zeros((n_feature+1,1));\r\n \r\n ##################\r\n # YOUR CODE HERE #\r\n ##################\r\n \r\n # Step-1: Compute yn\r\n w = params.reshape((n_feature+1, 1))\r\n wt = w.transpose();\r\n xn = train_data;\r\n xn_with_bias = np.array([])\r\n xn_with_bias_list = [] \r\n for x in range (0, n_data):\r\n xn_with_bias_list.append(np.append ([1], xn[x]))\r\n xn_with_bias = np.vstack(xn_with_bias_list)\r\n yn = sigmoid(np.dot (xn_with_bias, w));\r\n \r\n # Step-2: Compute Error\r\n tn = labeli;\r\n sum1 = tn * np.log (yn);\r\n sum2 = (1-tn) * np.log ((1- yn));\r\n errorr = 0\r\n for i in range (0, n_data):\r\n errorr = errorr + sum1[i] + sum2[i];\r\n errorr = -1 * errorr;\r\n error = errorr[0] \r\n \r\n # Step-3: Compute Error gradient\r\n yn_minus_tn = yn - tn;\r\n xn_with_bias\r\n error_grad = np.dot(xn_with_bias.transpose(), yn_minus_tn);\r\n error_grad = np.squeeze(np.asarray(error_grad));\r\n print (error)\r\n return error, error_grad","def get_gradient(self, batch_y, batch_x, weight):\n N = batch_y.shape[0]\n grad = np.empty(len(weight))\n for index in range(N):\n _y = batch_y[index]\n _x = batch_x[index]\n grad = grad + gradient_least_square(_y, _x, weight, self.loss_function_name)\n grad /= N\n grad += self.regularizer.get_gradient(weight)\n return grad","def backprop(self, x, y):\n nabla_b = [np.zeros(b.shape) for b in self.biases]\n nabla_w = [np.zeros(w.shape) for w in self.weights]\n # feedforward\n activation = x\n activations = [x] # list to store all the activations, layer by layer\n zs = [] # list to store all the z vectors, layer by layer\n for b, w in zip(self.biases, self.weights):\n z = np.dot(w, activation)+b\n zs.append(z)\n activation = sigmoid(z)\n activations.append(activation)\n # backward pass\n delta = (self.cost).delta(zs[-1], activations[-1], y)\n nabla_b[-1] = delta\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\n # Note that the variable l in the loop below is used a little\n # differently to the notation in Chapter 2 of the book. Here,\n # l = 1 means the last layer of neurons, l = 2 is the\n # second-last layer, and so on. It's a renumbering of the\n # scheme in the book, used here to take advantage of the fact\n # that Python can use negative indices in lists.\n for l in xrange(2, self.num_layers):\n z = zs[-l]\n sp = sigmoid_prime(z)\n delta = np.dot(self.weights[-l+1].transpose(), delta) * sp\n nabla_b[-l] = delta\n nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())\n return (nabla_b, nabla_w)","def gradient(self, node, output_grad):\r\n #return [output_grad]\r\n return [broadcast_to(output_grad,get_shape_op(node.inputs[0]),node.const_attr)]"],"string":"[\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 ComputeGradientsTest(X, Y, W, b, my_lambda):\\n grad_W = [np.zeros(w.shape) for w in W]\\n grad_b = [np.zeros(bi.shape) for bi in b]\\n P, _, _ = EvaluateClassifier(X, W, b)\\n cost, _ = ComputeCost(Y, W, P, my_lambda)\\n for k in range(len(W)):\\n\\n w = W[k]\\n for i in range(w.shape[0]):\\n for j in range(w.shape[1]):\\n W[k][i][j] += epsilon\\n P1, _, _ = EvaluateClassifier(X, W, b)\\n cost1, _ = ComputeCost(Y, W, P1, my_lambda)\\n W[k][i][j] -= epsilon\\n grad_W[k][i][j] = (cost1 - cost) / epsilon\\n\\n for i in range(b[k].shape[0]):\\n b[k][i] += epsilon\\n P1, _, _ = EvaluateClassifier(X, W, b)\\n cost1, _ = ComputeCost(Y, W, P1, my_lambda)\\n b[k][i] -= epsilon\\n grad_b[k][i] = (cost1 - cost) / epsilon\\n\\n return grad_W, grad_b\",\n \"def ComputeGradsNum(X, Y, P, W, b, lamda, h):\\n\\tno \\t= \\tW.shape[0]\\n\\td \\t= \\tX.shape[0]\\n\\n\\tgrad_W = np.zeros(W.shape);\\n\\tgrad_b = np.zeros((no, 1));\\n\\n\\tc = ComputeCost(X, Y, W, b, lamda);\\n\\t\\n\\tfor i in range(len(b)):\\n\\t\\tprint(i)\\n\\t\\tb_try = b\\n\\t\\tb_try[i] += h\\n\\t\\tc2 = ComputeCost(X, Y, W, b_try, lamda)\\n\\t\\tgrad_b[i] = (c2-c) / h\\n\\n\\tfor i in range(W.shape[0]):\\n\\t\\tprint(i)\\n\\t\\tfor j in range(W.shape[1]):\\n\\t\\t\\tW_try = W\\n\\t\\t\\tW_try[i,j] += h\\n\\t\\t\\tc2 = ComputeCost(X, Y, W_try, b, lamda)\\n\\t\\t\\tgrad_W[i,j] = (c2-c) / h\\n\\n\\treturn [grad_W, grad_b]\",\n \"def get_cost_updates(self,learning_rate, beta=0.9):\\n max_x = T.max(self.x)\\n min_x = T.min(self.x)\\n self.x = (self.x - min_x) / (max_x - min_x)\\n y = self.get_hidden_values(self.x)\\n z = self.get_reconstructed_input(y)\\n # note : we sum over the size of a datapoint; if we are using\\n # minibatches, L will be a vector, with one entry per\\n # example in minibatch\\n # L = - T.sum(self.x * T.log(z) + (1 - self.x) * T.log(1 - z), axis=1)\\n L_prime = T.sum(T.square(z - self.x), axis=1)\\n # note : L is now a vector, where each element is the\\n # cross-entropy cost of the reconstruction of the\\n # corresponding example of the minibatch. We need to\\n # compute the average of all these to get the cost of\\n # the minibatch\\n cost = T.mean(L_prime)\\n\\n # compute the gradients of the cost of the `dA` with respect\\n # to its parameters\\n gparams = T.grad(cost, self.params)\\n # generate the list of updates\\n updates = []\\n for momen, gparm1 in zip(self.mom, gparams):\\n updates.append((momen, momen * beta + (1 - beta) * gparm1))\\n for param, momen in zip(self.params, self.mom):\\n updates.append((param, param - learning_rate * momen))\\n\\n return (cost, updates)\",\n \"def costFun(self, x):\\n\\ttmp = x.reshape(self.inp_shape)\\n\\tc = np.float64(self.calcCost(np.asarray(tmp,dtype=np.float32))) + self.alpha * np.dot(x.T, x)\\n\\treturn c\",\n \"def gradient(C, w, b):\\n return list(partial_deriv(C, b)) + list(partial_deriv(C, wi) for wi in w)\",\n \"def get_cost_updates(self):\\n\\n y = self.get_hidden_values()\\n z = self.get_reconstructed_input(y)\\n\\n L = T.sum((self.x-z)**2, axis=1)\\n\\n cost = T.mean(L)\\n\\n return cost\",\n \"def get_cost_updates(self, contraction_level, learning_rate):\\r\\n\\r\\n y = self.get_hidden_values(self.x)\\r\\n z = self.get_reconstructed_input(y)\\r\\n J = self.get_jacobian(y, self.W)\\r\\n # note : we sum over the size of a datapoint; if we are using\\r\\n # minibatches, L will be a vector, with one entry per\\r\\n # example in minibatch\\r\\n self.L_rec = - T.sum(self.x * T.log(z) +\\r\\n (1 - self.x) * T.log(1 - z),\\r\\n axis=1)\\r\\n\\r\\n # Compute the jacobian and average over the number of samples/minibatch\\r\\n self.L_jacob = T.sum(J ** 2) / self.n_batchsize\\r\\n\\r\\n # note : L is now a vector, where each element is the\\r\\n # cross-entropy cost of the reconstruction of the\\r\\n # corresponding example of the minibatch. We need to\\r\\n # compute the average of all these to get the cost of\\r\\n # the minibatch\\r\\n cost = T.mean(self.L_rec) + contraction_level * T.mean(self.L_jacob)\\r\\n\\r\\n # compute the gradients of the cost of the `cA` with respect\\r\\n # to its parameters\\r\\n gparams = T.grad(cost, self.params)\\r\\n # generate the list of updates\\r\\n updates = []\\r\\n for param, gparam in zip(self.params, gparams):\\r\\n updates.append((param, param - learning_rate * gparam))\\r\\n\\r\\n return (cost, updates)\",\n \"def get_cost_updates(self, contraction_level, learning_rate):\\n self.n_batchsize = 20\\n y = self.get_hidden_values(self.x)\\n z = self.get_reconstructed_input(y)\\n J = self.get_jacobian(y, self.W)\\n # note : we sum over the size of a datapoint; if we are using\\n # minibatches, L will be a vector, with one entry per\\n # example in minibatch\\n self.L_rec = - T.sum(self.x * T.log(z) +\\n (1 - self.x) * T.log(1 - z),\\n axis=1)\\n\\n # Compute the jacobian and average over the number of samples/minibatch\\n self.L_jacob = T.sum(J ** 2) / self.n_batchsize\\n\\n # note : L is now a vector, where each element is the\\n # cross-entropy cost of the reconstruction of the\\n # corresponding example of the minibatch. We need to\\n # compute the average of all these to get the cost of\\n # the minibatch\\n cost = T.mean(self.L_rec) + contraction_level * T.mean(self.L_jacob)\\n\\n # compute the gradients of the cost of the `cA` with respect\\n # to its parameters\\n gparams = T.grad(cost, self.params)\\n # generate the list of updates\\n updates = []\\n for param, gparam in zip(self.params, gparams):\\n updates.append((param, param - learning_rate * gparam))\\n\\n return (cost, updates)\",\n \"def backprop_batch(self, xs, ys):\\n nabla_b = [cp.zeros(b.shape) for b in self.biases]\\n nabla_w = [cp.zeros(w.shape) for w in self.weights]\\n\\n # forward pass\\n activation = xs\\n activations = [xs] # list to store all the activations, layer by layer\\n zs = [] # list to store all the z vectors, layer by layer\\n for b, w in zip(self.biases, self.weights):\\n zs.append(w @ activation + b)\\n activation = sigmoid(zs[-1])\\n activations.append(activation)\\n\\n # backward pass\\n delta = self.cost_derivative(activations[-1], ys) * f_sigmoid_prime(activations[-1])\\n nabla_w[-1] = delta @ activations[-2].transpose((0, 2, 1))\\n nabla_b[-1] = delta\\n for t in range(self.num_layers - 2, 0, -1):\\n delta = f_sigmoid_prime(activations[t]) * (self.weights[t].T @ delta)\\n nabla_w[t - 1] = delta @ activations[t - 1].transpose((0, 2, 1))\\n nabla_b[t - 1] = delta\\n return nabla_b, nabla_w\",\n \"def jacobian(self, xs):\\n rx_list = []\\n for nx,x in enumerate(xs):\\n \\n numpy.testing.assert_array_almost_equal(self.independentVariableShapeList[nx], numpy.shape(x), err_msg = '\\\\ntaped xs[%d].shape != forward xs[%d]\\\\n'%(nx,nx))\\n rx = numpy.ravel(x)\\n rx_list.append(rx)\\n self.x = numpy.concatenate(rx_list)\\n return wrapped_functions.jacobian(self.tape_tag, self.x)\",\n \"def compute_cost(X, y, theta, lambd):\\n assert(theta.shape[0] == X.shape[1])\\n \\n m = X.shape[0]\\n grad = np.zeros(y.shape)\\n J = 0\\n \\n output = sigmoid(np.dot(X, theta))\\n\\n J = np.sum(- y * np.log(output) - (1 - y) * np.log(1 - output)) / m + lambd / (2 * m) * np.sum(np.square(theta[1:]))\\n\\n grad = np.dot(X.T, (output - y)) / m\\n \\n grad[1:] = grad[1:] + lambd / m * theta[1:]\\n\\n return J, grad\",\n \"def get_constraint_gradient_array(self, x):\\n all_constraint_grads = self.constraint.get_gradient(x)\\n constraint_grads = 1. * all_constraint_grads[0]\\n for i in range(1, len(all_constraint_grads)):\\n constraint_grads = np.column_stack((constraint_grads, 1. * all_constraint_grads[i]))\\n return constraint_grads\",\n \"def backprop(self, x, y):\\n nabla_b = [np.zeros(b.shape) for b in self.biases] #返回一个给定形状和类型的用0填充的数组 shape:形状\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\n # feedforward\\n activation = x\\n activations = [x] # list to store all the activations, layer by layer\\n zs = [] # list to store all the z vectors, layer by layer\\n for b, w in zip(self.biases, self.weights):\\n z = np.dot(w, activation)+b # 计算每一个节点的值\\n zs.append(z)\\n activation = sigmoid(z) # 加入激活函数\\n activations.append(activation)\\n\\n ''' backward pass 最后一层的 w和b \\n 因为最后一层没有权重weights因此单独计算，没有放在循环中\\n '''\\n delta = self.cost_derivative(activations[-1], y) * \\\\\\n sigmoid_prime(zs[-1])\\n nabla_b[-1] = delta\\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\\n # Note that the variable l in the loop below is used a little\\n # differently to the notation in Chapter 2 of the book. Here,\\n # l = 1 means the last layer of neurons, l = 2 is the\\n # second-last layer, and so on. It's a renumbering of the\\n # scheme in the book, used here to take advantage of the fact\\n # that Python can use negative indices in lists.\\n for l in range(2, self.num_layers):\\n z = zs[-l]\\n sp = sigmoid_prime(z)\\n delta = np.dot(self.weights[-l+1].transpose(), delta) * sp\\n nabla_b[-l] = delta\\n nabla_w[-l] = np.dot(delta, activations[-l-1].transpose()) \\n return (nabla_b, nabla_w)\",\n \"def get_updates(self):\\n\\n\\t\\tda_cost = self.get_cost()\\n\\n\\t\\tweight_gradient = theano.tensor.grad(da_cost, self.weights)\\n\\t\\tbias_gradient = theano.tensor.grad(da_cost, self.bias)\\n\\t\\treverse_bias_gradient = theano.tensor.grad(da_cost, self.reverse_bias)\\n\\n\\t\\tlr_cost = self.get_lr_cost()\\n\\t\\tlr_weight_gradient = theano.tensor.grad(lr_cost, self.label_weights)\\n\\t\\tlr_bias_gradient = theano.tensor.grad(lr_cost, self.label_bias)\\n\\n\\t\\tupdates = [\\n\\t\\t\\t(self.weights, self.weights - self.learning_rate*weight_gradient),\\n\\t\\t\\t(self.bias, self.bias - self.learning_rate*bias_gradient),\\n\\t\\t\\t(self.reverse_bias, self.reverse_bias -\\n\\t\\t\\t\\tself.learning_rate*reverse_bias_gradient),\\n\\t\\t\\t(self.label_weights, self.label_weights -\\n\\t\\t\\t\\tself.learning_rate*lr_weight_gradient),\\n\\t\\t\\t(self.label_bias, self.label_bias -\\n\\t\\t\\t\\tself.learning_rate*lr_bias_gradient)]\\n\\n\\t\\treturn updates\",\n \"def compute_gradient(c, x, y):\\n\\n vectors = np.array([[0, 1], [0, -1], [1, 0], [-1, 0]])\\n rows, cols = c.shape\\n\\n result = np.empty_like(x)\\n\\n for i in nb.prange(rows):\\n for j in nb.prange(cols):\\n c_remainder = c[i, j] % 4\\n gradient_co = vectors[c_remainder]\\n result[i, j] = gradient_co[0] * x[i, j] + gradient_co[1] * y[i, j]\\n\\n return result\",\n \"def compute_cost_gradient1(x, y0, W, b):\\n # compute cost\\n A = x @ W + b\\n y = sigmoid(A)\\n if y0 is None:\\n return y\\n cost = -1 * np.sum(y0 * np.log(y) + (1 - y0) * np.log(1 - y))\\n # compute gradients\\n dy = -(y0 * (y ** -1) - (1 - y0) * ((1 - y) ** -1))\\n dA = dy * (y * (1 - y))\\n dW = x.T @ dA\\n db = np.sum(dA)\\n return cost, dW, db\",\n \"def b_gradient_descent(self, LB,UB,eta, tol,iter):\\n bgd=[]\\n bgd_x=[LB]\\n iteration=0\\n # current_pt=X\\n first_derivative=sym.diff(self.gdfunc)\\n #print(first_derivative)\\n x=sym.Symbol('x')\\n first_derivative=sym.lambdify(x,first_derivative)\\n learn_rate=eta\\n \\n new_x=LB\\n bgd_x.append(LB)\\n \\n for i in range(iter):\\n for j in np.arange(LB,UB,0.1):\\n prev_x=new_x\\n new_x=prev_x-(learn_rate*first_derivative(prev_x))\\n #print(\\\"i = \\\",j,\\\"gradient =\\\",(learn_rate*first_derivative(j)),iteration)\\n iteration=iteration+1\\n #print(iteration)\\n if iteration >=iter:\\n break \\n if new_x <= tol:\\n #print(\\\"new_x = \\\",new_x,\\\"gradient =\\\",(learn_rate*first_derivative(prev_x)), iteration) \\n break\\n \\n \\n \\n \\n #print(new_x)\\n bgd_x.append(new_x)\\n \\n \\n bgd.append(bgd_x)\\n bgd.append(new_x)\\n bgd.append(iteration)\\n\\n return bgd\",\n \"def compute_cost_gradient2(x, y0, W, V, U, b0, b1, b2):\\n # compute cost\\n A1 = x @ W + b0\\n A2 = x @ V + b1\\n z0 = sigmoid(A1)\\n z1 = sigmoid(A2)\\n z = np.array([z0, z1]).T\\n A3 = z @ U + b2\\n y = sigmoid(A3)\\n if y0 is None:\\n return y\\n cost = np.sum((y - y0) ** 2)\\n # compute gradient\\n dy = 2 * (y - y0)\\n dA3 = dy * (y * (1 - y))\\n dz0 = dA3 * U[0]\\n dz1 = dA3 * U[1]\\n dA1 = dz0 * (z0 * (1 - z0))\\n dA2 = dz1 * (z1 * (1 - z1))\\n dW = x.T @ dA1\\n dV = x.T @ dA2\\n dU = z.T @ dA3\\n db0 = np.sum(dA1)\\n db1 = np.sum(dA2)\\n db2 = np.sum(dA3)\\n return cost, dW, dV, dU, db0, db1, db2\",\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 ComputeGradsNumSlow(X, Y, P, W, b, lamda, h, classifier):\\n no = W.shape[0]\\n d = X.shape[0]\\n\\n grad_W = np.zeros(W.shape);\\n grad_b = np.zeros((no, 1));\\n\\n for i in range(len(b)):\\n b_try = np.array(b)\\n b_try[i] -= h\\n c1 = classifier.ComputeCost(X, Y, W, b_try, lamda)\\n\\n b_try = np.array(b)\\n b_try[i] += h\\n c2 = classifier.ComputeCost(X, Y, W, b_try, lamda)\\n\\n grad_b[i] = (c2 - c1) / (2 * h)\\n\\n for i in range(W.shape[0]):\\n for j in range(W.shape[1]):\\n W_try = np.array(W)\\n W_try[i, j] -= h\\n c1 = classifier.ComputeCost(X, Y, W_try, b, lamda)\\n\\n W_try = np.array(W)\\n W_try[i, j] += h\\n c2 = classifier.ComputeCost(X, Y, W_try, b, lamda)\\n\\n grad_W[i, j] = (c2 - c1) / (2 * h)\\n\\n return [grad_W, grad_b]\",\n \"def gradient_descent(x, y, theta=[[0], [0]]):\\n m = y.size\\n j_history = []\\n for i in range(ITERATIONS):\\n h = x.dot(theta)\\n theta = theta - (ALPHA / m) * (x.T.dot(h - y))\\n j_history.append(compute_cost(x, y, theta))\\n return theta, j_history\",\n \"def backprop1_6(self, x, y):\\r\\n \\r\\n nabla_b = [np.zeros(b.shape) for b in self.biases]\\r\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\r\\n # feedforward\\r\\n activation = x\\r\\n activations = [x] # list to store all the activations, layer by layer\\r\\n zs = [] # list to store all the z vectors, layer by layer\\r\\n\\r\\n for b, w in list(zip(self.biases, self.weights))[:len(self.biases)-1]:\\r\\n z = np.dot(w, activation)+b\\r\\n zs.append(z)\\r\\n activation = relu(z)\\r\\n #print(activation)\\r\\n activations.append(activation)\\r\\n\\r\\n b = self.biases[-1]\\r\\n w = self.weights[-1]\\r\\n z = np.dot(w, activation)+b\\r\\n zs.append(z)\\r\\n activation = softmax(z)\\r\\n activations.append(activation)\\r\\n\\r\\n # backward pass\\r\\n delta = self.cost_derivative(activations[-1], y)\\r\\n\\r\\n nabla_b[-1] = delta\\r\\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\\r\\n # Note about the variable l: Here,\\r\\n # l = 1 means the last layer of neurons, l = 2 is the\\r\\n # second-last layer, and so on. This numbering takes advantage of the fact\\r\\n # that Python can use negative indices in lists.\\r\\n for l in range(2, self.num_layers):\\r\\n z = zs[-l]\\r\\n sp = reluDerivative(z)\\r\\n delta = np.dot(self.weights[-l+1].transpose(), delta) * sp\\r\\n nabla_b[-l] = delta\\r\\n nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())\\r\\n return (nabla_b, nabla_w)\",\n \"def backprop(x, y):\\n nabla_b = [np.zeros(b.shape) for b in self.biases]\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\n # feedforward\\n activation = x\\n activations = [x] # list to store all the activations, layer by layer\\n zs = [] # list to store all the z vectors, layer by layer\\n for b, w in zip(self.biases, self.weights):\\n z = np.dot(w, activation) + b\\n zs.append(z)\\n activation = sigmoid(z)\\n activations.append(activation)\\n # backward pass\\n delta = cost_derivative(activations[-1], y) * sigmoid_prime(zs[-1])\\n nabla_b[-1] = delta\\n nabla_w[-1] = np.dot(delta, np.array(activations[-2]).transpose())\\n # Note that the variable l in the loop below is used a little\\n # differently to the notation in Chapter 2 of the book. Here,\\n # l = 1 means the last layer of neurons, l = 2 is the\\n # second-last layer, and so on. It's a renumbering of the\\n # scheme in the book, used here to take advantage of the fact\\n # that Python can use negative indices in lists.\\n for l in xrange(2, self.num_layers):\\n z = zs[-l]\\n sp = sigmoid_prime(z)\\n delta = np.dot(self.weights[-l + 1].transpose(), delta) * sp\\n nabla_b[-l] = delta\\n nabla_w[-l] = np.dot(delta, np.array(activations[-l - 1]).transpose())\\n return (nabla_b, nabla_w)\",\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 fun(x, *args):\\n distance = a.normalized_distance(x.reshape(shape))\\n return distance.value, distance.gradient.reshape(-1)\",\n \"def individual_cost_function(gp, output_trajectory, output_times):\\r\\n # GET RIGHT PART OF ARRAY\\r\\n # REFORMAT\\r\\n # NOISE DATA\\r\\n # PREDICT NEW VALUES\\r\\n # GET COST.\\r\\n X_reshaped = output_times[:,None]\\r\\n # X_list = GPy_reformat_3D(output_times)\\r\\n # Y_list = GPy_reformat_3D(output_trajectory)\\r\\n\\r\\n # X_list = np.concatenate((X_reshaped,X_reshaped,X_reshaped), axis=1)\\r\\n X_list = X_reshaped\\r\\n array1 = output_trajectory.T[:, 0, None]\\r\\n array2 = output_trajectory.T[:, 1, None]\\r\\n array3 = output_trajectory.T[:, 2, None]\\r\\n Y_list = np.concatenate((array1,array2,array3),axis=1)\\r\\n Y_list = array1\\r\\n X_list = np.concatenate((X_reshaped,np.zeros_like(X_reshaped)),axis=1)\\r\\n\\r\\n\\r\\n Times_pred_1 = np.concatenate((X_reshaped, np.ones_like(X_reshaped)-1), axis=1)\\r\\n noise_dict1 = {'output_index': Times_pred_1[:, 1:].astype(int)}\\r\\n Xpred, Xvar = gp.predict(Times_pred_1,Y_metadata=noise_dict1)\\r\\n\\r\\n Times_pred_2 = np.concatenate((X_reshaped, np.ones_like(X_reshaped)), axis=1)\\r\\n noise_dict2 = {'output_index': Times_pred_2[:, 1:].astype(int)}\\r\\n Ypred, Yvar = gp.predict(Times_pred_2,Y_metadata=noise_dict2)\\r\\n\\r\\n Times_pred_3 = np.concatenate((X_reshaped, np.ones_like(X_reshaped)+1), axis=1)\\r\\n noise_dict3 = {'output_index': Times_pred_3[:, 1:].astype(int)}\\r\\n Zpred, Zvar = gp.predict(Times_pred_3,Y_metadata=noise_dict3)\\r\\n\\r\\n return gp.log_predictive_density(X_list,Y_list) # ,Y_metadata=noise_dict1) # ARRAY OF ROW INDICES, ARRAY OF COLUMN INDICES, COST\\r\",\n \"def cofiCostFunc(params, Y, R, num_users, num_movies, num_features, lbd):\\n X = np.reshape(params[:num_movies*num_features], (num_movies, num_features))\\n Theta = np.reshape(params[num_movies*num_features:], (num_users, num_features))\\n\\n # J=sum((X*Theta'-Y)^2) where R[i,j]==1\\n h = X.dot(Theta.T)-Y\\n M = h**2\\n J = (M*R).sum()/2\\n reg = lbd/2*((X**2).sum()+(Theta**2).sum())\\n J = J+reg\\n\\n X_grad = (h*R).dot(Theta)+lbd*X\\n Theta_grad = (h*R).T.dot(X)+lbd*Theta\\n\\n grad = np.r_[X_grad.flatten(), Theta_grad.flatten()]\\n return J, grad\",\n \"def gradient(self, x):\\n u = np.asarray([x[0]])\\n C = self.C_func(u)\\n dC = self.dC_func(u, order=1)\\n P = self.P\\n numerator = np.sum((C - P) * dC, axis=0)\\n denominator = np.sum(np.sum((C - P) ** 2, axis=0) ** (1 / 2))\\n if np.abs(denominator) > 0:\\n gradient = numerator/denominator\\n else:\\n gradient = np.asarray(0)[np.newaxis]\\n return gradient\",\n \"def output_error(self, zs, activations, y):\\n nabla_b = [np.zeros(b.shape) for b in self.biases]\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\n\\n delta = self.cost_derivative_for_output(activations[-1], y) * sigmoid_prime(zs[-1])\\n nabla_b[-1] = delta\\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\\n return delta, nabla_b, nabla_w\",\n \"def get_cost(self) -> numpy.ndarray:\\n def product(*args, repeat=1):\\n # product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy\\n # product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111\\n pools = [list(pool) for pool in args] * repeat\\n result = [[]]\\n for pool in pools:\\n result = [x + [y] for x in result for y in pool]\\n for prod in result:\\n yield list(prod)\\n\\n # Number of edges\\n M = self.num_edges\\n # Number of nodes\\n N = self.num_nodes\\n # Adjacency matrix\\n A = networkx.adjacency_matrix(self.graph).todense()\\n\\n # Generate a list of all possible n‐tuples of elements from {1,-1} and\\n # organize them as a (2^n x n) matrix. In other words create all\\n # possible solutions to the problem.\\n s = numpy.array(list(product([1, -1], repeat=N)))\\n\\n # Construct the the cost function for Max Cut: C=1/2*Sum(Z_i*Z_j)-M/2\\n # Note: This is the minimization version\\n return 1 / 2 * (numpy.diag(s@numpy.triu(A)@s.T) - M)\",\n \"def evaluate(self, X: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:\\n\\n output = self.fct(X, *self.args)\\n\\n Y = output[0].reshape(X.shape[0], self.ydim)\\n C = (\\n output[1].reshape(X.shape[0], self.cdim)\\n if self.cdim > 0\\n else np.zeros((X.shape[0], self.cdim))\\n )\\n\\n # Build penalty function\\n Py = Optimizer.boundaryCheck(Y, self.ylb, self.yub)\\n Px = Optimizer.boundaryCheck(X, self.xlb, self.xub)\\n Pc = Optimizer.boundaryCheck(C, self.clb, self.cub)\\n\\n # Assemble all penalties\\n P = Py + Px + Pc\\n\\n # callback:\\n if self.callback is not None:\\n self.callback(X, Y, C, self.currentIteration)\\n\\n # Return to optimizer\\n return Y, C, P\",\n \"def gradient_descent(X, Y, iterations, alpha, l = 0):\\n \\n # initialize B0, B1, ..., Bp\\n betas = np.array([0.0]*(len(X[0])+1))\\n \\n # initialize list of cost vs iterations; should see a gradual descent\\n costs = np.array([0.0]*iterations)\\n \\n # number of observations\\n m = len(X)\\n \\n for i in range(iterations):\\n sumterms = 1.0/m * ([estimation(xvec,betas) for xvec in X] - Y)\\n errors = np.array([0.0]*len(betas))\\n errors[0] = sum(sumterms) # error term for B0 has no multiplier\\n for k in range(1,len(betas)):\\n errors[k] = np.dot(sumterms, [row[k-1] for row in X]) + l/m*betas[k]\\n \\n betas = betas - alpha * errors\\n costs[i] = cost(X, Y, betas, l)\\n \\n return betas, costs\",\n \"def get_params_grad(self, X, output_grad):\\n JW = X.T.dot(output_grad)\\n Jb = np.sum(output_grad, axis=0)\\n return [g for g in itertools.chain(np.nditer(JW), np.nditer(Jb))]\",\n \"def gradient_of_selection(f_jk,benefit_function,b,c=1,*params):\\n f_jk['gos'] = f_jk.A*(b*benefit_function(f_jk.j+1,f_jk.k+1,*params)-c) - f_jk.B*b*benefit_function(f_jk.j,f_jk.k+1,*params)\\n gos = f_jk.groupby('n')['gos'].sum() \\n gos = gos*(Z-gos.index.values)*gos.index.values/(Z**2)*DELTA\\n gos.loc[0]=gos.loc[100]=0\\n return gos\",\n \"def backprop1_7(self, x, y):\\r\\n \\r\\n nabla_b = [np.zeros(b.shape) for b in self.biases]\\r\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\r\\n # feedforward\\r\\n activation = x\\r\\n activations = [x] # list to store all the activations, layer by layer\\r\\n zs = [] # list to store all the z vectors, layer by layer\\r\\n\\r\\n for b, w in list(zip(self.biases, self.weights))[:len(self.biases)-1]:\\r\\n z = np.dot(w, activation)+b\\r\\n zs.append(z)\\r\\n activation = relu(z)\\r\\n #print(activation)\\r\\n activations.append(activation)\\r\\n\\r\\n b = self.biases[-1]\\r\\n w = self.weights[-1]\\r\\n z = np.dot(w, activation)+b\\r\\n zs.append(z)\\r\\n activation = softmax(z)\\r\\n activations.append(activation)\\r\\n\\r\\n # backward pass\\r\\n delta = self.cost_derivative(activations[-1], y)\\r\\n\\r\\n nabla_b[-1] = delta\\r\\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\\r\\n # Note about the variable l: Here,\\r\\n # l = 1 means the last layer of neurons, l = 2 is the\\r\\n # second-last layer, and so on. This numbering takes advantage of the fact\\r\\n # that Python can use negative indices in lists.\\r\\n for l in range(2, self.num_layers):\\r\\n z = zs[-l]\\r\\n sp = leakyreluDerivative(z)\\r\\n delta = np.dot(self.weights[-l+1].transpose(), delta) * sp\\r\\n nabla_b[-l] = delta\\r\\n nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())\\r\\n return (nabla_b, nabla_w)\",\n \"def cost_function(self, X, y, theta_list, bias):\\n total_samples = len(y)\\n loss = 0\\n\\n for i in range(total_samples):\\n hypothesis = bias\\n hypothesis += np.matmul(X[i], np.array(theta_list).T)\\n \\n de = 1.0 + np.exp(-hypothesis)\\n sigmoidhypothesis = 1.0/de\\n\\n loss += (y[i]*np.log(sigmoidhypothesis)) + ((1-y[i])*(np.log(1 - sigmoidhypothesis)))\\n\\n return -1 * (loss/total_samples) #loss calculation\",\n \"def gradient_descent(initial_theta, X, y, niter, alpha, Lambda=0.0):\\n theta_list = []\\n cost_list = []\\n\\n theta = initial_theta\\n for i in range(0, niter):\\n theta -= alpha*gradient(theta, X, y, Lambda)\\n theta_list.append(theta)\\n cost_list.append(cost(theta, X, y, Lambda))\\n\\n return theta_list, cost_list\",\n \"def grad(self, x):\\n beta_flat = x.ravel()\\n Ab = np.vstack([Ai.dot(beta_flat) for Ai in self.A]).T\\n Ab_norm2 = np.sqrt(np.sum(Ab ** 2.0, axis=1))\\n\\n upper = Ab_norm2 > utils.TOLERANCE\\n grad_Ab_norm2 = Ab\\n grad_Ab_norm2[upper] = (Ab[upper].T / Ab_norm2[upper]).T\\n\\n lower = Ab_norm2 <= utils.TOLERANCE\\n n_lower = lower.sum()\\n\\n if n_lower:\\n D = len(self.A)\\n vec_rnd = (self.rng(n_lower, D) * 2.0) - 1.0\\n norm_vec = np.sqrt(np.sum(vec_rnd ** 2.0, axis=1))\\n a = self.rng(n_lower)\\n grad_Ab_norm2[lower] = (vec_rnd.T * (a / norm_vec)).T\\n\\n grad = np.vstack([self.A[i].T.dot(grad_Ab_norm2[:, i])\\n for i in xrange(len(self.A))])\\n grad = grad.sum(axis=0)\\n\\n return self.l * grad.reshape(x.shape)\",\n \"def Gradient(self):\\n \\n OutList = []\\n for dim in range(0,Dimension):\\n X = self._CreateSameType()\\n \\n for Ind in self.IndList():\\n \\n Factor = -1j * Ind[dim]\\n \\n X[Ind] = Factor * self[Ind]\\n \\n OutList.append(X)\\n \\n return BZO(array(OutList))\",\n \"def compute_grad(self, w0, w, data_type):\\n\\t\\tdw0 = 0\\n\\t\\tdw = [0]*len(w)\\n\\t\\tnum_data = 0\\n\\t\\tfor x_dict, y in dl.data_gen(self.data_file, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\tself.int_minmax, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\tself.category_dicts, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\tdata_type):\\n\\t\\t\\tprob = self.compute_prob(w0, w, x_dict)\\n\\t\\t\\tdw0 += -y + prob\\n\\t\\t\\tfor loc, x_val in x_dict.items():\\n\\t\\t\\t\\tdw[loc] += x_val * (-y + prob)\\n\\t\\t\\tnum_data += 1\\n\\t\\treturn dw0/num_data, [dwj/num_data for dwj in dw]\",\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 compute_grad(beta, lambdat, X, y):\\n return -2/len(y)*(np.maximum(0, 1-(\\n (y[:, np.newaxis]*X).dot(beta)))).dot(\\n y[:, np.newaxis]*X) + 2 * lambdat * beta\",\n \"def UpdateCostMatrix( self, extraXs ):\\n for x in extraXs:\\n newRow = [ self.EuclideanDistanceSq(x,y) for y in self.Y ]\\n self.C.append(newRow)\",\n \"def gradient(init_par, alpha, delta, obs, sigma_obs, ccoef, N):\\n\\n\\n\\t## Initial parameters\\n\\n\\tparallax, v, sigma_v = init_par[:-4], init_par[-4:-1], init_par[-1] \\n\\tplx_obs, mualpha_obs, mudelta_obs = obs[:, 0], obs[:, 1], obs[:, 2]\\n\\n\\t### Define normal triad and proper motions\\n\\tp, q, r = normalTriad(alpha, delta)\\n\\tmualpha_mod = np.dot(np.transpose(p),v)*parallax/_A\\n\\tmudelta_mod = np.dot(np.transpose(q),v)*parallax/_A\\n\\t\\n\\tplx_mod, mualpha_mod, mudelta_mod = parallax, mualpha_mod, mudelta_mod\\n\\tsigma_plx, sigma_mualpha, sigma_mudelta = np.transpose(sigma_obs)\\n\\ta,like, expo, detD = np.ones(N),np.ones(N),np.ones(N), np.ones(N) \\n\\n\\t### Eq. 8 in Lindegren+2000 (Covariance Matrix)\\n\\tC = np.zeros((3,3,N),dtype=np.float64)\\n\\tC[0,0,:],C[1,1,:],C[2,2,:] = sigma_plx**2.,sigma_mualpha**2., sigma_mudelta**2.\\n\\tcorr_coefficient_plx_mualpha, corr_coefficient_plx_mudelta, corr_coefficient_mualpha_mudelta = np.zeros(N), np.zeros(N), np.zeros(N)\\n\\tcorr_coefficient_plx_mualpha[:], corr_coefficient_plx_mudelta[:], corr_coefficient_mualpha_mudelta[:] = ccoef[:, 0], ccoef[:, 1], ccoef[:, 2] \\n\\t\\n\\tC[0,1,:], C[0,2,:] = corr_coefficient_plx_mualpha*sigma_plx*sigma_mualpha, corr_coefficient_plx_mudelta*sigma_plx*sigma_mudelta\\n\\tC[1,0,:], C[1,2,:] = corr_coefficient_plx_mualpha*sigma_plx*sigma_mualpha, corr_coefficient_mualpha_mudelta*sigma_mualpha*sigma_mudelta\\n\\tC[2,0,:], C[2,1,:] = corr_coefficient_plx_mudelta*sigma_plx*sigma_mudelta, corr_coefficient_mualpha_mudelta*sigma_mualpha*sigma_mudelta\\n\\n\\t### Eq. 16 in Lindegren+2000 (Definition of D matrix)\\t\\n\\tE = np.zeros((3,3,N),dtype=np.float64)\\n\\tE[1,1,:],E[2,2,:] = (sigma_v*parallax[:]/_A)**2., (sigma_v*parallax[:]/_A)**2.\\n\\tD,invD = np.zeros((3,3,N),dtype=np.float64),np.zeros((3,3,N),dtype=np.float64)\\n\\tD = np.add(E,C)\\n\\tfor i in range(N):\\n\\t\\tdetD[i] = matrix_det(D[:,:,i]) \\n\\t\\tinvD[:,:,i] = matrix_inv(D[:,:,i])\\n\\t\\t\\n\\t\\n\\ta_c = np.ones((3,N))\\n\\ta_c = [plx_obs - plx_mod, mualpha_obs - mualpha_mod, mudelta_obs-mudelta_mod]\\n\\t\\n\\t### First derivatives in Eq. A3 \\n\\tcprime_pi, cprime_vx, cprime_vy, cprime_vz, = np.ones((3,N)), np.ones((3,N)), \\\\\\n\\t\\t\\t\\t\\t\\t\\tnp.ones((3,N)), np.ones((3,N)), \\n\\tcprime_pi[0,:] = 1.\\n\\tcprime_pi[1,:] = np.dot(np.transpose(p),v)/_A\\n\\tcprime_pi[2,:] = np.dot(np.transpose(q),v)/_A\\n\\t\\n\\tcprime_vx[0,:] = 0.\\n\\tcprime_vx[1,:] = -np.sin(alpha)*plx_mod/_A \\n\\tcprime_vx[2,:] = -np.sin(delta)*np.cos(alpha)*plx_mod/_A\\n\\n\\t\\n\\tcprime_vy[0,:] = 0.\\n\\tcprime_vy[1,:] = np.cos(alpha)*plx_mod/_A \\n\\tcprime_vy[2,:] = -np.sin(delta)*np.sin(alpha)*plx_mod/_A\\n\\n\\tcprime_vz[0,:] = 0.\\n\\tcprime_vz[1,:] = 0. \\n\\tcprime_vz[2,:] = np.cos(delta)*plx_mod/_A\\n\\n\\tdlnd_dpi, dlnd_dsigmav = np.zeros(N), np.zeros(N)\\n\\tde_dpi, de_dsigmav = np.zeros(N), np.zeros(N)\\n\\t\\n\\n\\t### See Eq. A5 \\n\\tde_dpi[:] = ((sigma_v/_A)**2.)*2.*plx_mod[:]\\n\\tde_dsigmav[:] = ((plx_mod[:]/_A)**2.)*2.*sigma_v\\n\\t\\n\\tdlnd_dpi[:] = (invD[1,1,:] + invD[2,2,:])*de_dpi[:] \\n\\tdlnd_dsigmav[:] = (invD[1,1,:] + invD[2,2,:])*de_dsigmav[:]\\n\\t\\n\\t\\n\\t\\n\\t### See Eq. A6\\n\\tdG_dpi, dG_dsigmav = np.zeros((3,3,N)), np.zeros((3,3,N)) \\n\\t\\n\\tdG_dpi[0,0,:], dG_dpi[0,1,:], dG_dpi[0,2,:] = (-invD[0,1,:]*invD[1, 0, :] - invD[0, 2, :]*invD[2,0,:])*de_dpi[:], \\\\\\n\\t\\t\\t\\t\\t\\t (-invD[0,1,:]*invD[1, 1, :] - invD[0,2,:]*invD[2, 1, :])*de_dpi[:], \\\\\\n\\t\\t\\t\\t\\t\\t (-invD[0,1,:]*invD[1,2,:] - invD[0,2,:]*invD[2,2,:])*de_dpi[:]\\n\\tdG_dpi[1,0,:], dG_dpi[1,1,:], dG_dpi[1,2,:] = (-invD[1,1,:]*invD[1, 0, :] - invD[1, 2, :]*invD[2,0,:])*de_dpi[:], \\\\\\n\\t\\t\\t\\t\\t\\t (-invD[1,1,:]*invD[1, 1, :] - invD[1,2,:]*invD[2, 1, :])*de_dpi[:], \\\\\\n\\t\\t\\t\\t\\t\\t (-invD[1,1,:]*invD[1,2,:] - invD[1,2,:]*invD[2,2,:])*de_dpi[:]\\n\\tdG_dpi[2,0,:], dG_dpi[2,1,:], dG_dpi[2,2,:] = (-invD[2,1,:]*invD[1, 0, :] - invD[2, 2, :]*invD[2,0,:])*de_dpi[:], \\\\\\n\\t\\t\\t\\t\\t\\t (-invD[2,1,:]*invD[1, 1, :] - invD[2,2,:]*invD[2, 1, :])*de_dpi[:], \\\\\\n\\t\\t\\t\\t\\t\\t (-invD[2,1,:]*invD[1,2,:] - invD[2,2,:]*invD[2,2,:])*de_dpi[:]\\n\\t\\n\\n\\tdG_dsigmav[0,0,:], dG_dsigmav[0,1,:], dG_dsigmav[0,2,:] = (-invD[0,1,:]*invD[1, 0, :] - invD[0, 2, :]*invD[2,0,:])*de_dsigmav[:], \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t (-invD[0,1,:]*invD[1, 1, :] - invD[0,2,:]*invD[2, 1, :])*de_dsigmav[:], \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t (-invD[0,1,:]*invD[1,2,:] - invD[0,2,:]*invD[2,2,:])*de_dsigmav[:]\\n\\tdG_dsigmav[1,0,:], dG_dsigmav[1,1,:], dG_dsigmav[1,2,:] = (-invD[1,1,:]*invD[1, 0, :] - invD[1, 2, :]*invD[2,0,:])*de_dsigmav[:], \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t (-invD[1,1,:]*invD[1, 1, :] - invD[1,2,:]*invD[2, 1, :])*de_dsigmav[:], \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t (-invD[1,1,:]*invD[1,2,:] - invD[1,2,:]*invD[2,2,:])*de_dsigmav[:]\\n\\tdG_dsigmav[2,0,:], dG_dsigmav[2,1,:], dG_dsigmav[2,2,:] = (-invD[2,1,:]*invD[1, 0, :] - invD[2, 2, :]*invD[2,0,:])*de_dsigmav[:], \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t (-invD[2,1,:]*invD[1, 1, :] - invD[2,2,:]*invD[2, 1, :])*de_dsigmav[:], \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t (-invD[2,1,:]*invD[1,2,:] - invD[2,2,:]*invD[2,2,:])*de_dsigmav[:]\\n\\n\\tf_dpi = np.zeros((N), dtype=np.float64) \\n\\t\\n\\t\\n\\tfor i in range(N):\\n\\t\\tf_dpi_1, f_dpi_3 = 0., 0.0 \\n\\t\\tfor ia in range(3):\\n\\t\\t\\tfor ib in range(3):\\n\\t\\t\\t\\tf_dpi_1 += invD[ia,ib,i]*cprime_pi[ia,i]*a_c[ib][i]\\n\\t\\t\\t\\tf_dpi_3 += (-0.5)*(dG_dpi[ia,ib,i]*a_c[ia][i]*a_c[ib][i])\\n\\t\\t\\t\\t\\t\\n\\t\\tf_dpi_2 = (-0.5)*dlnd_dpi[i]\\n\\t\\tf_dpi[i] = f_dpi_1 + f_dpi_2 + f_dpi_3\\n\\t\\t\\n\\n\\tf_vx, f_vy, f_vz, f_sigmav = np.zeros(N), np.zeros(N), np.zeros(N), np.zeros(N) \\n\\n\\tf_vx = np.sum(invD[0,0,:]*cprime_vx[0,:]*a_c[0][:] + invD[0,1,:]*cprime_vx[0,:]*a_c[1][:] + invD[0,2,:]*cprime_vx[0,:]*a_c[2][:] + \\\\\\n\\t\\t invD[1,0,:]*cprime_vx[1,:]*a_c[0][:] + invD[1,1,:]*cprime_vx[1,:]*a_c[1][:] + invD[1,2,:]*cprime_vx[1,:]*a_c[2][:] + \\\\\\n\\t\\t invD[2,0,:]*cprime_vx[2,:]*a_c[0][:] + invD[2,1,:]*cprime_vx[2,:]*a_c[1][:] + invD[2,2,:]*cprime_vx[2,:]*a_c[2][:])\\n\\t\\n\\tf_vy = np.sum(invD[0,0,:]*cprime_vy[0,:]*a_c[0][:] + invD[0,1,:]*cprime_vy[0,:]*a_c[1][:] + invD[0,2,:]*cprime_vy[0,:]*a_c[2][:] + \\\\\\n\\t\\t invD[1,0,:]*cprime_vy[1,:]*a_c[0][:] + invD[1,1,:]*cprime_vy[1,:]*a_c[1][:] + invD[1,2,:]*cprime_vy[1][:]*a_c[2][:] + \\\\\\n\\t\\t invD[2,0,:]*cprime_vy[2,:]*a_c[0][:] + invD[2,1,:]*cprime_vy[2,:]*a_c[1][:] + invD[2,2,:]*cprime_vy[2,:]*a_c[2][:])\\n\\n\\tf_vz = np.sum(invD[0,0,:]*cprime_vz[0,:]*a_c[0][:] + invD[0,1,:]*cprime_vz[0,:]*a_c[1][:] + invD[0,2,:]*cprime_vz[0,:]*a_c[2][:] + \\\\\\n\\t\\t invD[1,0,:]*cprime_vz[1,:]*a_c[0][:] + invD[1,1,:]*cprime_vz[1,:]*a_c[1][:] + invD[1,2,:]*cprime_vz[1,:]*a_c[2][:] + \\\\\\n\\t\\t invD[2,0,:]*cprime_vz[2,:]*a_c[0][:] + invD[2,1,:]*cprime_vz[2,:]*a_c[1][:] + invD[2,2,:]*cprime_vz[2,:]*a_c[2][:])\\n\\t\\n\\tf_sigmav = np.sum(-0.5*(dG_dsigmav[0,0,:]*a_c[0][:]*a_c[0][:] + dG_dsigmav[0,1,:]*a_c[1][:]*a_c[0][:]+ dG_dsigmav[0,2,:]*a_c[2][:]*a_c[0][:] + \\\\\\n\\t\\t dG_dsigmav[1,0,i]*a_c[1][:]*a_c[0][:] + dG_dsigmav[1,1,:]*a_c[1][:]*a_c[1][:]+ dG_dsigmav[1,2,:]*a_c[1][:]*a_c[2][:] + \\t\\n\\t\\t dG_dsigmav[2,0,i]*a_c[2][:]*a_c[0][:] + dG_dsigmav[2,1,:]*a_c[2][:]*a_c[1][:]+ dG_dsigmav[2,2,:]*a_c[2][:]*a_c[2][:]))\\n\\t\\n\\n\\tf_sigmav = f_sigmav - 0.5*np.sum(dlnd_dsigmav)\\t\\n\\tf = np.concatenate((f_dpi, np.array([f_vx, f_vy, f_vz, f_sigmav]))) ### Grad L(theta), see Eq. 17\\n\\treturn -2.*f \\t\\t\\t\\t\\t\\t ### Grad U(theta), see Eq. 18\",\n \"def validation_cost(model, X_vala, L_vala, Y_vala):\\n vala_costs = []\\n for i in range(0,8-1+1):\\n X_v, L_v, Y_v = X_vala[i], L_vala[i], Y_vala[i]\\n c_v_s = model.get_cost(X_v,L_v,Y_v)\\n vala_costs.append(c_v_s)\\n return np.mean(vala_costs)\",\n \"def checkCostFunction(lbd=0):\\n # Create small problem\\n X_t = np.random.rand(4, 3)\\n Theta_t = np.random.rand(5, 3)\\n\\n # Zap out most entries\\n Y = X_t.dot(Theta_t.T)\\n Y[np.random.rand(Y.shape[0], Y.shape[1]) > .5] = 0\\n R = np.zeros(Y.shape)\\n R[Y == 0] = 1\\n\\n # Run Gradient Checking\\n X = np.random.randn(X_t.shape[0], X_t.shape[1])\\n Theta = np.random.randn(Theta_t.shape[0], Theta_t.shape[1])\\n num_users = Y.shape[1]\\n num_movies = Y.shape[0]\\n num_features = Theta_t.shape[1]\\n\\n def Jfunc(t):\\n return cofiCostFunc(t, Y, R, num_users, num_movies, num_features, lbd)\\n\\n numgrad = computeNumericalGradient(Jfunc, np.r_[X.flatten(), Theta.flatten()])\\n\\n cost, grad = cofiCostFunc(np.r_[X.flatten(), Theta.flatten()], Y, R, num_users, num_movies, num_features, lbd)\\n\\n print(np.c_[numgrad, grad])\\n print('The above two columns you get should be very similar.')\\n print('(Left-Your Numerical Gradient, Right-Analytical Gradient)\\\\n')\\n\\n diff = np.linalg.norm(numgrad-grad)/np.linalg.norm(numgrad+grad)\\n print('If your cost function implementation is correct, then')\\n print('the relative difference will be small (less than 1e-9).')\\n print('Relative Difference: %g\\\\n' % diff)\",\n \"def get_cost_updates(self, corruption_level, learning_rate):\\r\\n\\r\\n tilde_x = self.get_corrupted_input(self.x, corruption_level)\\r\\n y = self.get_hidden_values(tilde_x)\\r\\n z = self.get_reconstructed_input(y)\\r\\n # note : we sum over the size of a datapoint; if we are using\\r\\n # minibatches, L will be a vector, with one entry per\\r\\n # example in minibatch\\r\\n L = - T.sum(self.x * T.log(z) + (1 - self.x) * T.log(1 - z), axis=1)\\r\\n # note : L is now a vector, where each element is the\\r\\n # cross-entropy cost of the reconstruction of the\\r\\n # corresponding example of the minibatch. We need to\\r\\n # compute the average of all these to get the cost of\\r\\n # the minibatch\\r\\n cost = T.mean(L)\\r\\n\\r\\n # compute the gradients of the cost of the `dA` with respect\\r\\n # to its parameters\\r\\n gparams = T.grad(cost, self.params)\\r\\n # generate the list of updates\\r\\n updates = []\\r\\n for param, gparam in zip(self.params, gparams):\\r\\n updates.append((param, param - learning_rate * gparam))\\r\\n\\r\\n return (cost, updates)\",\n \"def compute_cost(AL, Y, parameters ,lambd):\\n L = len(parameters) // 2\\n m = Y.shape[1]\\n cost = -1 / m * np.sum(np.nan_to_num(Y * np.log(AL) + (1-Y) * np.log(1-AL)))\\n cost+= 0.5*(lambd/m)*sum(np.linalg.norm(parameters['W' + str(i)])**2 for i in range(1,L))\\n return cost\",\n \"def ComputeCostMatrix( self, A, B ):\\n #return [[EuclideanDistance(a,b) for b in B] for a in A]\\n return [[self.EuclideanDistanceSq(a,b) for b in B] for a in A] # skip the sqrt operation until later\",\n \"def cost_grad_log_reg(w, b, X, y, Multicalss=False):\\n if not len(X.shape) == 2:\\n X_flattened = X.reshape(X.shape[1] * X.shape[2], -1).T\\n else:\\n X_flattened = X\\n m = X_flattened.shape[1]\\n print(m)\\n if Multicalss:\\n # Multi-class\\n\\n y_train_reshaped = y.reshape(len(y), 1)\\n ohe = OneHotEncoder(categories='auto')\\n y_train_reshaped = ohe.fit_transform(y_train_reshaped).toarray()\\n print(y_train_reshaped.shape)\\n A = softmax(np.dot(X_flattened, w) + b)\\n print(A.shape)\\n xentropy = -np.sum(y_train_reshaped * np.log(A))\\n cost = np.mean(-1 / m * np.sum(y_train_reshaped * np.log(A) + (1 - y_train_reshaped) * np.log(1 - A), axis=1,\\n keepdims=True))\\n\\n dw = 1 / m * np.dot(X_flattened.T, (A - y_train_reshaped))\\n db = 1 / m * np.sum(A - y_train_reshaped)\\n else:\\n # Binary\\n A = sigmoid(np.dot(w.T, X_flattened) + b)\\n cost = -1 / m * np.sum(y * np.log(A) + (1 - y) * np.log(1 - A), axis=1, keepdims=True)\\n\\n dw = 1 / m * np.dot(X_flattened, (A - y).T)\\n db = 1 / m * np.sum(A - y)\\n\\n # grads/derivatives\\n cost = np.squeeze(cost)\\n\\n return dw, db, cost\",\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 costFunction(theta,X,y):\\n m = X.shape[0]\\n J = 0\\n h = sigmoid (np.dot(X,theta))\\n \\n J = (1/m)* ((-np.dot(y.T,(np.log(h)))) - np.dot((1 - y).T,(np.log(1-h))))\\n \\n #grad = (1/m) * np.dot(X.T,(h-y))\\n grad = (1/m) * np.dot((h.T - y), X).T\\n \\n return J, grad\",\n \"def cost_func(plist):\\n\\t\\tgamma, alpha = plist\\n\\t\\tk = ac.Moffat2DKernel(gamma, alpha, x_size=nx, y_size=ny)\\n\\n\\t\\tarr_out_predict = ac.convolve(arr_in, k)\\n\\n\\t\\tarr_out_fit, arr_out_predict_fit = match_dimension(arr_out, arr_out_predict)\\n\\t\\tdiff = (arr_out_fit - arr_out_predict_fit)*scale_factor\\n\\n\\t\\treturn np.sum(diff**2)/diff.size\",\n \"def b_coefficients(x1,x2,x3,y1,y2,y3,CCoefficients,DCoefficients):\\n\\tBCoefficients = np.array([\\t((y2-y1)/(x2-x1)-CCoefficients[0]*(x2-x1) - DCoefficients[0]*((x2-x1)**2)), \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t((y3-y2)/(x3-x2)-CCoefficients[1]*(x3-x2) - DCoefficients[1]*((x3-x2)**2)) \\t]).astype(float)\\n\\treturn(BCoefficients)\",\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 getVals(cdli):\\n \\n \\n swh = calcOutProd(np.reshape(cdli.datain_h, (cdli.datain_h.shape[0],1)), np.reshape(cdli.wh, (1, cdli.wh.shape[0])))\\n swl = calcOutProd(np.reshape(cdli.datain_l, (cdli.datain_l.shape[0],1)), np.reshape(cdli.wl, (1, cdli.wl.shape[0]))) \\n phi_h = [cdli.wh[i]*cdli.wh[i] for i in range(0,len(cdli.wh))] \\n phi_l = [cdli.wl[i]*cdli.wl[i] for i in range(0,len(cdli.wl))]\\n \\n return [[swh, swl], [phi_h, phi_l]]\",\n \"def _calc_gradients(self, X, y, y_hat):\\n # calculate gradient of weight and bias\\n grad_b = 2 * np.mean(y_hat - y)\\n grad_W = 2 * np.mean(np.matmul((y_hat - y), X))\\n return grad_W, grad_b\",\n \"def compute_gradient(self, grad=None):\\n if grad is None:\\n grad = backend.ones_like(self.output_value)\\n x, y = [node.output_value for node in self.input_nodes]\\n grad_wrt_x = grad\\n while backend.ndim(grad_wrt_x) > len(backend.shape(x)):\\n grad_wrt_x = backend.sum(grad_wrt_x, axis=0)\\n for axis, size in enumerate(backend.shape(x)):\\n if size == 1:\\n grad_wrt_x = backend.sum(grad_wrt_x, axis=axis, keepdims=True)\\n\\n grad_wrt_y = grad\\n while backend.ndim(grad_wrt_y) > len(backend.shape(y)):\\n grad_wrt_y = backend.sum(grad_wrt_y, axis=0)\\n for axis, size in enumerate(backend.shape(y)):\\n if size == 1:\\n grad_wrt_y = backend.sum(grad_wrt_y, axis=axis, keepdims=True)\\n return [grad_wrt_x, grad_wrt_y]\",\n \"def backprop(self, x, y):\\n nabla_b = [np.zeros(b.shape) for b in self.biases]\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\n\\n # feedforward\\n activation = x\\n\\n # list to store all the activations, layer by layer\\n activations = [x]\\n\\n # list to store all the z vectors, layer by layer\\n zs = []\\n for activ_func, b, w in zip(self._activation_funcs, self.biases, self.weights):\\n z = np.dot(w, activation) + b\\n zs.append(z)\\n activation = activ_func.fn(z)\\n activations.append(activation)\\n\\n # backward pass\\n delta = self.cost.delta(zs[-1], activations[-1], y)\\n\\n nabla_b[-1] = delta\\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\\n\\n # Note that the variable l in the loop below is used a little\\n # differently to the notation in Chapter 2 of the book. Here,\\n # l = 1 means the last layer of neurons, l = 2 is the\\n # second-last layer, and so on. It's a renumbering of the\\n # scheme in the book, used here to take advantage of the fact\\n # that Python can use negative indices in lists.\\n for l in xrange(2, self.num_layers):\\n z = zs[-l]\\n activ_func = self._activation_funcs[-l]\\n sp = activ_func.fprime(z)\\n delta = np.dot(self.weights[-l+1].transpose(), delta) * sp\\n nabla_b[-l] = delta\\n nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())\\n return (nabla_b, nabla_w)\",\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 \\r\\n h = numpy.dot(features, theta)\\r\\n \\r\\n theta = theta - alpha / m * numpy.dot((h-values),features)\\r\\n \\r\\n cost = compute_cost(features, values, theta)\\r\\n \\r\\n cost_history.append(cost)\\r\\n\\r\\n return theta, pandas.Series(cost_history) # leave this line for the grader\\r\",\n \"def backprop(self, x, y):\\r\\n #print(np.shape(x))\\r\\n nabla_b = [np.zeros(b.shape) for b in self.biases]\\r\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\r\\n # feedforward\\r\\n activation = x\\r\\n activations = [x] # list to store all the activations, layer by layer\\r\\n zs = [] # list to store all the z vectors, layer by layer\\r\\n #print(\\\"en\\\")\\r\\n for b, w in zip(self.biases, self.weights):\\r\\n z = np.dot(w, activation)+b\\r\\n zs.append(z)\\r\\n activation = sigmoid(z)\\r\\n activations.append(activation)\\r\\n\\r\\n # backward pass\\r\\n delta = self.cost_derivative(activations[-1], y) * \\\\\\r\\n sigmoid_prime(zs[-1])\\r\\n nabla_b[-1] = delta\\r\\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\\r\\n # Note about the variable l: Here,\\r\\n # l = 1 means the last layer of neurons, l = 2 is the\\r\\n # second-last layer, and so on. This numbering takes advantage of the fact\\r\\n # that Python can use negative indices in lists.\\r\\n for l in range(2, self.num_layers):\\r\\n z = zs[-l]\\r\\n sp = sigmoid_prime(z)\\r\\n delta = np.dot(self.weights[-l+1].transpose(), delta) * sp\\r\\n nabla_b[-l] = delta\\r\\n nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())\\r\\n #print('2')\\r\\n #print(nabla_w[-l])\\r\\n return (nabla_b, nabla_w)\",\n \"def gradFun(self, x):\\n tmp = x.reshape(self.inp_shape)\\n g = np.ravel(np.asarray(self.calcGrad(np.asarray(tmp,dtype=np.float32)),dtype=np.float64)) + 2*self.alpha*x\\n return g\",\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 gradient_descent_for_n_layers(num_layers, W, B, X, Y, alpha, num_iterations):\\n Z = [None] * (num_layers + 1)\\n A = [None] * (num_layers + 1)\\n dA = [None] * (num_layers + 1)\\n dW = [None] * (num_layers + 1)\\n dB = [None] * (num_layers + 1)\\n for _ in range(0, num_iterations):\\n\\n A[0] = np.array(X, copy=True)\\n for j in range(1, num_layers + 1):\\n Z[j], A[j] = forward_propagation(A[j - 1], W[j], B[j])\\n\\n yhat = A[num_layers]\\n dA[num_layers] = loss(yhat, Y)\\n cost_value = cost(dA[num_layers])\\n print(\\\"cost\\\", cost_value)\\n\\n for j in reversed(range(1, num_layers + 1)):\\n dA[j-1], dW[j], dB[j] = both_relu_and_linear_transform_and_chain_rule(\\n dA[j], Z[j], A[j-1], W[j])\\n W[j] = W[j] - (alpha * dW[j])\\n B[j] = B[j] - (alpha * dB[j])\\n\\n return W, B, yhat\",\n \"def get_cost_updates(self, corruption_rate=0.3, learning_rate=0.1):\\n tilde_x = self.get_corrupted_input(self.x, corruption_rate)\\n y = self.get_hidden_values(tilde_x)\\n z = self.get_reconstructed_input(y)\\n l = cross_entropy(self.x, z)\\n cost = T.mean(l)\\n grads = T.grad(cost, self.params)\\n updates = [\\n (param, param - learning_rate * grad) for param, grad in zip(self.params, grads)\\n ]\\n return cost, updates\",\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 compute_gradient(self, grad=None):\\n x, y = [node.output_value for node in self.input_nodes]\\n\\n if grad is None:\\n grad = backend.ones_like(self.output_value)\\n grad_wrt_x = grad * y\\n while backend.ndim(grad_wrt_x) > len(backend.shape(x)):\\n grad_wrt_x = backend.sum(grad_wrt_x, axis=0)\\n for axis, size in enumerate(backend.shape(x)):\\n if size == 1:\\n grad_wrt_x = backend.sum(grad_wrt_x, axis=axis, keepdims=True)\\n\\n grad_wrt_y = grad * x\\n while backend.ndim(grad_wrt_y) > len(backend.shape(y)):\\n grad_wrt_y = backend.sum(grad_wrt_y, axis=0)\\n for axis, size in enumerate(backend.shape(y)):\\n if size == 1:\\n grad_wrt_y = backend.sum(grad_wrt_y, axis=axis, keepdims=True)\\n\\n return [grad_wrt_x, grad_wrt_y]\",\n \"def compute_gradient(X, t, w): # TODO: try to change to square loss since it's hessian is easier to obtain\\n # TODO : print to console the max gradient in every run\\n A = np.dot(X, w)\\n m = t.shape[0]\\n C = -1 * t * (1 / (1 + np.exp(A * t)))\\n return (1 / m) * np.dot(X.T, C)\",\n \"def ANN_functional_shape(x_data):\\n\\tx_data_Li_Lj= ANN_discriminants(x_data)\\n\\tx_data_Li = np.reshape(x_data[:,:20].flatten(),(-1,5,4,1))\\n\\treturn [x_data_Li, x_data_Li_Lj]\",\n \"def _compute_gradient_list(x,\\n x_shape,\\n y,\\n y_shape,\\n x_init_value=None,\\n delta=1e-3,\\n init_targets=None,\\n extra_feed_dict=None):\\n assert isinstance(x, list)\\n dx, dy = zip(*[_compute_dx_and_dy(xi, y, y_shape) for xi in x])\\n\\n if init_targets is not None:\\n assert isinstance(init_targets, (list, tuple))\\n for init in init_targets:\\n init.run()\\n if x_init_value is None:\\n x_init_value = [None] * len(x)\\n ret = [_compute_gradient(xi, x_shapei, dxi, y, y_shape, dyi, x_init_valuei,\\n delta, extra_feed_dict=extra_feed_dict)\\n for xi, x_shapei, dxi, dyi, x_init_valuei in zip(x, x_shape, dx, dy,\\n x_init_value)]\\n return ret\",\n \"def deriv_costFunction(self, x, y):\\n self.yEst = self.forward_propagate(x)\\n\\n delta_o = np.multiply( ( self.yEst - y ), self.deriv_sigmoid(self.z_o) )\\n #partial deriv of cost wrt hidden -> output weights\\n partial_J_w_ho = np.dot( self.a_h.T, delta_o )\\n\\n ones_o = np.ones( delta_o.shape[0] )\\n #partial deriv of cost wrt output biases\\n partial_J_b_o = np.dot( ones_o, delta_o )\\n\\n delta_h = np.dot( delta_o, self.w_ho.T ) * self.deriv_sigmoid( self.z_h )\\n #partial deriv of cost wrt input -> hidden weights\\n partial_J_w_ih = np.dot( x.T, delta_h )\\n \\n ones_h = np.ones( delta_h.shape[0] )\\n #partial deriv of cost wrt hidden biases\\n partial_J_b_h = np.dot( ones_h, delta_h)\\n\\n return partial_J_w_ih, partial_J_w_ho, partial_J_b_h, partial_J_b_o\",\n \"def getGradients(T,x,y):\\n\\n # These are place holders, you will overwrite them in your code.\\n dummy = torch.zeros(3,4)\\n Tx = dummy\\n Ty = dummy\\n\\n # TODO: your code here to compute Tx, Ty\\n \\n return Tx, Ty\",\n \"def compute_grad(W, x, y, loss_c, config):\\n\\n # Lazy import of propper model\\n if config.model_type == \\\"linear_svm\\\":\\n from utils.linear_svm import model_grad\\n elif config.model_type == \\\"logistic_regression\\\":\\n from utils.logistic_regression import model_grad\\n else:\\n raise ValueError(\\\"Wrong model type {}\\\".format(\\n config.model_type))\\n\\n dW, db = model_grad(loss_c, x, y)\\n dW += config.reg_lambda * l2_grad(W)\\n\\n return dW, db\",\n \"def compute_gradient(self, function, arguments):\",\n \"def compute_cost(n: int,\\n lam: float,\\n dE: float,\\n L: int,\\n Lxi: int,\\n chi: int,\\n beta: int,\\n stps: int,\\n verbose: bool = False) -> Tuple[int, int, int]:\\n\\n # The number of bits used for the second register.\\n nxi = np.ceil(np.log2(n // 2))\\n\\n # The number of bits for the contiguous register.\\n nLxi = np.ceil(np.log2(Lxi + n // 2))\\n\\n # The number of bits used for the first register.\\n nL = np.ceil(np.log2(L + 1))\\n\\n # The power of 2 that is a factor of L + 1\\n eta = power_two(L + 1)\\n\\n oh = [0] * 20\\n for p in range(20):\\n # JJG note: arccos arg may be > 1\\n v = np.round(np.power(2,p+1) / (2 * np.pi) * arccos(np.power(2,nL) /\\\\\\n np.sqrt((L + 1)/2**eta)/2))\\n oh[p] = np.real(stps * (1 / (np.sin(3 * arcsin(np.cos(v * 2 * np.pi / \\\\\\n np.power(2,p+1)) * \\\\\\n np.sqrt((L + 1)/2**eta) / np.power(2,nL)))**2) - 1) + 4 * (p + 1))\\n\\n # Bits of precision for rotation\\n br = int(np.argmin(oh) + 1)\\n\\n # The following costs are from the list starting on page 50.\\n\\n # The cost for preparing an equal superposition for preparing the first\\n # register in step 1 (a). We double this cost to account for the inverse.\\n cost1a = 2 * (3 * nL + 2 * br - 3 * eta - 9)\\n\\n # The output size for the QROM for the first state preparation in Eq. (C27)\\n bp1 = nL + chi\\n\\n # The cost of the QROM for the first state preparation in step 1 (b) and\\n # its inverse.\\n cost1b = QR(L + 1, bp1)[1] + QI(L + 1)[1]\\n\\n # The cost for the inequality test, controlled swap and their inverse in\\n # steps 1 (c) and (d)\\n cost1cd = 2 * (chi + nL)\\n\\n # The total cost for preparing the first register in step 1.\\n cost1 = cost1a + cost1b + cost1cd\\n\\n # The output size for the QROM for the data to prepare the equal\\n # superposition on the second register, as given in Eq. (C29).\\n bo = nxi + nLxi + br + 1\\n\\n # This is step 2. This is the cost of outputting the data to prepare the\\n # equal superposition on the second register. We will assume it is not\\n # uncomputed, because we want to keep the offset for applying the QROM for\\n # outputting the rotations.\\n cost2 = QR(L + 1, bo)[1] + QI(L + 1)[1]\\n\\n # The number of bits for rotating the ancilla for the second preparation.\\n # We are just entering this manually because it is a typical value.\\n br = 7\\n\\n # The cost of preparing an equal superposition over the second register in\\n # a controlled way. We pay this cost 4 times.\\n cost3a = 4 * (7 * nxi + 2 * br - 6)\\n\\n # The cost of the offset to apply the QROM for state preparation on the\\n # second register.\\n cost3b = 4 * (nLxi - 1)\\n\\n bp2 = nxi + chi + 2\\n\\n # The cost of the QROMs and inverse QROMs for the state preparation, where\\n # in the first one we need + n/2 to account for the one-electron terms.\\n cost3c = QR(Lxi + n // 2, bp2)[1] + QI(Lxi + n // 2)[1] + QR(\\n Lxi, bp2)[1] + QI(Lxi)[1]\\n\\n # The inequality test and state preparations.\\n cost3d = 4 * (nxi + chi)\\n\\n # The total costs for state preparations on register 2.\\n cost3 = cost3a + cost3b + cost3c + cost3d\\n\\n # The cost of adding offsets in steps 4 (a) and (h).\\n cost4ah = 4 * (nLxi - 1)\\n\\n # The costs of the QROMs and their inverses in steps 4 (b) and (g).\\n cost4bg = QR(Lxi + n // 2, n * beta // 2)[1] + QI(Lxi + n // 2)[1] + QR(\\n Lxi, n * beta // 2)[1] + QI(Lxi)[1]\\n\\n # The cost of the controlled swaps based on the spin qubit in steps 4c and f\\n cost4cf = 2 * n\\n\\n # The controlled rotations in steps 4 (d) and (f).\\n cost4df = 4 * n * (beta - 2)\\n\\n # The controlled Z operations in the middle for step 4 (e).\\n cost4e = 3\\n\\n # This is the cost of the controlled rotations for step 4.\\n cost4 = cost4ah + cost4bg + cost4cf + cost4df + cost4e\\n\\n # This is the cost of the reflection on the second register from step 6.\\n cost6 = nxi + chi + 2\\n\\n # The cost of the final reflection req'd to construct the step of the\\n # quantum walk from step 9.\\n cost9 = nL + nxi + chi + 1\\n\\n # The extra two qubits for unary iteration and making the rflxn controlled.\\n cost10 = 2\\n\\n # The Toffoli cost for a single step\\n cost = cost1 + cost2 + cost3 + cost4 + cost6 + cost9 + cost10\\n\\n # The number of steps needed\\n iters = np.ceil(np.pi * lam / (2 * dE))\\n\\n # Now the number of qubits from the list on page 54.\\n\\n k1 = np.power(2, QR(Lxi + n // 2, n * beta // 2)[0])\\n\\n # The control register for phase estimation and iteration on it.\\n ac1 = np.ceil(np.log2(iters + 1)) * 2 - 1\\n\\n # The system qubits\\n ac2 = n\\n\\n # The first register prepared, a rotated qubit and a flag qubit.\\n ac3 = nL + 2\\n\\n # The output of the QROM, the equal superposition state and a flag qubit.\\n ac4 = nL + chi * 2 + 1\\n\\n # The data used for preparing the equal superposition state on the 2nd reg\\n ac5 = bo\\n\\n # The second register, a rotated qubit and a flag qubit.\\n ac6 = nxi + 2\\n\\n # The second preparation QROM output.\\n ac8 = bp2\\n\\n # The equal superposition state and the result of the inequality test.\\n ac9 = chi + 1\\n\\n # The angles for rotations.\\n ac10 = k1 * n * beta // 2\\n\\n # The phase gradient state.\\n ac11 = beta\\n\\n # A control qubit for the spin.\\n ac12 = 1\\n\\n # A T state.\\n ac13 = 1\\n\\n if verbose:\\n print(\\\"[*] Top of routine\\\")\\n print(\\\" [+] nxi = \\\", nxi)\\n print(\\\" [+] nLxi = \\\", nLxi)\\n print(\\\" [+] nL = \\\", nL)\\n print(\\\" [+] eta = \\\", eta)\\n print(\\\" [+] cost3 = \\\", cost3)\\n print(\\\" [+] cost4 = \\\", cost4)\\n print(\\\" [+] cost = \\\", cost)\\n print(\\\" [+] iters = \\\", iters)\\n\\n ancilla_cost = ac1 + ac2 + ac3 + ac4 + ac5 + ac6 + ac8 + ac9 + ac10 + ac11\\\\\\n + ac12 + ac13\\n\\n # Sanity checks before returning as int\\n assert cost.is_integer()\\n assert iters.is_integer()\\n assert ancilla_cost.is_integer()\\n\\n step_cost = int(cost)\\n total_cost = int(cost * iters)\\n ancilla_cost = int(ancilla_cost)\\n\\n return step_cost, total_cost, ancilla_cost\",\n \"def costFunction(theta, X, y):\\n\\n # Initialize some useful values\\n m = y.size # number of training examples\\n J = np.sum(np.array([inner(theta, xi, yi) for xi, yi in zip(X, y)]))\\n J /= m\\n\\n\\n return J\",\n \"def backprop(self, x, y):\\n\\n ### YOUR CODE HERE\\n nabla_output = np.zeros(self.params['nh'])\\n del1 = self.aout - y\\n nabla_output = del1 * self.ahidden\\n #print (nabla_output)\\n a1 = del1 * self.w_output\\n a2 = np.multiply(self.ahidden, (1-self.ahidden))\\n del2 = np.zeros(self.params['nh'])\\n for i in range(0, self.params['nh']):\\n del2[i] = self.w_output[i]* del1 * self.ahidden[i]*(1-self.ahidden[i])\\n # del2 = np.multiply(a1,a2)\\n # nabla_input = np.multiply(del2, x)\\n nabla_input = np.zeros([x.shape[0],self.params['nh']])\\n for i in range (0, x.shape[0]):\\n for j in range(0, self.params['nh']):\\n nabla_input[i][j] = x[i]*del2[j]\\n #nabla_input = np.dot(x, np.transpose(del2))\\n ### END YOUR CODE\\n\\n assert nabla_input.shape == self.w_input.shape\\n assert nabla_output.shape == self.w_output.shape\\n return (nabla_input, nabla_output)\",\n \"def gradient_calculation(self, coefficients, x_values, y_values):\\n gradient_coeffs = np.array([0]*len(coefficients))\\n\\n for xi in range(len(x_values)):\\n x = x_values[xi]\\n power_array = np.power(\\n np.array([x]*len(coefficients)), np.array(range(len(coefficients))))\\n\\n diff = (2/len(x_values))*(self.f(x, coefficients) - y_values[xi])\\n gradient_coeffs = gradient_coeffs + np.multiply(diff, power_array)\\n\\n return gradient_coeffs\",\n \"def compute_gradients(self, logits, target):\\n\\n target_length = target.shape[0]\\n num_time_steps = logits.shape[0]\\n\\n\\t\\t######################\\n\\t\\t### YOUR CODE HERE ###\\n\\t\\t######################\\n\\n # expand labels by inserting a blank between each pair\\n normalized_logits = softmax(logits)\\n blank_label = normalized_logits.shape[1] - 1\\n l = add_blanks(target, blank_label)\\n target_length = l.shape[0]\\n\\n alpha = self.compute_forward_variables(normalized_logits, target) \\n beta = self.compute_backward_variables(normalized_logits, target)\\n\\n # rescale\\n alpha = alpha / np.sum(alpha, axis=0)\\n beta = beta / np.sum(beta, axis=0)\\n alphabeta = alpha * beta\\n print \\\"alpha\\\"\\n print alpha\\n\\n # compute zt\\n z = Counter()\\n for t in xrange(num_time_steps):\\n for s, k in enumerate(l):\\n z[t] += alphabeta[s, t] / normalized_logits[t, k]\\n \\n # normalized_logits is time steps t by labels k\\n # alpha is 2 * target_length - 1 by time steps\\n lab_zk = np.zeros_like(normalized_logits)\\n for s, k in enumerate(l):\\n for t in xrange(num_time_steps):\\n lab_zk[t, k] += alphabeta[s, t]\\n\\n grad = normalized_logits\\n for k in xrange(target.shape[0]):\\n for t in xrange(num_time_steps):\\n ytk = normalized_logits[t, k]\\n constant = 1.0 / (ytk * z[t])\\n grad[t, k] = ytk - constant * lab_zk[t, k]\\n \\n return grad\",\n \"def activate(self, inputs: Tuple[float, ...]) -> Tuple[float, ...]:\\n self.z = [Math.dot(self.w[i], inputs) + self.b[i]\\n for i in range(len(self.w))]\\n self.a = [self.g(real) for real in self.z]\\n return tuple(self.a)\",\n \"def propagate(w, b, X, Y):\\n\\n m = X.shape[1];\\n\\n # A.shape should be (1, m), m -- number of training examples\\n A = sigmoid(np.dot(w.T, X) + b);\\n # print(\\\"A = \\\" +str(A))\\n\\n # single training exmaple cost = - (y * log(A) + (1-y) * log(1-A))\\n # cost = (-1/m) * (np.dot(Y, np.log(A).T) + np.dot((1-Y), np.log(1-A).T));\\n cost = (-1/m)*(np.dot(Y, np.log(A).T) + np.dot((1-Y), np.log(1-A).T));\\n # print(\\\"cost in function: \\\" +str(cost))\\n\\n # Backward propagation \\n dw = (1/m) * np.dot(X, (A - Y).T)\\n # np.sum() : axis = 0 means along the column and axis = 1 means working along the row.\\n db = (1/m) * ((A - Y).sum(1))\\n\\n # dw.shape should be (num_px * nump_px * 3, 1), db should be a scalar\\n assert(dw.shape == w.shape)\\n assert(db.dtype == float)\\n\\n # np.squeeze(arr) -- remove one dimentional entry from the shape of given array. \\n # -- arr: input array\\n cost = np.squeeze(cost)\\n assert(cost.shape == ())\\n \\n grads = {\\\"dw\\\": dw, \\\"db\\\": db}\\n \\n return grads, cost\",\n \"def compute_cost(Y, Y_hat):\\n m = Y.shape[1]\\n\\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\\n\\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\\n\\n return cost, dY_hat\",\n \"def compute_cost(Y, Y_hat):\\n m = Y.shape[1]\\n\\n cost = (1 / (2 * m)) * np.sum(np.square(Y - Y_hat))\\n cost = np.squeeze(cost) # remove extraneous dimensions to give just a scalar\\n\\n dY_hat = -1 / m * (Y - Y_hat) # derivative of the squared error cost function\\n\\n return cost, dY_hat\",\n \"def get_gradient(self, output_name=None):\\n \\n return array([self.gradient[wrt][output_name] for wrt in self.param_names])\",\n \"def ComputeGradsNumSlow(X, Y, P, W, b, lamda, h):\\n\\tno \\t= \\tW.shape[0]\\n\\td \\t= \\tX.shape[0]\\n\\n\\tgrad_W = np.zeros(W.shape);\\n\\tgrad_b = np.zeros((no, 1));\\n\\t\\n\\tfor i in range(len(b)):\\n\\t\\tb_try = b\\n\\t\\tb_try[i] -= h\\n\\t\\tc1 = ComputeCost(X, Y, W, b_try, lamda)\\n\\n\\t\\tb_try = b\\n\\t\\tb_try[i] += h\\n\\t\\tc2 = ComputeCost(X, Y, W, b_try, lamda)\\n\\n\\t\\tgrad_b[i] = (c2-c1) / (2*h)\\n\\n\\tfor i in range(W.shape[0]):\\n\\t\\tfor j in range(W.shape[1]):\\n\\t\\t\\tW_try = W\\n\\t\\t\\tW_try[i,j] -= h\\n\\t\\t\\tc1 = ComputeCost(X, Y, W_try, b, lamda)\\n\\n\\t\\t\\tW_try = W\\n\\t\\t\\tW_try[i,j] += h\\n\\t\\t\\tc2 = ComputeCost(X, Y, W_try, b, lamda)\\n\\n\\t\\t\\tgrad_W[i,j] = (c2-c1) / (2*h)\\n\\n\\treturn [grad_W, grad_b]\",\n \"def grad(self, inputs, cost_grad):\\r\\n a = inputs[0]\\r\\n n = inputs[1]\\r\\n axis = inputs[2]\\r\\n grad = cost_grad[0]\\r\\n if not isinstance(axis, tensor.TensorConstant):\\r\\n raise NotImplementedError('%s: gradient is currently implemented'\\r\\n ' only for axis being a Theano constant'\\r\\n % self.__class__.__name__)\\r\\n axis = int(axis.data)\\r\\n # notice that the number of actual elements in wrto is independent of\\r\\n # possible padding or truncation:\\r\\n elem = tensor.arange(0, tensor.shape(a)[axis], 1)\\r\\n # accounts for padding:\\r\\n freq = tensor.arange(0, n, 1)\\r\\n outer = tensor.outer(freq, elem)\\r\\n pow_outer = tensor.exp(((-2 * math.pi * 1j) * outer) / (1. * n))\\r\\n res = tensor.tensordot(grad, pow_outer, (axis, 0))\\r\\n\\r\\n # This would be simpler but not implemented by theano:\\r\\n # res = tensor.switch(tensor.lt(n, tensor.shape(a)[axis]),\\r\\n # tensor.set_subtensor(res[...,n::], 0, False, False), res)\\r\\n\\r\\n # Instead we resort to that to account for truncation:\\r\\n flip_shape = list(numpy.arange(0, a.ndim)[::-1])\\r\\n res = res.dimshuffle(flip_shape)\\r\\n res = tensor.switch(tensor.lt(n, tensor.shape(a)[axis]),\\r\\n tensor.set_subtensor(res[n::, ], 0, False, False), res)\\r\\n res = res.dimshuffle(flip_shape)\\r\\n\\r\\n # insures that gradient shape conforms to input shape:\\r\\n out_shape = list(numpy.arange(0, axis)) + [a.ndim - 1] +\\\\\\r\\n list(numpy.arange(axis, a.ndim - 1))\\r\\n res = res.dimshuffle(*out_shape)\\r\\n return [res, None, None]\",\n \"def objective_grad(self, wb, X, y):\\n N, D = X.shape\\n w = wb[:-1]\\n b = wb[-1]\\n loss_grad = np.zeros(D+1) \\n # grad wrt regularization\\n loss_grad[-1] = 2 * self.reg_param * (b - self.b0) # grad_b\\n loss_grad[:-1] = 2 * self.reg_param * (w - self.w0) # grad_w\\n\\n for i in range(N):\\n tmpvar = np.exp(-1 * y[i] * (np.dot(w, X[i]) + b)) \\n loss_grad[-1] += tmpvar/(1 + tmpvar) * -1 * y[i] # grad_b \\n loss_grad[:-1] += tmpvar/(1 + tmpvar) * -1 * y[i] * X[i] # grad_w\\n\\n return loss_grad\",\n \"def compute_cost(features, values, theta):\\r\\n \\r\\n # your code here\\r\\n error = (values - features.dot(theta))\\r\\n cost = error.dot(error) \\r\\n return cost\",\n \"def compute_gradient(self): # TODO: try to change to square loss since it's hessian is easier to obtain\\n A = np.dot(self.X, self.w)\\n m = self.t.shape[0]\\n C = -1 * self.t * (1 / (1 + np.exp(A * self.t)))\\n return (1 / m) * np.dot(self.X.T, C)\",\n \"def get_cost(self, logits_list):\\n\\n cost_list = []\\n\\n for dn, logits in zip(self.find_targetnodes(), logits_list):\\n\\n if len(dn.receives_from) == 0: continue\\n _, y_ = dn.get_tensors()\\n cost_list.append(self.cost_function(y_, logits))\\n\\n return cost_list\",\n \"def calc_gradient(self, W, X, y, reg):\\n\\n N = X.shape[0]\\n grad_W = np.zeros_like(W)\\n I = np.ones((1,10))\\n score = np.dot(X, W) # (N, C)\\n out = np.exp(score-np.dot(np.max(score, axis=1, keepdims=True ),I))\\n #print(\\\"out\\\", out)\\n out /= np.sum(out, axis=1, keepdims=True) # (N, C)\\n \\n dout = np.copy(out) # (N, C)\\n dout[np.arange(N), y] -= 1\\n grad_W = np.dot(X.T, dout) # (D, C)\\n grad_W /= N\\n #grad_W += reg * W\\n \\n return grad_W\",\n \"def compute_cost(features, values, theta):\\r\\n m = len(values)\\r\\n sum_of_square_errors = numpy.square(numpy.dot(features, theta) - values).sum()\\r\\n cost = sum_of_square_errors / (2*m)\\r\\n\\r\\n return cost\",\n \"def grad(self, inputs, g_outputs):\\r\\n x, = inputs\\r\\n xi = self(x)\\r\\n gz, = g_outputs\\r\\n #TT.dot(gz.T,xi)\\r\\n return [-matrix_dot(xi, gz.T, xi).T]\",\n \"def jacobian(self, x):\\n x_ = np.atleast_2d(x)\\n if self.normalize:\\n x_ = (x_ - self.sample_mean) / self.sample_std\\n s_ = (self.samples - self.sample_mean) / self.sample_std\\n else:\\n s_ = self.samples\\n\\n fx, jf = self.reg_model(x_)\\n rx, drdx = self.corr_model(x=x_, s=s_, params=self.corr_model_params, dx=True)\\n y_grad = np.einsum('ikj,jm->ik', jf, self.beta) + np.einsum('ijk,jm->ki', drdx.T, self.gamma)\\n if self.normalize:\\n y_grad = y_grad * self.value_std / self.sample_std\\n if x_.shape[1] == 1:\\n y_grad = y_grad.flatten()\\n return y_grad\",\n \"def backprop1_5(self, x, y):\\r\\n \\r\\n nabla_b = [np.zeros(b.shape) for b in self.biases]\\r\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\r\\n # feedforward\\r\\n activation = x\\r\\n activations = [x] # list to store all the activations, layer by layer\\r\\n zs = [] # list to store all the z vectors, layer by layer\\r\\n for b, w in list(zip(self.biases, self.weights))[:len(self.biases)-1]:\\r\\n z = np.dot(w, activation)+b\\r\\n zs.append(z)\\r\\n activation = sigmoid(z)\\r\\n activations.append(activation)\\r\\n\\r\\n b = self.biases[-1]\\r\\n w = self.weights[-1]\\r\\n z = np.dot(w, activation)+b\\r\\n zs.append(z)\\r\\n activation = softmax(z)\\r\\n activations.append(activation)\\r\\n\\r\\n # backward pass\\r\\n delta = self.cost_derivative(activations[-1], y)\\r\\n\\r\\n nabla_b[-1] = delta\\r\\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\\r\\n # Note about the variable l: Here,\\r\\n # l = 1 means the last layer of neurons, l = 2 is the\\r\\n # second-last layer, and so on. This numbering takes advantage of the fact\\r\\n # that Python can use negative indices in lists.\\r\\n for l in range(2, self.num_layers):\\r\\n z = zs[-l]\\r\\n sp = sigmoid_prime(z)\\r\\n delta = np.dot(self.weights[-l+1].transpose(), delta) * sp\\r\\n nabla_b[-l] = delta\\r\\n nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())\\r\\n return (nabla_b, nabla_w)\",\n \"def _ci_grads(preds, dtrain):\\n # predictions: np.array with shape of (n, )\\n n = preds.shape[0]\\n y_hat = preds\\n\\n # labels: np.array with shape of (n, )\\n labels = dtrain.get_label().astype('int')\\n E = (labels > 0).astype('int')\\n T = np.abs(labels)\\n\\n # L2 Gradient Computation (Concordance Index Approximation)\\n # gradients computation of numerator and denominator in L2\\n # initialization\\n num, den = .0, .0\\n grad_den = np.zeros_like(y_hat)\\n hess_den = np.zeros_like(y_hat) # 0\\n grad_num = np.zeros_like(y_hat)\\n hess_num = np.zeros_like(y_hat)\\n\\n # firstly, compute gradients of numerator(\\\\alpha) and denominator(\\\\beta) in L2\\n for k in np.arange(n):\\n ## gradients of denominator (\\\\beta)\\n # For set s1 (i.e. \\\\omega 1 in the paper)\\n # s1 = (k, i): E_k = 1 and T_k < T_i\\n s1 = E[k] * np.sum(T > T[k])\\n # For set s2 (i.e. \\\\omega 2 in the paper)\\n # s2 = (i, k): E_i = 1 and T_i < T_k\\n s2 = np.sum((E > 0) * (T < T[k]))\\n # For grad_den (i.e. the first-order gradient of denominator)\\n grad_den[k] = s2 - s1\\n # hess_den[k] = 0\\n\\n ## gradients of numerator (\\\\alpha)\\n\\n # set S1\\n # i.e. the first-order and second-order gradients related to set s1\\n # s1 = (k, i): E_k = 1 and T_k < T_i\\n g_s1, h_s1 = .0, .0\\n if E[k] == 1:\\n w = y_hat[k] - y_hat[T[k] < T]\\n # For den and num\\n den += np.sum(-w)\\n num += np.sum((w < _GAMMA) * (-w) * (_GAMMA - w)**2)\\n\\n g_s1 = np.sum((w < _GAMMA) * (_GAMMA - w) * (3*w - _GAMMA))\\n\\n h_s1 = np.sum((w < _GAMMA) * (4*_GAMMA - 6*w))\\n \\n # set S2\\n # i.e. the first-order and second-order gradients related to set s2\\n w = y_hat[(E > 0) * (T < T[k])] - y_hat[k]\\n g_s2 = np.sum((w < _GAMMA) * (_GAMMA - w) * (_GAMMA - 3*w))\\n h_s2 = np.sum((w < _GAMMA) * (4*_GAMMA - 6*w))\\n \\n grad_num[k] = g_s2 + g_s1\\n hess_num[k] = h_s2 + h_s1\\n\\n if den == 0:\\n grad_f = np.zeros_like(y_hat)\\n hess_f = np.zeros_like(y_hat)\\n else:\\n grad_f = grad_num / den - num * grad_den / (den ** 2)\\n hess_f = (den * hess_num - num * hess_den) / (den ** 2) - 2 * grad_den / den * grad_f\\n \\n return grad_f, hess_f\",\n \"def blrObjFunction(params, *args):\\r\\n train_data, labeli = args\\r\\n \\r\\n n_data = train_data.shape[0];\\r\\n n_feature = train_data.shape[1];\\r\\n error = 0;\\r\\n error_grad = np.zeros((n_feature+1,1));\\r\\n \\r\\n ##################\\r\\n # YOUR CODE HERE #\\r\\n ##################\\r\\n \\r\\n # Step-1: Compute yn\\r\\n w = params.reshape((n_feature+1, 1))\\r\\n wt = w.transpose();\\r\\n xn = train_data;\\r\\n xn_with_bias = np.array([])\\r\\n xn_with_bias_list = [] \\r\\n for x in range (0, n_data):\\r\\n xn_with_bias_list.append(np.append ([1], xn[x]))\\r\\n xn_with_bias = np.vstack(xn_with_bias_list)\\r\\n yn = sigmoid(np.dot (xn_with_bias, w));\\r\\n \\r\\n # Step-2: Compute Error\\r\\n tn = labeli;\\r\\n sum1 = tn * np.log (yn);\\r\\n sum2 = (1-tn) * np.log ((1- yn));\\r\\n errorr = 0\\r\\n for i in range (0, n_data):\\r\\n errorr = errorr + sum1[i] + sum2[i];\\r\\n errorr = -1 * errorr;\\r\\n error = errorr[0] \\r\\n \\r\\n # Step-3: Compute Error gradient\\r\\n yn_minus_tn = yn - tn;\\r\\n xn_with_bias\\r\\n error_grad = np.dot(xn_with_bias.transpose(), yn_minus_tn);\\r\\n error_grad = np.squeeze(np.asarray(error_grad));\\r\\n print (error)\\r\\n return error, error_grad\",\n \"def get_gradient(self, batch_y, batch_x, weight):\\n N = batch_y.shape[0]\\n grad = np.empty(len(weight))\\n for index in range(N):\\n _y = batch_y[index]\\n _x = batch_x[index]\\n grad = grad + gradient_least_square(_y, _x, weight, self.loss_function_name)\\n grad /= N\\n grad += self.regularizer.get_gradient(weight)\\n return grad\",\n \"def backprop(self, x, y):\\n nabla_b = [np.zeros(b.shape) for b in self.biases]\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\n # feedforward\\n activation = x\\n activations = [x] # list to store all the activations, layer by layer\\n zs = [] # list to store all the z vectors, layer by layer\\n for b, w in zip(self.biases, self.weights):\\n z = np.dot(w, activation)+b\\n zs.append(z)\\n activation = sigmoid(z)\\n activations.append(activation)\\n # backward pass\\n delta = (self.cost).delta(zs[-1], activations[-1], y)\\n nabla_b[-1] = delta\\n nabla_w[-1] = np.dot(delta, activations[-2].transpose())\\n # Note that the variable l in the loop below is used a little\\n # differently to the notation in Chapter 2 of the book. Here,\\n # l = 1 means the last layer of neurons, l = 2 is the\\n # second-last layer, and so on. It's a renumbering of the\\n # scheme in the book, used here to take advantage of the fact\\n # that Python can use negative indices in lists.\\n for l in xrange(2, self.num_layers):\\n z = zs[-l]\\n sp = sigmoid_prime(z)\\n delta = np.dot(self.weights[-l+1].transpose(), delta) * sp\\n nabla_b[-l] = delta\\n nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())\\n return (nabla_b, nabla_w)\",\n \"def gradient(self, node, output_grad):\\r\\n #return [output_grad]\\r\\n return [broadcast_to(output_grad,get_shape_op(node.inputs[0]),node.const_attr)]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6407299","0.6327713","0.6275338","0.6226583","0.6159513","0.60856426","0.6059724","0.6057005","0.60185087","0.6004246","0.5938753","0.5938481","0.5900218","0.58863527","0.5880659","0.5858331","0.57814264","0.5776528","0.5766199","0.5753891","0.5751687","0.57509255","0.5746241","0.57312113","0.5724589","0.5719326","0.5717682","0.57039374","0.5694547","0.5685932","0.5682278","0.56730986","0.56562173","0.564476","0.56432116","0.56428033","0.5637313","0.56285846","0.562746","0.56261724","0.5622287","0.5615422","0.5614921","0.5606696","0.5606368","0.5602047","0.55914026","0.55850524","0.55840254","0.55623686","0.55582964","0.5554853","0.5554077","0.5545381","0.55452204","0.5539961","0.5539394","0.55374914","0.55343246","0.55330247","0.5532268","0.5531576","0.5529567","0.55256975","0.5525222","0.5522798","0.5521447","0.5517223","0.5501316","0.5497924","0.54971135","0.5496513","0.54934096","0.54909587","0.54874533","0.5487331","0.5483707","0.5482472","0.5482192","0.5478403","0.5476557","0.547365","0.54705876","0.54705876","0.54699403","0.54699206","0.54635304","0.54635054","0.5460281","0.5454325","0.5451022","0.5450379","0.54459995","0.5432703","0.54291207","0.5425678","0.54254997","0.5424653","0.542185","0.541904","0.54146236"],"string":"[\n \"0.6407299\",\n \"0.6327713\",\n \"0.6275338\",\n \"0.6226583\",\n \"0.6159513\",\n \"0.60856426\",\n \"0.6059724\",\n \"0.6057005\",\n \"0.60185087\",\n \"0.6004246\",\n \"0.5938753\",\n \"0.5938481\",\n \"0.5900218\",\n \"0.58863527\",\n \"0.5880659\",\n \"0.5858331\",\n \"0.57814264\",\n \"0.5776528\",\n \"0.5766199\",\n \"0.5753891\",\n \"0.5751687\",\n \"0.57509255\",\n \"0.5746241\",\n \"0.57312113\",\n \"0.5724589\",\n \"0.5719326\",\n \"0.5717682\",\n \"0.57039374\",\n \"0.5694547\",\n \"0.5685932\",\n \"0.5682278\",\n \"0.56730986\",\n \"0.56562173\",\n \"0.564476\",\n \"0.56432116\",\n \"0.56428033\",\n \"0.5637313\",\n \"0.56285846\",\n \"0.562746\",\n \"0.56261724\",\n \"0.5622287\",\n \"0.5615422\",\n \"0.5614921\",\n \"0.5606696\",\n \"0.5606368\",\n \"0.5602047\",\n \"0.55914026\",\n \"0.55850524\",\n \"0.55840254\",\n \"0.55623686\",\n \"0.55582964\",\n \"0.5554853\",\n \"0.5554077\",\n \"0.5545381\",\n \"0.55452204\",\n \"0.5539961\",\n \"0.5539394\",\n \"0.55374914\",\n \"0.55343246\",\n \"0.55330247\",\n \"0.5532268\",\n \"0.5531576\",\n \"0.5529567\",\n \"0.55256975\",\n \"0.5525222\",\n \"0.5522798\",\n \"0.5521447\",\n \"0.5517223\",\n \"0.5501316\",\n \"0.5497924\",\n \"0.54971135\",\n \"0.5496513\",\n \"0.54934096\",\n \"0.54909587\",\n \"0.54874533\",\n \"0.5487331\",\n \"0.5483707\",\n \"0.5482472\",\n \"0.5482192\",\n \"0.5478403\",\n \"0.5476557\",\n \"0.547365\",\n \"0.54705876\",\n \"0.54705876\",\n \"0.54699403\",\n \"0.54699206\",\n \"0.54635304\",\n \"0.54635054\",\n \"0.5460281\",\n \"0.5454325\",\n \"0.5451022\",\n \"0.5450379\",\n \"0.54459995\",\n \"0.5432703\",\n \"0.54291207\",\n \"0.5425678\",\n \"0.54254997\",\n \"0.5424653\",\n \"0.542185\",\n \"0.541904\",\n \"0.54146236\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":80996,"cells":{"query":{"kind":"string","value":"Return the number of test inputs for which the neural network outputs the correct result. Note that the neural network's output is assumed to be the index of whichever neuron in the final layer has the highest activation."},"document":{"kind":"string","value":"def evaluate(self, test_data):\n test_results = [(np.argmax(self.feed_forward(x)), y) for (x, y) in test_data]\n return sum(int(x == y) for (x, y) in test_results)"},"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 test_network(neural_network, test_data):\n total_trials = 0\n correct_trials = 0\n output_values = [np.argmax(neural_network.calculate_output(vector[1])) for vector in test_data]\n expected_values = list(zip(*test_data))[0]\n for expected, recieved in zip(expected_values,output_values):\n total_trials += 1\n if expected == recieved:\n correct_trials+=1\n return correct_trials/total_trials","def get_number_of_testing(self):\n return self.n_test","def n_test(self):\n return self.factors[1].shape[0]","def n_outputs(self):\n return len(self._output_labels)","def n_outputs(self):\n return len(self._output_labels)","def size_out(self):\n if isinstance(self.ensemble.neuron_type, Direct):\n # This will prevent users from connecting/probing Direct neurons\n # (since there aren't actually any neurons being simulated).\n return 0\n return self.ensemble.n_neurons","def predict(self, test_data):\n count = 0.0\n for testcase in test_data:\n answer = np.argmax(testcase[1])\n prediction = np.argmax(self.feed_forward(testcase[0]))\n count = count + 1 if (answer - prediction) == 0 else count\n return count","def n_outputs(self):\n return self.__n_outputs","def test(self, data_set):\r\n\r\n correct = 0.0\r\n total = 0.0\r\n\r\n for input, target in data_set:\r\n #actual output from neural net\r\n output = self.predict(input)\r\n total += 1.0 #number of total output vectors\r\n\r\n if allclose(output, target, self.converge) == True:\r\n correct += 1.0\r\n\r\n return correct/total","def n_inputs(self):\n return self.__n_inputs","def get_num_outputs(self):\n return len(self.outputs)","def n_outputs(self):\n return len(self.output_names())","def n_inputs(self):\n return len(self.input_names())","def n_inputs(self):\n return len(self._input_labels)","def n_inputs(self):\n return len(self._input_labels)","def num_training_examples(self):","def neural_result(self, input):\n n_output = self.network.activate(input)\n if n_output >= 0.5:\n return 2\n else:\n return 1","def nInputs(self):\n\n\t\treturn self._nInputs","def compute_number_error(output_one_hot, target_one_hot):\n output = output_one_hot.argmax(dim=1)\n target = target_one_hot.argmax(dim=1)\n nb_of_error = (output != target).sum()\n return nb_of_error","def get_num_inputs(self):\n return len(self.inputs)","def inputs_count(self):\n return len(self._input_nodes_map.keys())","def evaluate(self, test_data):\n test_results = [(np.argmax(self.feedforward(x)), np.argmax(y)) #argmax 返回最大数的索引\n for (x, y) in test_data]\n return sum(int(x == y) for (x, y) in test_results)","def _expected_inputs():\n return 3","def evaluate(self, test_data):\r\n test_results = [(np.argmax(self.feedforward(x)), y)\r\n for (x, y) in test_data]\r\n #print(self.feedforward(test_data[0][0]))\r\n #print(test_data[0][1])\r\n return sum(int(x == y) for (x, y) in test_results)","def evaluate(self, test_data):\n test_results = [(np.argmax(self.feed_forward(x)), y)\n for (x, y) in test_data]\n return sum(int(x == y) for (x, y) in test_results)","def n_rounds(self) -> int:\n return self.y.shape[0]","def outputs_count(self):\n return len(self._output_nodes_map.keys())","def get_number_of_training(self):\n return self.n_train","def size_in(self):\n if isinstance(self.ensemble.neuron_type, Direct):\n # This will prevent users from connecting/probing Direct neurons\n # (since there aren't actually any neurons being simulated).\n return 0\n return self.ensemble.n_neurons","def getNeuronCount(self):\n\t\treturn self.loader.getNeuronCount()","def nOutputs(self):\n\n\t\treturn self._nOutputs","def num_feature_outputs(self):\n pass","def _calculateIterations(self):\n #iterations = self.nb_images/self.batchsize\n imgs = self.protofile.nb_test()\n batch = self.protofile.batch_test()\n iterations = imgs/batch\n if imgs % batch != 0:\n iterations += 1\n return iterations","def get_num_measured_outputs(self):\n i = 0\n for o in self.outputs:\n if o.is_measured_output():\n i += 1\n return i","def _expected_inputs():\n return 1","def __len__(self):\n return len(self.train) + len(self.val) + len(self.test)","def get_num_of_output_tensors(self):\n return self._engine.get_num_of_output_tensors()","def evaluate1_6(self, test_data):\r\n test_results = [(np.argmax(self.feedforward1_6(x)), y)\r\n for (x, y) in test_data]\r\n #print(self.feedforward(test_data[0][0]))\r\n #print(test_data[0][1])\r\n return sum(int(x == y) for (x, y) in test_results)","def num_prunable_parameters(self) -> int:\n return sum(l.weight.numel() for l in self.out_layers) + \\\n sum(weight.numel() for weight in self.out_projs)","def num_prunable_parameters(self) -> int:\n return sum(l.weight.numel() for l in self.out_layers) + \\\n sum(weight.numel() for weight in self.out_projs)","def test_nn_predicts_accurate_results(self):\n self.nn.train_nn(self.X_train, self.y_train, 6, 10, 0.06)\n accuracy = 0\n X_test, y_test = load_data(\"../data/testdata.mat.tar.gz\")\n for i in range(len(X_test[:100])):\n out = self.nn.forward_prop(X_test[i])[0][-1]\n if np.argmax(out) == np.where(y_test[i])[0][0]:\n accuracy += 1\n else:\n print(\"Incorrect\", np.argmax(out))\n print(\"accuracy: \", accuracy)\n self.assertGreaterEqual(accuracy, 70)","def evaluate(self,test_data):\n test_results = [(np.argmax(self.feedforward(x)), y)\n for (x, y) in test_data]\n return sum(int(x == y) for (x, y) in test_results)","def n_ins(self):\n return np.max([[input.n_ins for input in c_set.inputs]\n for c_set in self.configuration_sets])","def test(xtest, ytest, neural_net):\n loss, accuracy = neural_net.evaluate(xtest, ytest, verbose=0)\n return accuracy","def num_feature_outputs(self):\n return 1","def num_correct_fun(preds, labels):\n assert preds.size(0) == labels.size(\n 0\n ), \"Batch dim of predictions and labels must match\"\n # Find number of correct predictions\n num_correct = (preds == labels).float().sum()\n return num_correct","def num_correct(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k)\n return res, batch_size","def test_3_bit(nn, training):\n accuracy = 0\n for example in training:\n input, target = example\n output =[round(num) for num in nn.forward_propagate(input)]\n print(input, target, output)\n for i in range(len(output)):\n if output[i] == target[i]:\n accuracy += 1\n print('Accuracy: ', accuracy/24)","def test(test_data, test_output, n_hidden_layer, n_hidden_layer_2, w1, w2, w3, bias_w1, bias_w2, bias_w3, l1, lmbda):\n # Set up initial variables\n samples = test_data.shape[0]\n correct_values = np.argmax(test_output, axis=1)\n predicted_values = np.zeros((samples,))\n error = np.zeros(test_output.shape)\n error_l1 = 0\n\n # Extract inputs\n x0 = test_data.T\n\n # Apply input weights to summation of inputs and add bias terms\n h1 = np.matmul(w1, x0) + bias_w1\n # Apply the activation function to the summation\n x1 = relu(h1)\n\n # Checks if L1 is wanted\n if l1:\n # Calculates l1 error for input layer\n error_l1 = lmbda * np.sum(np.sqrt(np.square(w1)))\n\n # Checks if hidden layer is needed\n if n_hidden_layer > 0:\n # Apply input weights to summation of inputs and add bias terms\n h2 = np.matmul(w2, x1) + bias_w2\n # Apply the activation function to the summation\n x2 = relu(h2)\n if l1:\n # Calculates l1 error for hidden layer\n error_l1 += lmbda * np.sum(np.sqrt(np.square(w2)))\n\n if n_hidden_layer_2 > 0:\n # Apply input weights to summation of inputs and add bias terms\n h3 = np.matmul(w3, x2) + bias_w3\n # Apply the activation function to the summation\n x3 = relu(h3)\n if l1:\n # Calculates l1 error for second hidden layer\n error_l1 += lmbda * np.sum(np.sqrt(np.square(w3)))\n\n # Calculate labels\n predicted_values = np.argmax(x3, axis=0)\n # Error Signal\n error = (test_output - x3.T)\n\n else:\n # Calculate labels\n predicted_values = np.argmax(x2, axis=0)\n # Error Signal\n error = (test_output - x2.T)\n\n else:\n # Calculate labels\n predicted_values = np.argmax(x1, axis=0)\n # Error Signal\n error = (test_output - x1.T)\n\n # Calculate MSE error\n error_mse = np.sum(np.square(error)) / (2 * error.shape[0])\n\n # Add MSE error to L1 error, if L1 isn't used this will add 0\n error = error_mse + error_l1\n\n # Calculate accuracy of predictions\n accuracy = (np.sum(predicted_values == correct_values) / samples) * 100\n\n print(\"Accuracy = \", accuracy)\n print(\"Error = \", error)\n return accuracy, error","def test_net(self, input_test, input_test_label):\n out = self.forward(input_test)[0]\n loss = -1*sum(input_test_label * np.log(out))\n\n return [out.argmax(),loss]","def n_train(self):\n return self.factors[0].shape[0]","def num_layers(self):\n\n return 2 + self.num_hidden_layers","def size(self):\n return self.num_inputs, self.num_outputs","def get_parameter_numbers(self) -> int:\n # TODO(jeikeilim): return the number of parameter list of each layers.\n n_param = sum([x.numel() for x in self.model.parameters()])\n return n_param","def test(self):\n self.eval()\n test_mask = self.data.test_mask\n labels = self.data.y\n output = self.forward(self.data)\n # output = self.output\n loss_test = F.nll_loss(output[test_mask], labels[test_mask])\n acc_test = utils.accuracy(output[test_mask], labels[test_mask])\n print(\"Test set results:\",\n \"loss= {:.4f}\".format(loss_test.item()),\n \"accuracy= {:.4f}\".format(acc_test.item()))\n return acc_test.item()","def evaluate(self, test_data):\n\t\ttest_results = [(np.argmax(self.feedforward(x)), y)\n\t\t\t\t\t\tfor (x, y) in test_data]\n\t\treturn sum(int(x == y) for (x, y) in test_results)","def test_n_iris(self):\r\n n = NeuronNetwork(1,\r\n [3],\r\n [[[0.2,0.2,0.2,0.2]]*3],\r\n [[-1.0,-1.0,-1.0]],learningRate=0.3)\r\n print(n)\r\n \r\n data = load_iris()\r\n\r\n inputs = data.data\r\n target = []\r\n for x in data.target:\r\n empty = [0,0,0]\r\n empty[x] = 1\r\n target.append(empty)\r\n \r\n n.train(inputs, target, 2000, 10*60)\r\n print(n)\r\n\r\n total = 0\r\n error = 0\r\n for i, x in enumerate(target, 0):\r\n out = n.feed_forward(inputs[i])\r\n if i < 50:\r\n error += self.mse(out, [1,0,0])\r\n if np.argmax(out) == 0:\r\n total +=1\r\n print(i, out, 1)\r\n elif i >= 50 and i < 100:\r\n error += self.mse(out, [0,1,0])\r\n if np.argmax(out) == 1:\r\n total +=1\r\n print(i, out, 2)\r\n elif i >= 100 and i < 150:\r\n error += self.mse(out, [0,0,1])\r\n if np.argmax(out) == 2:\r\n total +=1\r\n print(i, out, 3)\r\n\r\n print(f'MSE: {error/150}, RMSE:{math.sqrt(error/150)}')\r\n print(f'Accuracy:{total/len(target)}')","def get_num_hidden(self) -> int:\n return self.output_dim","def _n_features_out(self):\n return self.components_.shape[0]","def num_nodes(self):\n\n return self.num_input_nodes + self.num_hidden_layers * self.num_nodes_per_hidden_layer + self.num_output_nodes","def test(self):\n self.load()\n bottleneck_features = np.load(self.feature_path)\n test = bottleneck_features['test']\n _, test_targets = load_dataset(self.image_path_test) \n predictions = [np.argmax(self.model.predict(np.expand_dims(feature, axis=0))) for feature in test]\n test_accuracy = 100*np.sum(np.array(predictions) == np.argmax(test_targets, axis=1))/len(predictions)\n print('{}, test accuracy: {:.4f}%'.format(self.name, test_accuracy))\n return test_accuracy","def num_test_samples(self):\n if self._num_test_samples is None:\n for key, value in self._test_data.items():\n self._num_test_samples[key] = len(value[0])\n return self._num_test_samples","def test(model, X_test, y_test, config):\n loss, y_pred = model.forward_pass(X_test)\n\n y_maxVals = np.amax(y_pred, axis=1).reshape(-1, 1)\n y_1hot = np.where(y_maxVals == y_pred, 1, 0)\n correct = np.sum(y_test * y_1hot)\n\n accuracy = correct / len(X_test)\n return accuracy","def test_neuron(self):\r\n # crear una lista 1-D (Horizontal, Entradas).\r\n Z = [1, 2, 3]\r\n # crear una lista 1-D (Vertical, Pesos de la red).\r\n W = [10, 20, 30]\r\n # Inicializamos la neurona, y obtenemos el valor que toma dado W * Z\r\n # X(k) = W * Z\r\n result = rhonn(W, Z).predict()\r\n # Comprobamos el resultado \r\n self.assertEqual(result, 140)","def test_output_activation():\n RANDOM_ITERATIONS = 20\n input_dim = 100\n for _ in range(RANDOM_ITERATIONS):\n data = torch.randn((25, 10, 100))\n RNN_instance = RNN(layers_info=[[\"lstm\", 20], [\"gru\", 5], [\"linear\", 10], [\"linear\", 3]],\n hidden_activations=\"relu\", input_dim=input_dim,\n output_activation=\"relu\", initialiser=\"xavier\", batch_norm=True)\n out = RNN_instance.forward(data)\n assert all(out.reshape(1, -1).squeeze() >= 0)\n\n RNN_instance = RNN(layers_info=[[\"lstm\", 20], [\"gru\", 5]],\n hidden_activations=\"relu\", input_dim=input_dim,\n output_activation=\"relu\", initialiser=\"xavier\")\n out = RNN_instance.forward(data)\n assert all(out.reshape(1, -1).squeeze() >= 0)\n\n RNN_instance = RNN(layers_info=[[\"lstm\", 20], [\"gru\", 5], [\"linear\", 10], [\"linear\", 3]],\n hidden_activations=\"relu\", input_dim=input_dim,\n output_activation=\"relu\", initialiser=\"xavier\")\n out = RNN_instance.forward(data)\n assert all(out.reshape(1, -1).squeeze() >= 0)\n\n RNN_instance = RNN(layers_info=[[\"lstm\", 20], [\"gru\", 5], [\"linear\", 10], [\"linear\", 3]],\n hidden_activations=\"relu\", input_dim=input_dim,\n output_activation=\"sigmoid\", initialiser=\"xavier\")\n out = RNN_instance.forward(data)\n assert all(out.reshape(1, -1).squeeze() >= 0)\n assert all(out.reshape(1, -1).squeeze() <= 1)\n summed_result = torch.sum(out, dim=1)\n assert all(summed_result.reshape(1, -1).squeeze() != 1.0)\n\n\n RNN_instance = RNN(layers_info=[[\"lstm\", 20], [\"gru\", 5], [\"linear\", 10], [\"linear\", 3]],\n hidden_activations=\"relu\", input_dim=input_dim,\n output_activation=\"softmax\", initialiser=\"xavier\")\n out = RNN_instance.forward(data)\n assert all(out.reshape(1, -1).squeeze() >= 0)\n assert all(out.reshape(1, -1).squeeze() <= 1)\n summed_result = torch.sum(out, dim=1)\n summed_result = summed_result.reshape(1, -1).squeeze()\n summed_result = torch.round( (summed_result * 10 ** 5) / (10 ** 5))\n assert all( summed_result == 1.0)\n\n RNN_instance = RNN(layers_info=[[\"lstm\", 20], [\"gru\", 5], [\"lstm\", 25]],\n hidden_activations=\"relu\", input_dim=input_dim,\n output_activation=\"softmax\", initialiser=\"xavier\")\n out = RNN_instance.forward(data)\n assert all(out.reshape(1, -1).squeeze() >= 0)\n assert all(out.reshape(1, -1).squeeze() <= 1)\n summed_result = torch.sum(out, dim=1)\n summed_result = summed_result.reshape(1, -1).squeeze()\n summed_result = torch.round( (summed_result * 10 ** 5) / (10 ** 5))\n assert all( summed_result == 1.0)\n\n RNN_instance = RNN(layers_info=[[\"lstm\", 20], [\"gru\", 5], [\"lstm\", 25]],\n hidden_activations=\"relu\", input_dim=input_dim,\n initialiser=\"xavier\")\n out = RNN_instance.forward(data)\n assert not all(out.reshape(1, -1).squeeze() >= 0)\n\n assert not all(out.reshape(1, -1).squeeze() <= 0)\n summed_result = torch.sum(out, dim=1)\n summed_result = summed_result.reshape(1, -1).squeeze()\n summed_result = torch.round( (summed_result * 10 ** 5) / (10 ** 5))\n assert not all(summed_result == 1.0)\n\n RNN_instance = RNN(layers_info=[[\"lstm\", 20], [\"gru\", 5], [\"lstm\", 25], [\"linear\", 8]],\n hidden_activations=\"relu\", input_dim=input_dim,\n initialiser=\"xavier\")\n out = RNN_instance.forward(data)\n assert not all(out.reshape(1, -1).squeeze() >= 0)\n assert not all(out.reshape(1, -1).squeeze() <= 0)\n summed_result = torch.sum(out, dim=1)\n summed_result = summed_result.reshape(1, -1).squeeze()\n summed_result = torch.round( (summed_result * 10 ** 5) / (10 ** 5))\n assert not all( summed_result == 1.0)","def evaluate1_5(self, test_data):\r\n test_results = [(np.argmax(self.feedforward1_5(x)), y)\r\n for (x, y) in test_data]\r\n #print(self.feedforward(test_data[0][0]))\r\n #print(test_data[0][1])\r\n return sum(int(x == y) for (x, y) in test_results)","def num_outputs(cls) -> list[int]:\n return [5] * 10","def n_inputs(self):","def test_init() -> None:\n neural_net = NeuralNetwork()\n assert neural_net.model.get_layer('output_layer').output_shape, (None, 4)","def test(self, inputs, labels):\n n = inputs.shape[0]\n\n error = 0.0\n for idx in range(n):\n result = self.forward(inputs[idx:idx+1, :])\n error += abs(result - labels[idx:idx+1, :])\n\n print(\"error: \", error)\n error /= n\n print('accuracy: %.2f' % ((1 - error)*100) + '%')\n print('')","def test_size(self) -> int:\n return int(self.data_size * self.__test_fraction)","def count_weights(print_perlayer=True):\n acc_total = 0\n for v in tf.trainable_variables():\n dims = v.get_shape().as_list()\n total = np.prod(dims)\n acc_total += total\n if print_perlayer:\n print('{}: {}, {}'.format(v.name, dims, total))\n\n return acc_total","def getOutputLength(self):\n return len(self.Y[0])","def __len__(self):\n if self._train:\n return len(self._train_data)\n return len(self._test_data)","def __len__(self):\n if self._train:\n return len(self._train_data)\n return len(self._test_data)","def get_number_of_validation(self):\n return self.n_valid","def calculate_num_params(self):\n num_params = 0\n for p in self.parameters():\n num_params += p.data.view(-1).size(0)\n return num_params","def getNumOutputs(self):\n return _libsbml.Transition_getNumOutputs(self)","def get_num_eval_images(hparams):\n num_images_map = {\n 'imagenet': 50000,\n 'cifar10': 10000,\n }\n if hparams.input_data.input_fn not in num_images_map:\n raise ValueError(\n f'Unknown dataset size for input_fn {hparams.input_data.input_fn}')\n\n return num_images_map[hparams.input_data.input_fn]","def total_predict_batches(self) -> int:\n return sum(self.trainer.num_predict_batches)","def num_examples_per_epoch(self):\n\t\tif self.subset == 'train':\n\t\t\treturn 50000\n\t\tif self.subset == 'validation':\n\t\t\treturn 10000","def neural_network(X, Y, Xs_test, Ys_test):\n ## YOUR CODE HERE\n #################\n return 0","def len(self):\r\n return len(self.input), len(self.target)","def total_test_batches(self) -> int:\n return sum(self.trainer.num_test_batches)","def width_fitness(predicted, expected_output):\n return np.abs(predicted.shape[0] - expected_output.shape[0])","def test_network(self):\n train_accuracy = 100 - percentError(map(self.neural_result,\n self.train_inputs),\n self.train_outputs)\n print 'Train accuracy:', train_accuracy\n\n test_accuracy = 100 - percentError(map(self.neural_result,\n self.test_inputs),\n self.test_outputs)\n print 'Test accuracy:', test_accuracy\n\n print '#' * int(train_accuracy), 'TR'\n print '#' * int(test_accuracy), 'TE'","def evaluate(self):\n # initialize delta_weights\n Loss = 0\n for i, x_test in enumerate(self.X_test):\n Loss += (self.sigmoid(np.dot(self.weights,x_test))-self.y_test[i])**2\n return Loss","def num_params():\n total_num = 0\n for var in tf.trainable_variables():\n shape = var.get_shape()\n total_num += functools.reduce(operator.mul, [dim.value for dim in shape], 1)\n return total_num","def test(self, inputs, labels):\n n = inputs.shape[0]\n\n error = 0.0\n for idx in range(n):\n result = self.forward(inputs[idx:idx+1, :])\n error += abs(result - labels[idx:idx+1, :])\n\n error /= n\n accuracy = np.round((1 - error)*100, 3)\n self.accuracy_box.append(accuracy[0][0])\n print('accuracy: %.2f' % accuracy + '%')\n print('')","def testNN(self, nn, testLoader):\n self.nnMapping[nn].eval()\n # check if total prediction is correct\n correct = 0\n total = 0\n # check if each single prediction is correct\n singleCorrect = 0\n singleTotal = 0\n with torch.no_grad():\n for data, target in testLoader:\n output = self.nnMapping[nn](data.to(self.device))\n if target.shape == output.shape[:-1]:\n pred = output.argmax(dim=-1) # get the index of the max value\n elif target.shape == output.shape:\n pred = (output >= 0.5).int()\n else:\n print(f'Error: none considered case for output with shape {output.shape} v.s. label with shape {target.shape}')\n sys.exit()\n target = target.to(self.device).view_as(pred)\n correctionMatrix = (target.int() == pred.int()).view(target.shape[0], -1)\n correct += correctionMatrix.all(1).sum().item()\n total += target.shape[0]\n singleCorrect += correctionMatrix.sum().item()\n singleTotal += target.numel()\n\n accuracy = 100. * correct / total\n singleAccuracy = 100. * singleCorrect / singleTotal\n return accuracy, singleAccuracy","def n_actions(self) -> int:\n return np.unique(self.y).shape[0]","def get_total_input_dimension(self, layers):\n self._validate_layer_names(layers)\n total = 0\n for layer in self.layers:\n if layer.layer_name in layers:\n total += layer.get_input_space().get_total_dimension()\n return total","def test_CNN_hyperparameters_nrlayers(self):\n hyperparams = modelgen.generate_CNN_hyperparameter_set(\n min_fc_nodes=123, max_fc_nodes=123)\n assert hyperparams.get('fc_hidden_nodes') == 123","def number_of_iterations(self):\n return self._solution.nit","def nb_errors_nb(self, input_data, target):\n input_data_resize = input_data.view(2000, 1, 14, 14)\n number_output = self(input_data_resize)\n number_output = number_output.view(1000, 2, 10)\n predicted_classes = number_output.argmax(2)\n predictions = predicted_classes[:, 0] <= predicted_classes[:, 1]\n target_labels = target\n nb_errors = torch.sum(predictions.type(torch.LongTensor) != target_labels)\n return float(nb_errors) * 100 / input_data.size(0)","def evaluate(self,test_data):\r\n\t\ttest_results= [(np.argmax(self.forwardprop(x)),y) for (x,y) in test_data]\r\n\t\treturn sum(int(x==y) for (x,y) in test_results)","def test_model(net, data_loader):\n net.eval()\n true_preds, count = 0.0, 0\n for imgs, labels in data_loader:\n imgs, labels = imgs.to(device), labels.to(device)\n with torch.no_grad():\n preds = net(imgs).argmax(dim=-1)\n true_preds += (preds == labels).sum().item()\n count += labels.shape[0]\n test_acc = true_preds / count\n return test_acc","def get_valid_data_size(self):\n return len(self.pipeline.data['test'])","def get_num_hidden(self) -> int:\n return self.encoders[-1].get_num_hidden()","def get_accuracy(self) -> float:\n self.network.load_data()\n self.network.train()\n\n n = len(self.network.y_test)\n correct = 0\n for i in range(n):\n # Predict by running forward pass through the neural network\n pred = self.network.predict(self.network.x_test[i])\n # Sanity check of the prediction\n assert 0 <= pred <= 1, \"The prediction needs to be in [0, 1] range.\"\n # Check if right class is predicted\n correct += self.network.y_test[i] == round(float(pred))\n return round(correct / n, 3)"],"string":"[\n \"def test_network(neural_network, test_data):\\n total_trials = 0\\n correct_trials = 0\\n output_values = [np.argmax(neural_network.calculate_output(vector[1])) for vector in test_data]\\n expected_values = list(zip(*test_data))[0]\\n for expected, recieved in zip(expected_values,output_values):\\n total_trials += 1\\n if expected == recieved:\\n correct_trials+=1\\n return correct_trials/total_trials\",\n \"def get_number_of_testing(self):\\n return self.n_test\",\n \"def n_test(self):\\n return self.factors[1].shape[0]\",\n \"def n_outputs(self):\\n return len(self._output_labels)\",\n \"def n_outputs(self):\\n return len(self._output_labels)\",\n \"def size_out(self):\\n if isinstance(self.ensemble.neuron_type, Direct):\\n # This will prevent users from connecting/probing Direct neurons\\n # (since there aren't actually any neurons being simulated).\\n return 0\\n return self.ensemble.n_neurons\",\n \"def predict(self, test_data):\\n count = 0.0\\n for testcase in test_data:\\n answer = np.argmax(testcase[1])\\n prediction = np.argmax(self.feed_forward(testcase[0]))\\n count = count + 1 if (answer - prediction) == 0 else count\\n return count\",\n \"def n_outputs(self):\\n return self.__n_outputs\",\n \"def test(self, data_set):\\r\\n\\r\\n correct = 0.0\\r\\n total = 0.0\\r\\n\\r\\n for input, target in data_set:\\r\\n #actual output from neural net\\r\\n output = self.predict(input)\\r\\n total += 1.0 #number of total output vectors\\r\\n\\r\\n if allclose(output, target, self.converge) == True:\\r\\n correct += 1.0\\r\\n\\r\\n return correct/total\",\n \"def n_inputs(self):\\n return self.__n_inputs\",\n \"def get_num_outputs(self):\\n return len(self.outputs)\",\n \"def n_outputs(self):\\n return len(self.output_names())\",\n \"def n_inputs(self):\\n return len(self.input_names())\",\n \"def n_inputs(self):\\n return len(self._input_labels)\",\n \"def n_inputs(self):\\n return len(self._input_labels)\",\n \"def num_training_examples(self):\",\n \"def neural_result(self, input):\\n n_output = self.network.activate(input)\\n if n_output >= 0.5:\\n return 2\\n else:\\n return 1\",\n \"def nInputs(self):\\n\\n\\t\\treturn self._nInputs\",\n \"def compute_number_error(output_one_hot, target_one_hot):\\n output = output_one_hot.argmax(dim=1)\\n target = target_one_hot.argmax(dim=1)\\n nb_of_error = (output != target).sum()\\n return nb_of_error\",\n \"def get_num_inputs(self):\\n return len(self.inputs)\",\n \"def inputs_count(self):\\n return len(self._input_nodes_map.keys())\",\n \"def evaluate(self, test_data):\\n test_results = [(np.argmax(self.feedforward(x)), np.argmax(y)) #argmax 返回最大数的索引\\n for (x, y) in test_data]\\n return sum(int(x == y) for (x, y) in test_results)\",\n \"def _expected_inputs():\\n return 3\",\n \"def evaluate(self, test_data):\\r\\n test_results = [(np.argmax(self.feedforward(x)), y)\\r\\n for (x, y) in test_data]\\r\\n #print(self.feedforward(test_data[0][0]))\\r\\n #print(test_data[0][1])\\r\\n return sum(int(x == y) for (x, y) in test_results)\",\n \"def evaluate(self, test_data):\\n test_results = [(np.argmax(self.feed_forward(x)), y)\\n for (x, y) in test_data]\\n return sum(int(x == y) for (x, y) in test_results)\",\n \"def n_rounds(self) -> int:\\n return self.y.shape[0]\",\n \"def outputs_count(self):\\n return len(self._output_nodes_map.keys())\",\n \"def get_number_of_training(self):\\n return self.n_train\",\n \"def size_in(self):\\n if isinstance(self.ensemble.neuron_type, Direct):\\n # This will prevent users from connecting/probing Direct neurons\\n # (since there aren't actually any neurons being simulated).\\n return 0\\n return self.ensemble.n_neurons\",\n \"def getNeuronCount(self):\\n\\t\\treturn self.loader.getNeuronCount()\",\n \"def nOutputs(self):\\n\\n\\t\\treturn self._nOutputs\",\n \"def num_feature_outputs(self):\\n pass\",\n \"def _calculateIterations(self):\\n #iterations = self.nb_images/self.batchsize\\n imgs = self.protofile.nb_test()\\n batch = self.protofile.batch_test()\\n iterations = imgs/batch\\n if imgs % batch != 0:\\n iterations += 1\\n return iterations\",\n \"def get_num_measured_outputs(self):\\n i = 0\\n for o in self.outputs:\\n if o.is_measured_output():\\n i += 1\\n return i\",\n \"def _expected_inputs():\\n return 1\",\n \"def __len__(self):\\n return len(self.train) + len(self.val) + len(self.test)\",\n \"def get_num_of_output_tensors(self):\\n return self._engine.get_num_of_output_tensors()\",\n \"def evaluate1_6(self, test_data):\\r\\n test_results = [(np.argmax(self.feedforward1_6(x)), y)\\r\\n for (x, y) in test_data]\\r\\n #print(self.feedforward(test_data[0][0]))\\r\\n #print(test_data[0][1])\\r\\n return sum(int(x == y) for (x, y) in test_results)\",\n \"def num_prunable_parameters(self) -> int:\\n return sum(l.weight.numel() for l in self.out_layers) + \\\\\\n sum(weight.numel() for weight in self.out_projs)\",\n \"def num_prunable_parameters(self) -> int:\\n return sum(l.weight.numel() for l in self.out_layers) + \\\\\\n sum(weight.numel() for weight in self.out_projs)\",\n \"def test_nn_predicts_accurate_results(self):\\n self.nn.train_nn(self.X_train, self.y_train, 6, 10, 0.06)\\n accuracy = 0\\n X_test, y_test = load_data(\\\"../data/testdata.mat.tar.gz\\\")\\n for i in range(len(X_test[:100])):\\n out = self.nn.forward_prop(X_test[i])[0][-1]\\n if np.argmax(out) == np.where(y_test[i])[0][0]:\\n accuracy += 1\\n else:\\n print(\\\"Incorrect\\\", np.argmax(out))\\n print(\\\"accuracy: \\\", accuracy)\\n self.assertGreaterEqual(accuracy, 70)\",\n \"def evaluate(self,test_data):\\n test_results = [(np.argmax(self.feedforward(x)), y)\\n for (x, y) in test_data]\\n return sum(int(x == y) for (x, y) in test_results)\",\n \"def n_ins(self):\\n return np.max([[input.n_ins for input in c_set.inputs]\\n for c_set in self.configuration_sets])\",\n \"def test(xtest, ytest, neural_net):\\n loss, accuracy = neural_net.evaluate(xtest, ytest, verbose=0)\\n return accuracy\",\n \"def num_feature_outputs(self):\\n return 1\",\n \"def num_correct_fun(preds, labels):\\n assert preds.size(0) == labels.size(\\n 0\\n ), \\\"Batch dim of predictions and labels must match\\\"\\n # Find number of correct predictions\\n num_correct = (preds == labels).float().sum()\\n return num_correct\",\n \"def num_correct(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k)\\n return res, batch_size\",\n \"def test_3_bit(nn, training):\\n accuracy = 0\\n for example in training:\\n input, target = example\\n output =[round(num) for num in nn.forward_propagate(input)]\\n print(input, target, output)\\n for i in range(len(output)):\\n if output[i] == target[i]:\\n accuracy += 1\\n print('Accuracy: ', accuracy/24)\",\n \"def test(test_data, test_output, n_hidden_layer, n_hidden_layer_2, w1, w2, w3, bias_w1, bias_w2, bias_w3, l1, lmbda):\\n # Set up initial variables\\n samples = test_data.shape[0]\\n correct_values = np.argmax(test_output, axis=1)\\n predicted_values = np.zeros((samples,))\\n error = np.zeros(test_output.shape)\\n error_l1 = 0\\n\\n # Extract inputs\\n x0 = test_data.T\\n\\n # Apply input weights to summation of inputs and add bias terms\\n h1 = np.matmul(w1, x0) + bias_w1\\n # Apply the activation function to the summation\\n x1 = relu(h1)\\n\\n # Checks if L1 is wanted\\n if l1:\\n # Calculates l1 error for input layer\\n error_l1 = lmbda * np.sum(np.sqrt(np.square(w1)))\\n\\n # Checks if hidden layer is needed\\n if n_hidden_layer > 0:\\n # Apply input weights to summation of inputs and add bias terms\\n h2 = np.matmul(w2, x1) + bias_w2\\n # Apply the activation function to the summation\\n x2 = relu(h2)\\n if l1:\\n # Calculates l1 error for hidden layer\\n error_l1 += lmbda * np.sum(np.sqrt(np.square(w2)))\\n\\n if n_hidden_layer_2 > 0:\\n # Apply input weights to summation of inputs and add bias terms\\n h3 = np.matmul(w3, x2) + bias_w3\\n # Apply the activation function to the summation\\n x3 = relu(h3)\\n if l1:\\n # Calculates l1 error for second hidden layer\\n error_l1 += lmbda * np.sum(np.sqrt(np.square(w3)))\\n\\n # Calculate labels\\n predicted_values = np.argmax(x3, axis=0)\\n # Error Signal\\n error = (test_output - x3.T)\\n\\n else:\\n # Calculate labels\\n predicted_values = np.argmax(x2, axis=0)\\n # Error Signal\\n error = (test_output - x2.T)\\n\\n else:\\n # Calculate labels\\n predicted_values = np.argmax(x1, axis=0)\\n # Error Signal\\n error = (test_output - x1.T)\\n\\n # Calculate MSE error\\n error_mse = np.sum(np.square(error)) / (2 * error.shape[0])\\n\\n # Add MSE error to L1 error, if L1 isn't used this will add 0\\n error = error_mse + error_l1\\n\\n # Calculate accuracy of predictions\\n accuracy = (np.sum(predicted_values == correct_values) / samples) * 100\\n\\n print(\\\"Accuracy = \\\", accuracy)\\n print(\\\"Error = \\\", error)\\n return accuracy, error\",\n \"def test_net(self, input_test, input_test_label):\\n out = self.forward(input_test)[0]\\n loss = -1*sum(input_test_label * np.log(out))\\n\\n return [out.argmax(),loss]\",\n \"def n_train(self):\\n return self.factors[0].shape[0]\",\n \"def num_layers(self):\\n\\n return 2 + self.num_hidden_layers\",\n \"def size(self):\\n return self.num_inputs, self.num_outputs\",\n \"def get_parameter_numbers(self) -> int:\\n # TODO(jeikeilim): return the number of parameter list of each layers.\\n n_param = sum([x.numel() for x in self.model.parameters()])\\n return n_param\",\n \"def test(self):\\n self.eval()\\n test_mask = self.data.test_mask\\n labels = self.data.y\\n output = self.forward(self.data)\\n # output = self.output\\n loss_test = F.nll_loss(output[test_mask], labels[test_mask])\\n acc_test = utils.accuracy(output[test_mask], labels[test_mask])\\n print(\\\"Test set results:\\\",\\n \\\"loss= {:.4f}\\\".format(loss_test.item()),\\n \\\"accuracy= {:.4f}\\\".format(acc_test.item()))\\n return acc_test.item()\",\n \"def evaluate(self, test_data):\\n\\t\\ttest_results = [(np.argmax(self.feedforward(x)), y)\\n\\t\\t\\t\\t\\t\\tfor (x, y) in test_data]\\n\\t\\treturn sum(int(x == y) for (x, y) in test_results)\",\n \"def test_n_iris(self):\\r\\n n = NeuronNetwork(1,\\r\\n [3],\\r\\n [[[0.2,0.2,0.2,0.2]]*3],\\r\\n [[-1.0,-1.0,-1.0]],learningRate=0.3)\\r\\n print(n)\\r\\n \\r\\n data = load_iris()\\r\\n\\r\\n inputs = data.data\\r\\n target = []\\r\\n for x in data.target:\\r\\n empty = [0,0,0]\\r\\n empty[x] = 1\\r\\n target.append(empty)\\r\\n \\r\\n n.train(inputs, target, 2000, 10*60)\\r\\n print(n)\\r\\n\\r\\n total = 0\\r\\n error = 0\\r\\n for i, x in enumerate(target, 0):\\r\\n out = n.feed_forward(inputs[i])\\r\\n if i < 50:\\r\\n error += self.mse(out, [1,0,0])\\r\\n if np.argmax(out) == 0:\\r\\n total +=1\\r\\n print(i, out, 1)\\r\\n elif i >= 50 and i < 100:\\r\\n error += self.mse(out, [0,1,0])\\r\\n if np.argmax(out) == 1:\\r\\n total +=1\\r\\n print(i, out, 2)\\r\\n elif i >= 100 and i < 150:\\r\\n error += self.mse(out, [0,0,1])\\r\\n if np.argmax(out) == 2:\\r\\n total +=1\\r\\n print(i, out, 3)\\r\\n\\r\\n print(f'MSE: {error/150}, RMSE:{math.sqrt(error/150)}')\\r\\n print(f'Accuracy:{total/len(target)}')\",\n \"def get_num_hidden(self) -> int:\\n return self.output_dim\",\n \"def _n_features_out(self):\\n return self.components_.shape[0]\",\n \"def num_nodes(self):\\n\\n return self.num_input_nodes + self.num_hidden_layers * self.num_nodes_per_hidden_layer + self.num_output_nodes\",\n \"def test(self):\\n self.load()\\n bottleneck_features = np.load(self.feature_path)\\n test = bottleneck_features['test']\\n _, test_targets = load_dataset(self.image_path_test) \\n predictions = [np.argmax(self.model.predict(np.expand_dims(feature, axis=0))) for feature in test]\\n test_accuracy = 100*np.sum(np.array(predictions) == np.argmax(test_targets, axis=1))/len(predictions)\\n print('{}, test accuracy: {:.4f}%'.format(self.name, test_accuracy))\\n return test_accuracy\",\n \"def num_test_samples(self):\\n if self._num_test_samples is None:\\n for key, value in self._test_data.items():\\n self._num_test_samples[key] = len(value[0])\\n return self._num_test_samples\",\n \"def test(model, X_test, y_test, config):\\n loss, y_pred = model.forward_pass(X_test)\\n\\n y_maxVals = np.amax(y_pred, axis=1).reshape(-1, 1)\\n y_1hot = np.where(y_maxVals == y_pred, 1, 0)\\n correct = np.sum(y_test * y_1hot)\\n\\n accuracy = correct / len(X_test)\\n return accuracy\",\n \"def test_neuron(self):\\r\\n # crear una lista 1-D (Horizontal, Entradas).\\r\\n Z = [1, 2, 3]\\r\\n # crear una lista 1-D (Vertical, Pesos de la red).\\r\\n W = [10, 20, 30]\\r\\n # Inicializamos la neurona, y obtenemos el valor que toma dado W * Z\\r\\n # X(k) = W * Z\\r\\n result = rhonn(W, Z).predict()\\r\\n # Comprobamos el resultado \\r\\n self.assertEqual(result, 140)\",\n \"def test_output_activation():\\n RANDOM_ITERATIONS = 20\\n input_dim = 100\\n for _ in range(RANDOM_ITERATIONS):\\n data = torch.randn((25, 10, 100))\\n RNN_instance = RNN(layers_info=[[\\\"lstm\\\", 20], [\\\"gru\\\", 5], [\\\"linear\\\", 10], [\\\"linear\\\", 3]],\\n hidden_activations=\\\"relu\\\", input_dim=input_dim,\\n output_activation=\\\"relu\\\", initialiser=\\\"xavier\\\", batch_norm=True)\\n out = RNN_instance.forward(data)\\n assert all(out.reshape(1, -1).squeeze() >= 0)\\n\\n RNN_instance = RNN(layers_info=[[\\\"lstm\\\", 20], [\\\"gru\\\", 5]],\\n hidden_activations=\\\"relu\\\", input_dim=input_dim,\\n output_activation=\\\"relu\\\", initialiser=\\\"xavier\\\")\\n out = RNN_instance.forward(data)\\n assert all(out.reshape(1, -1).squeeze() >= 0)\\n\\n RNN_instance = RNN(layers_info=[[\\\"lstm\\\", 20], [\\\"gru\\\", 5], [\\\"linear\\\", 10], [\\\"linear\\\", 3]],\\n hidden_activations=\\\"relu\\\", input_dim=input_dim,\\n output_activation=\\\"relu\\\", initialiser=\\\"xavier\\\")\\n out = RNN_instance.forward(data)\\n assert all(out.reshape(1, -1).squeeze() >= 0)\\n\\n RNN_instance = RNN(layers_info=[[\\\"lstm\\\", 20], [\\\"gru\\\", 5], [\\\"linear\\\", 10], [\\\"linear\\\", 3]],\\n hidden_activations=\\\"relu\\\", input_dim=input_dim,\\n output_activation=\\\"sigmoid\\\", initialiser=\\\"xavier\\\")\\n out = RNN_instance.forward(data)\\n assert all(out.reshape(1, -1).squeeze() >= 0)\\n assert all(out.reshape(1, -1).squeeze() <= 1)\\n summed_result = torch.sum(out, dim=1)\\n assert all(summed_result.reshape(1, -1).squeeze() != 1.0)\\n\\n\\n RNN_instance = RNN(layers_info=[[\\\"lstm\\\", 20], [\\\"gru\\\", 5], [\\\"linear\\\", 10], [\\\"linear\\\", 3]],\\n hidden_activations=\\\"relu\\\", input_dim=input_dim,\\n output_activation=\\\"softmax\\\", initialiser=\\\"xavier\\\")\\n out = RNN_instance.forward(data)\\n assert all(out.reshape(1, -1).squeeze() >= 0)\\n assert all(out.reshape(1, -1).squeeze() <= 1)\\n summed_result = torch.sum(out, dim=1)\\n summed_result = summed_result.reshape(1, -1).squeeze()\\n summed_result = torch.round( (summed_result * 10 ** 5) / (10 ** 5))\\n assert all( summed_result == 1.0)\\n\\n RNN_instance = RNN(layers_info=[[\\\"lstm\\\", 20], [\\\"gru\\\", 5], [\\\"lstm\\\", 25]],\\n hidden_activations=\\\"relu\\\", input_dim=input_dim,\\n output_activation=\\\"softmax\\\", initialiser=\\\"xavier\\\")\\n out = RNN_instance.forward(data)\\n assert all(out.reshape(1, -1).squeeze() >= 0)\\n assert all(out.reshape(1, -1).squeeze() <= 1)\\n summed_result = torch.sum(out, dim=1)\\n summed_result = summed_result.reshape(1, -1).squeeze()\\n summed_result = torch.round( (summed_result * 10 ** 5) / (10 ** 5))\\n assert all( summed_result == 1.0)\\n\\n RNN_instance = RNN(layers_info=[[\\\"lstm\\\", 20], [\\\"gru\\\", 5], [\\\"lstm\\\", 25]],\\n hidden_activations=\\\"relu\\\", input_dim=input_dim,\\n initialiser=\\\"xavier\\\")\\n out = RNN_instance.forward(data)\\n assert not all(out.reshape(1, -1).squeeze() >= 0)\\n\\n assert not all(out.reshape(1, -1).squeeze() <= 0)\\n summed_result = torch.sum(out, dim=1)\\n summed_result = summed_result.reshape(1, -1).squeeze()\\n summed_result = torch.round( (summed_result * 10 ** 5) / (10 ** 5))\\n assert not all(summed_result == 1.0)\\n\\n RNN_instance = RNN(layers_info=[[\\\"lstm\\\", 20], [\\\"gru\\\", 5], [\\\"lstm\\\", 25], [\\\"linear\\\", 8]],\\n hidden_activations=\\\"relu\\\", input_dim=input_dim,\\n initialiser=\\\"xavier\\\")\\n out = RNN_instance.forward(data)\\n assert not all(out.reshape(1, -1).squeeze() >= 0)\\n assert not all(out.reshape(1, -1).squeeze() <= 0)\\n summed_result = torch.sum(out, dim=1)\\n summed_result = summed_result.reshape(1, -1).squeeze()\\n summed_result = torch.round( (summed_result * 10 ** 5) / (10 ** 5))\\n assert not all( summed_result == 1.0)\",\n \"def evaluate1_5(self, test_data):\\r\\n test_results = [(np.argmax(self.feedforward1_5(x)), y)\\r\\n for (x, y) in test_data]\\r\\n #print(self.feedforward(test_data[0][0]))\\r\\n #print(test_data[0][1])\\r\\n return sum(int(x == y) for (x, y) in test_results)\",\n \"def num_outputs(cls) -> list[int]:\\n return [5] * 10\",\n \"def n_inputs(self):\",\n \"def test_init() -> None:\\n neural_net = NeuralNetwork()\\n assert neural_net.model.get_layer('output_layer').output_shape, (None, 4)\",\n \"def test(self, inputs, labels):\\n n = inputs.shape[0]\\n\\n error = 0.0\\n for idx in range(n):\\n result = self.forward(inputs[idx:idx+1, :])\\n error += abs(result - labels[idx:idx+1, :])\\n\\n print(\\\"error: \\\", error)\\n error /= n\\n print('accuracy: %.2f' % ((1 - error)*100) + '%')\\n print('')\",\n \"def test_size(self) -> int:\\n return int(self.data_size * self.__test_fraction)\",\n \"def count_weights(print_perlayer=True):\\n acc_total = 0\\n for v in tf.trainable_variables():\\n dims = v.get_shape().as_list()\\n total = np.prod(dims)\\n acc_total += total\\n if print_perlayer:\\n print('{}: {}, {}'.format(v.name, dims, total))\\n\\n return acc_total\",\n \"def getOutputLength(self):\\n return len(self.Y[0])\",\n \"def __len__(self):\\n if self._train:\\n return len(self._train_data)\\n return len(self._test_data)\",\n \"def __len__(self):\\n if self._train:\\n return len(self._train_data)\\n return len(self._test_data)\",\n \"def get_number_of_validation(self):\\n return self.n_valid\",\n \"def calculate_num_params(self):\\n num_params = 0\\n for p in self.parameters():\\n num_params += p.data.view(-1).size(0)\\n return num_params\",\n \"def getNumOutputs(self):\\n return _libsbml.Transition_getNumOutputs(self)\",\n \"def get_num_eval_images(hparams):\\n num_images_map = {\\n 'imagenet': 50000,\\n 'cifar10': 10000,\\n }\\n if hparams.input_data.input_fn not in num_images_map:\\n raise ValueError(\\n f'Unknown dataset size for input_fn {hparams.input_data.input_fn}')\\n\\n return num_images_map[hparams.input_data.input_fn]\",\n \"def total_predict_batches(self) -> int:\\n return sum(self.trainer.num_predict_batches)\",\n \"def num_examples_per_epoch(self):\\n\\t\\tif self.subset == 'train':\\n\\t\\t\\treturn 50000\\n\\t\\tif self.subset == 'validation':\\n\\t\\t\\treturn 10000\",\n \"def neural_network(X, Y, Xs_test, Ys_test):\\n ## YOUR CODE HERE\\n #################\\n return 0\",\n \"def len(self):\\r\\n return len(self.input), len(self.target)\",\n \"def total_test_batches(self) -> int:\\n return sum(self.trainer.num_test_batches)\",\n \"def width_fitness(predicted, expected_output):\\n return np.abs(predicted.shape[0] - expected_output.shape[0])\",\n \"def test_network(self):\\n train_accuracy = 100 - percentError(map(self.neural_result,\\n self.train_inputs),\\n self.train_outputs)\\n print 'Train accuracy:', train_accuracy\\n\\n test_accuracy = 100 - percentError(map(self.neural_result,\\n self.test_inputs),\\n self.test_outputs)\\n print 'Test accuracy:', test_accuracy\\n\\n print '#' * int(train_accuracy), 'TR'\\n print '#' * int(test_accuracy), 'TE'\",\n \"def evaluate(self):\\n # initialize delta_weights\\n Loss = 0\\n for i, x_test in enumerate(self.X_test):\\n Loss += (self.sigmoid(np.dot(self.weights,x_test))-self.y_test[i])**2\\n return Loss\",\n \"def num_params():\\n total_num = 0\\n for var in tf.trainable_variables():\\n shape = var.get_shape()\\n total_num += functools.reduce(operator.mul, [dim.value for dim in shape], 1)\\n return total_num\",\n \"def test(self, inputs, labels):\\n n = inputs.shape[0]\\n\\n error = 0.0\\n for idx in range(n):\\n result = self.forward(inputs[idx:idx+1, :])\\n error += abs(result - labels[idx:idx+1, :])\\n\\n error /= n\\n accuracy = np.round((1 - error)*100, 3)\\n self.accuracy_box.append(accuracy[0][0])\\n print('accuracy: %.2f' % accuracy + '%')\\n print('')\",\n \"def testNN(self, nn, testLoader):\\n self.nnMapping[nn].eval()\\n # check if total prediction is correct\\n correct = 0\\n total = 0\\n # check if each single prediction is correct\\n singleCorrect = 0\\n singleTotal = 0\\n with torch.no_grad():\\n for data, target in testLoader:\\n output = self.nnMapping[nn](data.to(self.device))\\n if target.shape == output.shape[:-1]:\\n pred = output.argmax(dim=-1) # get the index of the max value\\n elif target.shape == output.shape:\\n pred = (output >= 0.5).int()\\n else:\\n print(f'Error: none considered case for output with shape {output.shape} v.s. label with shape {target.shape}')\\n sys.exit()\\n target = target.to(self.device).view_as(pred)\\n correctionMatrix = (target.int() == pred.int()).view(target.shape[0], -1)\\n correct += correctionMatrix.all(1).sum().item()\\n total += target.shape[0]\\n singleCorrect += correctionMatrix.sum().item()\\n singleTotal += target.numel()\\n\\n accuracy = 100. * correct / total\\n singleAccuracy = 100. * singleCorrect / singleTotal\\n return accuracy, singleAccuracy\",\n \"def n_actions(self) -> int:\\n return np.unique(self.y).shape[0]\",\n \"def get_total_input_dimension(self, layers):\\n self._validate_layer_names(layers)\\n total = 0\\n for layer in self.layers:\\n if layer.layer_name in layers:\\n total += layer.get_input_space().get_total_dimension()\\n return total\",\n \"def test_CNN_hyperparameters_nrlayers(self):\\n hyperparams = modelgen.generate_CNN_hyperparameter_set(\\n min_fc_nodes=123, max_fc_nodes=123)\\n assert hyperparams.get('fc_hidden_nodes') == 123\",\n \"def number_of_iterations(self):\\n return self._solution.nit\",\n \"def nb_errors_nb(self, input_data, target):\\n input_data_resize = input_data.view(2000, 1, 14, 14)\\n number_output = self(input_data_resize)\\n number_output = number_output.view(1000, 2, 10)\\n predicted_classes = number_output.argmax(2)\\n predictions = predicted_classes[:, 0] <= predicted_classes[:, 1]\\n target_labels = target\\n nb_errors = torch.sum(predictions.type(torch.LongTensor) != target_labels)\\n return float(nb_errors) * 100 / input_data.size(0)\",\n \"def evaluate(self,test_data):\\r\\n\\t\\ttest_results= [(np.argmax(self.forwardprop(x)),y) for (x,y) in test_data]\\r\\n\\t\\treturn sum(int(x==y) for (x,y) in test_results)\",\n \"def test_model(net, data_loader):\\n net.eval()\\n true_preds, count = 0.0, 0\\n for imgs, labels in data_loader:\\n imgs, labels = imgs.to(device), labels.to(device)\\n with torch.no_grad():\\n preds = net(imgs).argmax(dim=-1)\\n true_preds += (preds == labels).sum().item()\\n count += labels.shape[0]\\n test_acc = true_preds / count\\n return test_acc\",\n \"def get_valid_data_size(self):\\n return len(self.pipeline.data['test'])\",\n \"def get_num_hidden(self) -> int:\\n return self.encoders[-1].get_num_hidden()\",\n \"def get_accuracy(self) -> float:\\n self.network.load_data()\\n self.network.train()\\n\\n n = len(self.network.y_test)\\n correct = 0\\n for i in range(n):\\n # Predict by running forward pass through the neural network\\n pred = self.network.predict(self.network.x_test[i])\\n # Sanity check of the prediction\\n assert 0 <= pred <= 1, \\\"The prediction needs to be in [0, 1] range.\\\"\\n # Check if right class is predicted\\n correct += self.network.y_test[i] == round(float(pred))\\n return round(correct / n, 3)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71643096","0.678337","0.66984856","0.6695219","0.6695219","0.6681218","0.6619715","0.66186917","0.6527112","0.6512901","0.6510943","0.6478449","0.64484787","0.6436919","0.6436919","0.6424878","0.6382965","0.6375347","0.6356472","0.634797","0.6315814","0.62784094","0.6245149","0.6219271","0.6201982","0.61959404","0.61931974","0.619085","0.6187766","0.61783046","0.6176461","0.61714256","0.6166377","0.61640924","0.61400676","0.6136564","0.61113554","0.61081284","0.61052483","0.61052483","0.610419","0.60894924","0.60886127","0.60764647","0.6039071","0.60383904","0.6032159","0.60199326","0.60144085","0.5995336","0.59665996","0.5960612","0.5960604","0.595771","0.59520507","0.5948654","0.592552","0.59228665","0.5909149","0.59084636","0.590399","0.59011644","0.5895797","0.58919764","0.5890233","0.5885897","0.58858335","0.5883754","0.58707935","0.5868159","0.5863293","0.5857126","0.5852617","0.58517903","0.58517903","0.5849304","0.58376575","0.58333576","0.58311194","0.5828568","0.5817888","0.58177954","0.58132994","0.5802735","0.58019567","0.5786155","0.578551","0.5781338","0.5780711","0.5777442","0.5775829","0.57624483","0.5759717","0.5752201","0.5750409","0.5748699","0.574526","0.57440895","0.573947","0.57361287"],"string":"[\n \"0.71643096\",\n \"0.678337\",\n \"0.66984856\",\n \"0.6695219\",\n \"0.6695219\",\n \"0.6681218\",\n \"0.6619715\",\n \"0.66186917\",\n \"0.6527112\",\n \"0.6512901\",\n \"0.6510943\",\n \"0.6478449\",\n \"0.64484787\",\n \"0.6436919\",\n \"0.6436919\",\n \"0.6424878\",\n \"0.6382965\",\n \"0.6375347\",\n \"0.6356472\",\n \"0.634797\",\n \"0.6315814\",\n \"0.62784094\",\n \"0.6245149\",\n \"0.6219271\",\n \"0.6201982\",\n \"0.61959404\",\n \"0.61931974\",\n \"0.619085\",\n \"0.6187766\",\n \"0.61783046\",\n \"0.6176461\",\n \"0.61714256\",\n \"0.6166377\",\n \"0.61640924\",\n \"0.61400676\",\n \"0.6136564\",\n \"0.61113554\",\n \"0.61081284\",\n \"0.61052483\",\n \"0.61052483\",\n \"0.610419\",\n \"0.60894924\",\n \"0.60886127\",\n \"0.60764647\",\n \"0.6039071\",\n \"0.60383904\",\n \"0.6032159\",\n \"0.60199326\",\n \"0.60144085\",\n \"0.5995336\",\n \"0.59665996\",\n \"0.5960612\",\n \"0.5960604\",\n \"0.595771\",\n \"0.59520507\",\n \"0.5948654\",\n \"0.592552\",\n \"0.59228665\",\n \"0.5909149\",\n \"0.59084636\",\n \"0.590399\",\n \"0.59011644\",\n \"0.5895797\",\n \"0.58919764\",\n \"0.5890233\",\n \"0.5885897\",\n \"0.58858335\",\n \"0.5883754\",\n \"0.58707935\",\n \"0.5868159\",\n \"0.5863293\",\n \"0.5857126\",\n \"0.5852617\",\n \"0.58517903\",\n \"0.58517903\",\n \"0.5849304\",\n \"0.58376575\",\n \"0.58333576\",\n \"0.58311194\",\n \"0.5828568\",\n \"0.5817888\",\n \"0.58177954\",\n \"0.58132994\",\n \"0.5802735\",\n \"0.58019567\",\n \"0.5786155\",\n \"0.578551\",\n \"0.5781338\",\n \"0.5780711\",\n \"0.5777442\",\n \"0.5775829\",\n \"0.57624483\",\n \"0.5759717\",\n \"0.5752201\",\n \"0.5750409\",\n \"0.5748699\",\n \"0.574526\",\n \"0.57440895\",\n \"0.573947\",\n \"0.57361287\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.621531"},"document_rank":{"kind":"string","value":"24"}}},{"rowIdx":80997,"cells":{"query":{"kind":"string","value":"Return the vector of partial derivatives \\partial C_x / \\partial a for the output activations Based on the quadratic cost function C(x) = 1/(2n) (y a^L(x))^2 where x is input y is expected output a^L is the actual output"},"document":{"kind":"string","value":"def cost_derivative(self, output_activations, y):\n return (output_activations-y)"},"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 cost_derivative(self, output_activations, y):\r\n return (output_activations-y)","def cost_derivative(output_activations, y):\n return (output_activations - y)","def cost_derivative(self, output_activations, y):\n\t\treturn (output_activations - y)","def deriv_costFunction(self, x, y):\n self.yEst = self.forward_propagate(x)\n\n delta_o = np.multiply( ( self.yEst - y ), self.deriv_sigmoid(self.z_o) )\n #partial deriv of cost wrt hidden -> output weights\n partial_J_w_ho = np.dot( self.a_h.T, delta_o )\n\n ones_o = np.ones( delta_o.shape[0] )\n #partial deriv of cost wrt output biases\n partial_J_b_o = np.dot( ones_o, delta_o )\n\n delta_h = np.dot( delta_o, self.w_ho.T ) * self.deriv_sigmoid( self.z_h )\n #partial deriv of cost wrt input -> hidden weights\n partial_J_w_ih = np.dot( x.T, delta_h )\n \n ones_h = np.ones( delta_h.shape[0] )\n #partial deriv of cost wrt hidden biases\n partial_J_b_h = np.dot( ones_h, delta_h)\n\n return partial_J_w_ih, partial_J_w_ho, partial_J_b_h, partial_J_b_o","def _fv(self):\n return self.beta * (self.x ** self.c)","def F(cst, x):\n [u0, v0, u1, v1, u2, v2, coeffs] = cst\n [u, v, g1, g2, g3] = x\n a = g1*u1 - u0\n b = g2*u2 - u0\n c = g3*u - u0\n l = g1*v1 - v0 \n m = g2*v2 - v0\n n = g3*v - v0\n r = g1 - 1\n s = g2 - 1\n t = g3 - 1\n return np.array([\n coeffs[0]*(a**2-l**2) + 2*coeffs[1]*(a*b-l*m) + coeffs[2]*(b**2-m**2) + 2*coeffs[3]*(a*c-l*n) + 2*coeffs[4]*(b*c-m*n) + c**2 - n**2,\n coeffs[0]*(l**2-r**2) + 2*coeffs[1]*(l*m-r*s) + coeffs[2]*(m**2-s**2) + 2*coeffs[3]*(l*n-r*t) + 2*coeffs[4]*(m*n-s*t) + n**2 - t**2,\n coeffs[0]*a*l + coeffs[1]*(l*b+m*a) + coeffs[2]*m*b + coeffs[3]*(l*c+n*a) + coeffs[4]*(m*c+b*n) + c*n,\n coeffs[0]*a*r + coeffs[1]*(r*b+s*a) + coeffs[2]*s*b + coeffs[3]*(r*c+t*a) + coeffs[4]*(s*c+b*t) + c*t,\n coeffs[0]*r*l + coeffs[1]*(l*s+m*r) + coeffs[2]*m*s + coeffs[3]*(l*t+n*r) + coeffs[4]*(m*t+s*n) + t*n \n ])","def cost_derivative(self, output_activations, y):\n return 2 * (output_activations - y)","def cost_derivative(self,output_results,y):\r\n\t\treturn (output_results-y)","def _gradients(self, partial):\r\n dL_dfhat, I_KW_i = self._shared_gradients_components()\r\n dlik_dthetaL, dlik_grad_dthetaL, dlik_hess_dthetaL = self.noise_model._laplace_gradients(self.f_hat, self.data, extra_data=self.extra_data)\r\n\r\n #len(dlik_dthetaL)\r\n num_params = len(self._get_param_names())\r\n # make space for one derivative for each likelihood parameter\r\n dL_dthetaL = np.zeros(num_params)\r\n for thetaL_i in range(num_params):\r\n #Explicit\r\n dL_dthetaL_exp = ( np.sum(dlik_dthetaL[:, thetaL_i])\r\n #- 0.5*np.trace(mdot(self.Ki_W_i, (self.K, np.diagflat(dlik_hess_dthetaL[thetaL_i]))))\r\n + np.dot(0.5*np.diag(self.Ki_W_i)[:,None].T, dlik_hess_dthetaL[:, thetaL_i])\r\n )\r\n\r\n #Implicit\r\n dfhat_dthetaL = mdot(I_KW_i, self.K, dlik_grad_dthetaL[:, thetaL_i])\r\n dL_dthetaL_imp = np.dot(dL_dfhat, dfhat_dthetaL)\r\n dL_dthetaL[thetaL_i] = dL_dthetaL_exp + dL_dthetaL_imp\r\n\r\n return dL_dthetaL","def get_partial_derivatives(self) -> List[Callable]:\n return [self.dfdm, self.dfdc]","def c_coefficients(x1,x2,x3,y1,y2,y3,initial_slope,final_slope):\n\tC = c_matrix(x1,x2,x3)\n\ty = y_vector(x1,x2,x3,y1,y2,y3,initial_slope,final_slope)\n\tCCoefficients = np.dot(inv(C),y)\n\treturn(CCoefficients)","def coefC(x0,y0,x1,y1):\n return (x1*y0-x0*y1)/(x1-x0)","def lp_acent(A,b,c,x_0):\n #Parameters\n b = b.flatten()\n c = c.flatten()\n ALPHA = 0.01\n BETA = 0.5\n EPSILON = 1e-6\n MAXITERS = 100\n if (np.min(x_0)<=0) and (np.linalg.norm>1e-3):\n print 'failed' \n return 0\n #m = len(b)\n #n = len(x_0)\n lambda_hist = []\n x = x_0\n for iter in range(MAXITERS):\n # H = np.diag(1/np.power(x,3))\n g = c-np.power(x,-1)\n #print g.shape\n #solving KKT system\n w = np.linalg.solve(np.dot(np.dot(A,np.diag(np.power(x,2))),A.T),\n np.dot(np.dot(-A,np.diag(np.power(x,2))),g))\n dx = np.dot(-np.diag(np.power(x,2)),np.dot(A.T,w)+g)\n lambdasqr = np.dot(-g.T,dx) #dx'*T*dx: newton incremental\n lambda_hist.append(lambdasqr/2)\n if lambdasqr/2 <= EPSILON:\n break\n # backtracking line search\n t = 1\n # brin the point inside the domain\n while np.min(x+t*dx)<=0:\n t =BETA*t\n while np.dot(c.T,np.dot(t,dx))-np.sum(np.log(x+t*dx))+np.sum(np.log(x))-ALPHA*t*np.dot(g.T,dx)>0:\n t = BETA*t\n x = x+t*dx\n if iter == MAXITERS:\n print 'ERROR: MAXITERS reached'\n else:\n #plt.figure()\n #plt.plot(range(len(lambda_hist)),lambda_hist,'b-',range(len(lambda_hist)),lambda_hist,'bo')\n return x,w,lambda_hist","def costFun(self, x):\n\ttmp = x.reshape(self.inp_shape)\n\tc = np.float64(self.calcCost(np.asarray(tmp,dtype=np.float32))) + self.alpha * np.dot(x.T, x)\n\treturn c","def get_partial_derivatives(self) -> List[Callable]:\n return [self.dfda, self.dfdb, self.dfdc]","def coefA(x0,y0,x1,y1):\n return -(y1-y0)/(x1-x0)","def compute_cost_derivative(AL, Y):\n pass","def gradient(C, w, b):\n return list(partial_deriv(C, b)) + list(partial_deriv(C, wi) for wi in w)","def jacobian(self, x):\n x_ = np.atleast_2d(x)\n if self.normalize:\n x_ = (x_ - self.sample_mean) / self.sample_std\n s_ = (self.samples - self.sample_mean) / self.sample_std\n else:\n s_ = self.samples\n\n fx, jf = self.reg_model(x_)\n rx, drdx = self.corr_model(x=x_, s=s_, params=self.corr_model_params, dx=True)\n y_grad = np.einsum('ikj,jm->ik', jf, self.beta) + np.einsum('ijk,jm->ki', drdx.T, self.gamma)\n if self.normalize:\n y_grad = y_grad * self.value_std / self.sample_std\n if x_.shape[1] == 1:\n y_grad = y_grad.flatten()\n return y_grad","def get_partial_derivatives(self) -> List[Callable]:\n pass","def cost_derivative_for_output(output_activations, y):\n return output_activations - y","def f(z, X, Y, _lambda):\r\n w = z[:-1]\r\n beta = np.squeeze(z[-1])\r\n term_1_d = (X * (Y[:, np.newaxis] - g(X.dot(w) + beta))).sum(axis=0)\r\n term_d_1 = (Y[:, np.newaxis] - g(X.dot(w) + beta)).sum() + 2 * _lambda * beta\r\n return np.hstack((term_1_d, term_d_1))[:, np.newaxis]","def L_fun(x):\n \n f_x0 = f(ad.create_vector('x0', x0, seed_vector=x));\n f_x0 = np.array(f_x0) #ensure that f_x0 is np.array\n action = sum_values(ad.get_deriv(f_x0))\n return action","def get_partial_derivatives(self) -> List[Callable]:\n return [self.dfdmu, self.dfdsig]","def det(a, b, c):\n d = (b[0]*c[1]-c[0]*b[1])+(c[0]*a[1]-a[0]*c[1])+(a[0]*b[1]-a[1]*b[0])\n return d","def compute_partials(self, inputs, partials):\n SOC = inputs['SOC']\n temperature = inputs['temperature']\n P_bat = inputs['P_bat']\n\n # dI_dP\n dV_dvoc = IR * self.exponential\n dV_dT = - IR * self.voc * np.exp(alpha*(temperature[4, :] - T0)/T0) * alpha / T0\n dVoc_dSOC = np.exp(SOC[0, :]) / (np.e-1)\n\n self.dI_dP = 1.0 / self.V\n tmp = -P_bat/(self.V**2)\n self.dI_dT = tmp * dV_dT\n self.dI_dSOC = tmp * dV_dvoc * dVoc_dSOC","def cd(x0,partial,learning_rate=0.01,iterations=10,**kwargs):\n x = x0; N = len(x)\n for i in range(iterations):\n indices = random.sample(list(range(N)),N)\n for j in indices:\n x[j] -= learning_rate*partial(x0,j)\n return x","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 cubic_evolve(self,nt=1):\n #loop through time steps\n for l in range(nt):\n # temporary array\n y_temp = np.zeros(self.y.shape[0])\n # loop through array\n for i in range(self.y.shape[0]):\n # idx left to departure point\n x_dep = self.x[i]-self.u[i]*self.dt\n j = int(np.floor(x_dep/self.dx))\n # alpha\n a = (self.x[i]-self.u[i]*self.dt - j*self.dx)/self.dx\n # calculate next time step\n f = lambda x: x % self.y.shape[0] if x >= self.y.shape[0] else x\n y_temp[i] = - a * (1-a)*(2-a)/6 * self.y[f(j-1)]\n y_temp[i] += (1-a**2)*(2-a)/2 * self.y[f(j)]\n y_temp[i] += a*(1+a)*(2-a)/2 * self.y[f(j+1)]\n y_temp[i] -= a*(1-a**2)/6 * self.y[f(j+2)]\n self.y = np.copy(y_temp)\n return self.y","def test_partial_sum_2d(self): # pylint:disable=no-self-use\n x = [1, 2, 3]\n y = [4, 5, 6]\n c = [7, 8, 9]\n\n gamma = dcor_internals._partial_sum_2d(x, y, c)\n expected_gamma = [17., 16., 15.]\n\n np.testing.assert_allclose(gamma, expected_gamma)","def f(self, x: np.array) -> np.array:\n return self.a * x**2 + self.b * x + self.c","def slip_to_coefficients(x, y, a):\n partials = np.zeros((x.size, 3))\n partials[:, 0] = (x / a) * (9 * (x / a) / 8 - 3 / 4)\n partials[:, 1] = (1 - 3 * (x / a) / 2) * (1 + 3 * (x / a) / 2)\n partials[:, 2] = (x / a) * (9 * (x / a) / 8 + 3 / 4)\n coefficients = np.linalg.inv(partials) @ y\n return coefficients","def _cost_function_derivative(self, y_pred, y, X, m):\n\n derivatives= np.zeros((X.shape[0],1))\n for j in range(X.shape[0]):\n auxsum = 0\n for i in range(m):\n auxsum+=(y_pred[0][i] -y[0][i])*X[j][i]\n derivatives[j][0] = self.theta[j][0] - self.alpha * 1/m * auxsum\n\n #empty_derivatives = np.zeros((X.shape[0],1))\n return derivatives","def compute_partials(self, inputs, partials):\n I_bat = inputs['I_bat']\n SOC = inputs['SOC']\n\n self.dCh_dg, self.dCh_drho = KSfunction.derivatives(I_bat - self.Imax, self.rho)\n self.dDs_dg, self.dDs_drho = KSfunction.derivatives(self.Imin - I_bat, self.rho)\n self.dS0_dg, self.dS0_drho = KSfunction.derivatives(self.SOC0 - SOC, self.rho)\n self.dS1_dg, self.dS1_drho = KSfunction.derivatives(SOC - self.SOC1, self.rho)\n\n self.dCh_dg = self.dCh_dg.flatten()\n self.dCh_drho = self.dCh_drho.flatten()\n self.dDs_dg = self.dDs_dg.flatten()\n self.dDs_drho = self.dDs_drho.flatten()\n self.dS0_dg = self.dS0_dg.flatten()\n self.dS0_drho = self.dS0_drho.flatten()\n self.dS1_dg = self.dS1_dg.flatten()\n self.dS1_drho = self.dS1_drho.flatten()","def fixed_cost(self):\n return np.einsum('i->', self.c[self.f])","def gradient(self, x):\n u = np.asarray([x[0]])\n C = self.C_func(u)\n dC = self.dC_func(u, order=1)\n P = self.P\n numerator = np.sum((C - P) * dC, axis=0)\n denominator = np.sum(np.sum((C - P) ** 2, axis=0) ** (1 / 2))\n if np.abs(denominator) > 0:\n gradient = numerator/denominator\n else:\n gradient = np.asarray(0)[np.newaxis]\n return gradient","def d_coefficients(x1,x2,x3,CCoefficients):\n\tDCoefficients = np.array([\t(CCoefficients[1]-CCoefficients[0])/(3*(x2-x1)), \\\n\t\t\t\t\t\t\t\t(CCoefficients[2]-CCoefficients[1])/(3*(x3-x2))\t], \\\n\t\t\t\t\t\t\t\tfloat)\n\treturn(DCoefficients)","def b_coefficients(x1,x2,x3,y1,y2,y3,CCoefficients,DCoefficients):\n\tBCoefficients = np.array([\t((y2-y1)/(x2-x1)-CCoefficients[0]*(x2-x1) - DCoefficients[0]*((x2-x1)**2)), \\\n\t\t\t\t\t\t\t\t((y3-y2)/(x3-x2)-CCoefficients[1]*(x3-x2) - DCoefficients[1]*((x3-x2)**2)) \t]).astype(float)\n\treturn(BCoefficients)","def df(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 dfx = 2 * D / x**3 + A / B**2 * math.exp(- x / B) - 42 * C / x**8\n\n return dfx","def fit(self, f: callable, a: float, b: float, d: int, maxtime: float) -> callable:\r\n\r\n # replace these lines with your solution\r\n initial_T = time.time()\r\n\r\n def get_points(f, a, b, n):\r\n x = np.linspace(a, b, n)\r\n y_lst = f(x)\r\n y = np.array(y_lst)\r\n\r\n return x, y\r\n\r\n def build_vector(x, y, size, deg):\r\n if deg == size:\r\n y_n = y.sum()\r\n else:\r\n y_n = np.dot(y, (x ** (size - deg)))\r\n pol1 = np.zeros(size + 1)\r\n for i in range(size + 1):\r\n pol1[i] = (x ** (2 * size - deg - i)).sum()\r\n return pol1, y_n\r\n\r\n def build_coeff_matrix(f, a, b, n, d):\r\n x, y = get_points(f, a, b, n)\r\n deg = d\r\n b = np.array([])\r\n coeff_matrix = np.array([])\r\n for i in range(d + 1):\r\n x_n, y_n = build_vector(x, y, d, i)\r\n deg -= 1\r\n coeff_matrix = np.append(coeff_matrix, x_n)\r\n b = np.append(b, y_n)\r\n coeff_matrix = np.reshape(coeff_matrix, (d + 1, d + 1))\r\n return coeff_matrix, b\r\n\r\n def solve_coeff_matrix(coeff_matrix, b):\r\n A_inverse = np.linalg.inv(coeff_matrix)\r\n coeffs = A_inverse.dot(b)\r\n return coeffs\r\n\r\n def build_function_from_coeffs(coeffs):\r\n f = np.poly1d(coeffs)\r\n return f\r\n\r\n n = 100 # fisrt sample size\r\n while (time.time() - initial_T) + 0.2 < maxtime: # while i still have time loop again\r\n Ax, B = build_coeff_matrix(f, a, b, n, d=d)\r\n if time.time() - initial_T + 0.2 >= maxtime: # first break point\r\n break\r\n coeffs = solve_coeff_matrix(coeff_matrix=Ax, b=B)\r\n if time.time() - initial_T + 0.2 >= maxtime: # second break point\r\n break\r\n result = build_function_from_coeffs(coeffs)\r\n if time.time() - initial_T + 0.2 >= maxtime: # third break point\r\n break\r\n n += 200 # increasing sample size\r\n\r\n return result","def c(\n dp: np.ndarray,\n ddp: np.ndarray,\n ) -> np.ndarray:\n\n return \\\n np.abs(ddp[0, :]*dp[1, :] - dp[0, :]*ddp[1, :]) / \\\n (dp[0, :]**2 + dp[1, :]**2)**1.5","def dV(X):\n return -4 * a * np.power(X, 3) + 2 * b * X","def compute_gradient(c, x, y):\n\n vectors = np.array([[0, 1], [0, -1], [1, 0], [-1, 0]])\n rows, cols = c.shape\n\n result = np.empty_like(x)\n\n for i in nb.prange(rows):\n for j in nb.prange(cols):\n c_remainder = c[i, j] % 4\n gradient_co = vectors[c_remainder]\n result[i, j] = gradient_co[0] * x[i, j] + gradient_co[1] * y[i, j]\n\n return result","def gradient_of_selection(f_jk,benefit_function,b,c=1,*params):\n f_jk['gos'] = f_jk.A*(b*benefit_function(f_jk.j+1,f_jk.k+1,*params)-c) - f_jk.B*b*benefit_function(f_jk.j,f_jk.k+1,*params)\n gos = f_jk.groupby('n')['gos'].sum() \n gos = gos*(Z-gos.index.values)*gos.index.values/(Z**2)*DELTA\n gos.loc[0]=gos.loc[100]=0\n return gos","def func_deriv(x,remain):\n #df_x0 = -1*remain[0]/x[0]**2\n #df_x1 = -1*remain[2]/x[1]**2\n #df_x2 = -1*remain[1]/x[2]**2\n return np.array(-1*remain/x**2)","def V_fit(x, a, b, c, d, e, f):\n x1 = x[0] # I\n x2 = x[1] # dT\n m = (a * x1 ** 2 + b * x1 + c)\n b = (d * x1 ** 2 + e * x1 + f)\n return m * x2 + b","def partial ( index , func , x , h = 0 , I = 2 , err = False ) :\n \n if len(x) <= index :\n raise AttributeError(\"Invalid argument length/index %d/%d\" % ( len(x) , index ) )\n \n _x = [ float(a) for a in x ]\n \n ## create wrapper function \n def _wrap ( z ) :\n _z = _x[index] \n _x[index] = z\n _r = func ( *_x )\n _x[index] = _z\n return _r\n \n x_i = _x[ index ]\n return derivative ( _wrap , x = x_i , h = h , I = I , err = err )","def _antipode(self, x, c):\n lambda_x = self._lambda_x(x, c)\n x_sqnorm = tf.reduce_sum(tf.pow(x, 2), axis=-1, keepdims=True)\n scale = -1.0 / (lambda_x * c * x_sqnorm)\n return scale * x","def return_quadratic_cost_function_expansion_variables(\n X,U,dt,\n RunningCost=\"Minimize Input Energy\"):\n\n if type(RunningCost)==str:\n assert RunningCost in ['Minimize Input Energy',\n 'Minimize time away from target angle',\n 'Minimize time away from target angular velocity'],\\\n \"RunningCost must be either 'Minimize Input Energy','Minimize time away from target angle', or 'Minimize time away from target angular velocity'.\"\n else:\n assert type(RunningCost)==list, \"RunningCost must be a list of cost types.\"\n for el in RunningCost:\n assert type(el)==str, \"Each element of RunningCost must be a string. Not \" + str(type(el)) + \".\"\n assert el in ['Minimize Input Energy',\n 'Minimize time away from target angle',\n 'Minimize time away from target angular velocity'],\\\n \"Each element of RunningCost must be either 'Minimize Input Energy','Minimize time away from target angle', or 'Minimize time away from target angular velocity'. '\" + el + \"' not accepted.\"\n\n # returns a list of length len(Time)-1, each element with shape (1,1), where n is the number of states.\n l_func = return_l_func(RunningCost=RunningCost)\n l = list(\n map(\n lambda X,U: l_func(X,U,dt),\n X[:,1:].T,\n U\n )\n )\n\n # returns a list of length len(Time)-1, each element with shape (n,1), where n is the number of states.\n lx_func = return_lx_func(RunningCost=RunningCost)\n lx = list(\n map(\n lambda X,U: lx_func(X,U,dt),\n X[:,1:].T,\n U\n )\n )\n\n # returns a list of length len(Time)-1, each element with shape (m,1), where n is the number of states.\n lu_func = return_lu_func(RunningCost=RunningCost)\n lu = list(\n map(\n lambda X,U: lu_func(X,U,dt),\n X[:,1:].T,\n U\n )\n )\n\n # returns a list of length len(Time)-1, each element with shape (m,n), where m is the number of inputs and n is the number of states.\n lux_func = return_lux_func(RunningCost=RunningCost)\n lux = list(\n map(\n lambda X,U: lux_func(X,U,dt),\n X[:,1:].T,\n U\n )\n )\n\n # returns a list of length len(Time)-1, each element with shape (n,m), where n is the number of states and m is the number of inputs.\n lxu_func = return_lxu_func(RunningCost=RunningCost)\n lxu = list(\n map(\n lambda X,U: lxu_func(X,U,dt),\n X[:,1:].T,\n U\n )\n )\n\n # returns a list of length len(Time)-1, each element with shape (m,m), where m is the number of inputs.\n luu_func = return_luu_func(RunningCost=RunningCost)\n luu = list(\n map(\n lambda X,U: luu_func(X,U,dt),\n X[:,1:].T,\n U\n )\n )\n\n # returns a list of length len(Time)-1, each element with shape (n,n), where n is the number of states.\n lxx_func = return_lxx_func(RunningCost=RunningCost)\n lxx = list(\n map(\n lambda X,U: lxx_func(X,U,dt),\n X[:,1:].T,\n U\n )\n )\n\n return(l,lx,lu,lux,lxu,luu,lxx)","def jacobian(self, b):\n \n # Substitute parameters in partial derivatives\n subs = [pd.subs(zip(self._b, b)) for pd in self._pderivs]\n # Evaluate substituted partial derivatives for all x-values\n vals = [sp.lambdify(self._x, sub, \"numpy\")(self.xvals) for sub in subs]\n # Arrange values in column-major order\n return np.column_stack(vals)","def DynamicsCo(x, t, T0, alpha, cost_co, cost_ch, K_co, K_ch, n, r):\n y=np.zeros([np.size(x)])\n D=np.zeros([2]) \n #define fitnss\n D[0]=dmax*x[0]**n/(K_co**n+x[0]**n) #cooperator\n D[1]=dmax*x[0]**n/(K_ch**n+x[0]**n) #cheater \n #degradation\n deg=fmax*x[1]/(x[1]+Kd) \n #ODE of eco-evo dynamics\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\n y[1]=x[1]*(r*(1-cost_co)*(1-x[1]-x[2])-D[0]-alpha)#d Co/dt\n y[2]=x[2]*(r*(1-cost_ch)*(1-x[1]-x[2])-D[1]-alpha) #d Ch/dt\n \n return y","def grad(self, x):\n l2 = L2(1.0, rng=self.rng)\n grad_Ab = 0\n for i in xrange(len(self.A)):\n Ai = self.A[i]\n Ab = Ai.dot(x)\n grad_Ab += Ai.T.dot(l2.grad(Ab))\n\n return self.l * grad_Ab","def _evalAndDer(self, x):\n if _isscalar(x):\n pos = np.searchsorted(self.x_list, x)\n if pos == 0:\n y = self.coeffs[0, 0] + self.coeffs[0, 1] * (x - self.x_list[0])\n dydx = self.coeffs[0, 1]\n elif pos < self.n:\n alpha = (x - self.x_list[pos - 1]) / (\n self.x_list[pos] - self.x_list[pos - 1]\n )\n y = self.coeffs[pos, 0] + alpha * (\n self.coeffs[pos, 1]\n + alpha * (self.coeffs[pos, 2] + alpha * self.coeffs[pos, 3])\n )\n dydx = (\n self.coeffs[pos, 1]\n + alpha\n * (2 * self.coeffs[pos, 2] + alpha * 3 * self.coeffs[pos, 3])\n ) / (self.x_list[pos] - self.x_list[pos - 1])\n else:\n alpha = x - self.x_list[self.n - 1]\n y = (\n self.coeffs[pos, 0]\n + x * self.coeffs[pos, 1]\n - self.coeffs[pos, 2] * np.exp(alpha * self.coeffs[pos, 3])\n )\n dydx = self.coeffs[pos, 1] - self.coeffs[pos, 2] * self.coeffs[\n pos, 3\n ] * np.exp(alpha * self.coeffs[pos, 3])\n else:\n m = len(x)\n pos = np.searchsorted(self.x_list, x)\n y = np.zeros(m)\n dydx = np.zeros(m)\n if y.size > 0:\n out_bot = pos == 0\n out_top = pos == self.n\n in_bnds = np.logical_not(np.logical_or(out_bot, out_top))\n\n # Do the \"in bounds\" evaluation points\n i = pos[in_bnds]\n coeffs_in = self.coeffs[i, :]\n alpha = (x[in_bnds] - self.x_list[i - 1]) / (\n self.x_list[i] - self.x_list[i - 1]\n )\n y[in_bnds] = coeffs_in[:, 0] + alpha * (\n coeffs_in[:, 1]\n + alpha * (coeffs_in[:, 2] + alpha * coeffs_in[:, 3])\n )\n dydx[in_bnds] = (\n coeffs_in[:, 1]\n + alpha * (2 * coeffs_in[:, 2] + alpha * 3 * coeffs_in[:, 3])\n ) / (self.x_list[i] - self.x_list[i - 1])\n\n # Do the \"out of bounds\" evaluation points\n y[out_bot] = self.coeffs[0, 0] + self.coeffs[0, 1] * (\n x[out_bot] - self.x_list[0]\n )\n dydx[out_bot] = self.coeffs[0, 1]\n alpha = x[out_top] - self.x_list[self.n - 1]\n y[out_top] = (\n self.coeffs[self.n, 0]\n + x[out_top] * self.coeffs[self.n, 1]\n - self.coeffs[self.n, 2] * np.exp(alpha * self.coeffs[self.n, 3])\n )\n dydx[out_top] = self.coeffs[self.n, 1] - self.coeffs[\n self.n, 2\n ] * self.coeffs[self.n, 3] * np.exp(alpha * self.coeffs[self.n, 3])\n return y, dydx","def cost_function(x, N, w, dt):\n yh = np.abs(fftkernel(x, w / dt)) # density\n # formula for density\n C = np.sum(yh ** 2) * dt - 2 * np.sum(yh * x) * \\\n dt + 2 / np.sqrt(2 * np.pi) / w / N\n C = C * N * N\n # formula for rate\n # C = dt*sum( yh.^2 - 2*yh.*y_hist + 2/sqrt(2*pi)/w*y_hist )\n return C, yh","def calc_nonlinear_rhs(self, A):\n cff = -1/(4*self.dx) \n N = self.N\n rhs = np.zeros((N,))\n alpha = self.alpha\n\n # Central difference for the interior points\n rhs[1:N-1] = cff*alpha[1:-1] * (A[2:]*A[2:] - A[0:-2]*A[0:-2])\n\n # Boundary term forward difference\n rhs[0] = 0.5*cff*alpha[0]*(A[1]*A[1] - A[0]*A[0])\n\n return rhs","def compute_cost(AL, Y, parameters ,lambd):\n L = len(parameters) // 2\n m = Y.shape[1]\n cost = -1 / m * np.sum(np.nan_to_num(Y * np.log(AL) + (1-Y) * np.log(1-AL)))\n cost+= 0.5*(lambd/m)*sum(np.linalg.norm(parameters['W' + str(i)])**2 for i in range(1,L))\n return cost","def linear_evolve(self,nt=1):\n for l in range(nt):\n y_temp = np.empty(self.y.shape[0])\n for i in range(self.y.shape[0]):\n \n # idx left to the departure point\n j = int(np.floor((self.x[i]-self.u[i]*self.dt)/self.dx))\n # idx right to the departure point\n k = j+1\n print i, j, k\n # linear interpolation\n alpha = (self.x[i]-self.u[i]*self.dt - j*self.dx)/self.dx\n y_temp[i] = (1-alpha)*self.y[j] + alpha*self.y[k]\n # copy array to current time\n self.y = np.copy(y_temp)\n stop\n #return current varibale\n return self.y","def _linear_dispersion_coeff(beta, q):\n return np.sqrt(beta) / (2 * np.sin(np.pi * q))","def F_lambda(theta, b, q, d, r, M, C, sigma_xx, L):\r\n theta = np.reshape(theta, (q, r))\r\n b = np.reshape(b, (d, r))\r\n total = 0.0\r\n for k in range(d):\r\n for l in range(r):\r\n total += np.linalg.norm(b[k][l])\r\n t1 = -2.0 * np.trace(\r\n np.matmul(np.matmul(np.matmul(b.T, M.T), C), theta))\r\n t2 = np.trace(np.matmul(np.matmul(b.T, sigma_xx), b))\r\n return t1 + t2 + L * total","def TestFunc1(x):\r\n return 12*x[0]*x[0] + 4*x[1]*x[1] - 12*x[0]*x[1] + 2*x[1]","def cdm(x0,partial,learning_rate=0.01,momentum_weight=0.9,iterations=10,\n initial_momentum=0,**kwargs):\n x = x0; N = len(x)\n if initial_momentum == 0:\n momentum = np.zeros(x0.shape)\n else:\n momentum = initial_momentum\n for i in range(iterations):\n indices = random.sample(range(N),N)\n for j in indices:\n momentum[j] = momentum_weight*momentum[j]+\\\n (1-momentum_weight)*partial(x0,j)\n x[j] -= learning_rate*momentum[j]\n return x, momentum","def fn(a, y):\n return 0.5*np.linalg.norm(a-y)**2","def lr_cost_function_grad(theta: np.ndarray, X: np.ndarray, y: np.ndarray, l: float) -> np.ndarray:\n # Initialize some useful values\n m = len(y) # number of training examples\n\n # You need to return the following variable correctly.\n grad = np.zeros(theta.shape)\n\n # ====================== YOUR CODE HERE ======================\n # Instructions: Compute the partial derivatives and set grad to the partial\n # derivatives of the cost w.r.t. each parameter in theta.\n\n # =============================================================\n return grad","def grad(self, x):\n norm_beta = np.linalg.norm(x)\n if norm_beta > utils.TOLERANCE:\n return (self.l / norm_beta) * x\n else:\n D = x.shape[0]\n u = (self.rng(D, 1) * 2.0) - 1.0 # [-1, 1]^D\n norm_u = np.linalg.norm(u)\n a = self.rng() # [0, 1]\n\n return (self.l * (a / norm_u)) * u","def fd_jacobian(self,y):\n res0 = self.residual(y)\n eps = 1e-6\n dofs = y.shape[0]\n jac_approx = np.zeros((dofs,dofs))\n for i in range(dofs):\n y_temp = np.copy(y)\n y_temp[i]+=eps\n\n r2 = self.residual(y_temp)\n dr = (r2-res0)/eps\n for j in range(dofs):\n jac_approx[j,i] = dr[j]\n \n return jac_approx","def derivatives(x_p, y_p):\r\n # set up the matrix equation\r\n n = x_p.shape[0]\r\n M = np.zeros( [n,n] )\r\n d = np.zeros( [n,1] )\r\n \r\n # fill in the constants where they can be\r\n for i in np.arange(1,n-1 ): # for all but the first and last row\r\n M[i,i-1 ] = ( x_p[i] - x_p[i-1] ) / 6.\r\n M[i,i] = ( x_p[i+1] - x_p[i-1] ) / 3.\r\n M[i,i+1] = ( x_p[i+1] - x_p[i] ) /6.\r\n d[i,0 ] = ( y_p[i+1] - y_p[i] ) / ( x_p[i+1] - x_p[i] ) - ( y_p[i] - y_p[i-1] ) / ( x_p[i] - x_p[i-1] )\r\n \r\n M[0,0],M[-1,-1] = 1.,1. # compactly sets the BCs\r\n \r\n LU = lu.LU_decomp(M) # solves the matrix equations\r\n return lu.FB_sub(LU.Low, LU.Upp, d) # find and return 2nd derivatives\r","def pdf(self, x):\r\n return self._coef * reduce(mul, [xx ** (aa-1) for (xx, aa) in zip(x, self._alpha)])","def jacobian(self,x,p,fun):\n n = self.n\n y = fun(x,p)\n h = 1e-4\n nout = np.size(y)\n dfdx = np.zeros((nout,n))\n for j in range(n):\n dx1 = np.zeros(n)\n dx2 = np.zeros(n)\n dx1[j] = -h\n dx2[j] = h\n dfdx[:,j] = (fun(x+dx2,p)-fun(x+dx1,p))/(2*h)\n return dfdx","def DynamicsCheat(x, t, T0, alpha, cost, K, n, r):\n D=dmax*x[0]**n/(x[0]**n+K**n)\n #defune the degradation effect\n deg=0\n #define ODEs\n y=np.zeros([np.size(x)])\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\n y[1]=x[1]*(r*(1-cost)*(1-x[1])-D-alpha)#d Co/dt\n \n return y","def derivatives(self, x=[], function='sigmoid', alpha=0.01, y_pred = [], y = []):\n if function == \"sigmoid\":\n dadz = self.activation(x,\"sigmoid\")*(1-self.activation(x,\"sigmoid\"))\n return dadz\n\n if function == \"swish\":\n dadz = self.activation(x,\"sigmoid\") + x * self.activation(x,\"sigmoid\") * (1-self.activation(x,\"sigmoid\"))\n return dadz\n \n if function == \"linear\":\n dadz = np.ones(np.shape(x))\n return dadz\n\n if function == \"relu\":\n dadz = np.greater(x, 0).astype(int)\n return dadz\n\n if function == \"leakyrelu\":\n dadz = 1 * (x > 0) + alpha * (x<0)\n return dadz\n \n if function == \"mse\":\n assert(np.shape(y_pred)) == np.shape(y)\n if y.ndim > 1:\n m = np.shape(y)[0] #number of samples\n n = np.shape(y)[1] #number of output elements\n dCdy_pred = np.sum((y_pred - y), axis=0)*(1/(m*n))*2\n\n else:\n m = 1\n n = len(y) \n dCdy_pred = (y_pred - y)*(1/(m*n))*2\n return dCdy_pred","def _compute_correction(self, initial_state, final_state, a, b, c, s):\r\n pertub = self.pertub\r\n pertub_s = pertub *10\r\n \r\n pred_no_pertub = self._motion_update_one_shot(initial_state, a, b, c, s)\r\n pred_pertub_a = self._motion_update_one_shot(initial_state, a +pertub, b, c, s)\r\n pred_pertub_b = self._motion_update_one_shot(initial_state, a, b +pertub, c, s)\r\n # no need to correct C, C is constrained by kappa_final\r\n # # pred_pertub_c = self._motion_update_one_shot(initial_state, a, b, c +pertub, s)\r\n pred_pertub_s = self._motion_update_one_shot(initial_state, a, b, c, s +pertub_s)\r\n\r\n d_state = np.zeros((3,1))\r\n d_pertub_state = np.zeros((3,3))\r\n Jacobian = np.zeros((3,3))\r\n for i in range(0, 3):\r\n d_pertub_state[i][0] = (final_state[i] - pred_pertub_a[i]) # a\r\n d_pertub_state[i][1] = (final_state[i] - pred_pertub_b[i]) # b\r\n # d_pertub_state[i][2] = (final_state[i] - pred_pertub_c[i]) # c (no update)\r\n d_pertub_state[i][2] = (final_state[i] - pred_pertub_s[i]) # s\r\n \r\n d_state[i] = final_state[i] - pred_no_pertub[i]\r\n \r\n Jacobian[i][0] = (d_pertub_state[i][0] - d_state[i])/pertub # a\r\n Jacobian[i][1] = (d_pertub_state[i][1] - d_state[i])/pertub # b\r\n # Jacobian[i][2] = (d_pertub_state[i][2] - d_state[i])/pertub # c (no update)\r\n Jacobian[i][2] = (d_pertub_state[i][2] - d_state[i])/pertub_s # s\r\n\r\n # inv_Jacobian = np.linalg.inv(Jacobian)\r\n inv_Jacobian = np.linalg.pinv(Jacobian)\r\n correction = np.dot(inv_Jacobian, d_state)\r\n # pdb.set_trace()\r\n return correction","def grad_wrt_L(samples, laplacian, activations, diffusion_factors):\n num_vertices = samples.shape[1]\n grad = np.zeros(shape=(num_vertices, num_vertices))\n eigenvalues, eigenvectors = np.linalg.eigh(laplacian)\n for i, tau in enumerate(diffusion_factors):\n H_tau = activations[:, num_vertices*i:num_vertices*(i+1)]\n A = H_tau.T @ samples\n grad -= 2 * (- tau * grad_tr_A_exp_L(- tau * eigenvalues, eigenvectors, A))\n for j, tau_bis in enumerate(diffusion_factors):\n H_tau_bis = activations[:, num_vertices*j:num_vertices*(j+1)]\n A = H_tau_bis.T @ H_tau\n grad += - ((tau+tau_bis) * grad_tr_A_exp_L(-(tau+tau_bis)*eigenvalues, eigenvectors, A))\n return grad","def derivative_func(t, x, Approx_func):\n return x.dot(Approx_func)","def cofiCostFunc(self,params, *args):\n\t\tY, R, num_users, num_products, num_features,l = args[0], args[1],args[2], args[3],args[4],args[5]\n\n\t\taux = params.reshape((num_products + num_users, num_features))\n\n\t\tX = aux[0:num_products , :]\n\n\t\tTheta = aux[num_products:, :] \n\n\t\ttest = np.dot(X,Theta.transpose())\n\t\ttest = test - Y\n\t\ttest = np.multiply(test , R)\n\t\ttest = np.power(test,2)\n\t\ttest = test.sum()\n\t\ttest = 0.5 * test\n\n\t\tJ = 0;\n\t\tregularization = (l * 0.5) * np.power(X,2).sum() + np.power(Theta,2).sum()\n\n\t\tJ = test# + regularization\n\n\t\treturn J","def grad(y, y_pred, z, act_fn):\n return (y_pred - y) * act_fn.grad(z)","def _evalAndDer(self, x):\n m = len(x)\n fx = np.zeros((m, self.funcCount))\n for j in range(self.funcCount):\n fx[:, j] = self.functions[j](x)\n i = self.argcompare(fx, axis=1)\n y = fx[np.arange(m), i]\n dydx = np.zeros_like(y)\n for j in range(self.funcCount):\n c = i == j\n dydx[c] = self.functions[j].derivative(x[c])\n return y, dydx","def _evalAndDer(self, x):\n m = len(x)\n fx = np.zeros((m, self.funcCount))\n for j in range(self.funcCount):\n fx[:, j] = self.functions[j](x)\n i = self.argcompare(fx, axis=1)\n y = fx[np.arange(m), i]\n dydx = np.zeros_like(y)\n for j in range(self.funcCount):\n c = i == j\n dydx[c] = self.functions[j].derivative(x[c])\n return y, dydx","def gradient(init_par, alpha, delta, obs, sigma_obs, ccoef, N):\n\n\n\t## Initial parameters\n\n\tparallax, v, sigma_v = init_par[:-4], init_par[-4:-1], init_par[-1] \n\tplx_obs, mualpha_obs, mudelta_obs = obs[:, 0], obs[:, 1], obs[:, 2]\n\n\t### Define normal triad and proper motions\n\tp, q, r = normalTriad(alpha, delta)\n\tmualpha_mod = np.dot(np.transpose(p),v)*parallax/_A\n\tmudelta_mod = np.dot(np.transpose(q),v)*parallax/_A\n\t\n\tplx_mod, mualpha_mod, mudelta_mod = parallax, mualpha_mod, mudelta_mod\n\tsigma_plx, sigma_mualpha, sigma_mudelta = np.transpose(sigma_obs)\n\ta,like, expo, detD = np.ones(N),np.ones(N),np.ones(N), np.ones(N) \n\n\t### Eq. 8 in Lindegren+2000 (Covariance Matrix)\n\tC = np.zeros((3,3,N),dtype=np.float64)\n\tC[0,0,:],C[1,1,:],C[2,2,:] = sigma_plx**2.,sigma_mualpha**2., sigma_mudelta**2.\n\tcorr_coefficient_plx_mualpha, corr_coefficient_plx_mudelta, corr_coefficient_mualpha_mudelta = np.zeros(N), np.zeros(N), np.zeros(N)\n\tcorr_coefficient_plx_mualpha[:], corr_coefficient_plx_mudelta[:], corr_coefficient_mualpha_mudelta[:] = ccoef[:, 0], ccoef[:, 1], ccoef[:, 2] \n\t\n\tC[0,1,:], C[0,2,:] = corr_coefficient_plx_mualpha*sigma_plx*sigma_mualpha, corr_coefficient_plx_mudelta*sigma_plx*sigma_mudelta\n\tC[1,0,:], C[1,2,:] = corr_coefficient_plx_mualpha*sigma_plx*sigma_mualpha, corr_coefficient_mualpha_mudelta*sigma_mualpha*sigma_mudelta\n\tC[2,0,:], C[2,1,:] = corr_coefficient_plx_mudelta*sigma_plx*sigma_mudelta, corr_coefficient_mualpha_mudelta*sigma_mualpha*sigma_mudelta\n\n\t### Eq. 16 in Lindegren+2000 (Definition of D matrix)\t\n\tE = np.zeros((3,3,N),dtype=np.float64)\n\tE[1,1,:],E[2,2,:] = (sigma_v*parallax[:]/_A)**2., (sigma_v*parallax[:]/_A)**2.\n\tD,invD = np.zeros((3,3,N),dtype=np.float64),np.zeros((3,3,N),dtype=np.float64)\n\tD = np.add(E,C)\n\tfor i in range(N):\n\t\tdetD[i] = matrix_det(D[:,:,i]) \n\t\tinvD[:,:,i] = matrix_inv(D[:,:,i])\n\t\t\n\t\n\ta_c = np.ones((3,N))\n\ta_c = [plx_obs - plx_mod, mualpha_obs - mualpha_mod, mudelta_obs-mudelta_mod]\n\t\n\t### First derivatives in Eq. A3 \n\tcprime_pi, cprime_vx, cprime_vy, cprime_vz, = np.ones((3,N)), np.ones((3,N)), \\\n\t\t\t\t\t\t\tnp.ones((3,N)), np.ones((3,N)), \n\tcprime_pi[0,:] = 1.\n\tcprime_pi[1,:] = np.dot(np.transpose(p),v)/_A\n\tcprime_pi[2,:] = np.dot(np.transpose(q),v)/_A\n\t\n\tcprime_vx[0,:] = 0.\n\tcprime_vx[1,:] = -np.sin(alpha)*plx_mod/_A \n\tcprime_vx[2,:] = -np.sin(delta)*np.cos(alpha)*plx_mod/_A\n\n\t\n\tcprime_vy[0,:] = 0.\n\tcprime_vy[1,:] = np.cos(alpha)*plx_mod/_A \n\tcprime_vy[2,:] = -np.sin(delta)*np.sin(alpha)*plx_mod/_A\n\n\tcprime_vz[0,:] = 0.\n\tcprime_vz[1,:] = 0. \n\tcprime_vz[2,:] = np.cos(delta)*plx_mod/_A\n\n\tdlnd_dpi, dlnd_dsigmav = np.zeros(N), np.zeros(N)\n\tde_dpi, de_dsigmav = np.zeros(N), np.zeros(N)\n\t\n\n\t### See Eq. A5 \n\tde_dpi[:] = ((sigma_v/_A)**2.)*2.*plx_mod[:]\n\tde_dsigmav[:] = ((plx_mod[:]/_A)**2.)*2.*sigma_v\n\t\n\tdlnd_dpi[:] = (invD[1,1,:] + invD[2,2,:])*de_dpi[:] \n\tdlnd_dsigmav[:] = (invD[1,1,:] + invD[2,2,:])*de_dsigmav[:]\n\t\n\t\n\t\n\t### See Eq. A6\n\tdG_dpi, dG_dsigmav = np.zeros((3,3,N)), np.zeros((3,3,N)) \n\t\n\tdG_dpi[0,0,:], dG_dpi[0,1,:], dG_dpi[0,2,:] = (-invD[0,1,:]*invD[1, 0, :] - invD[0, 2, :]*invD[2,0,:])*de_dpi[:], \\\n\t\t\t\t\t\t (-invD[0,1,:]*invD[1, 1, :] - invD[0,2,:]*invD[2, 1, :])*de_dpi[:], \\\n\t\t\t\t\t\t (-invD[0,1,:]*invD[1,2,:] - invD[0,2,:]*invD[2,2,:])*de_dpi[:]\n\tdG_dpi[1,0,:], dG_dpi[1,1,:], dG_dpi[1,2,:] = (-invD[1,1,:]*invD[1, 0, :] - invD[1, 2, :]*invD[2,0,:])*de_dpi[:], \\\n\t\t\t\t\t\t (-invD[1,1,:]*invD[1, 1, :] - invD[1,2,:]*invD[2, 1, :])*de_dpi[:], \\\n\t\t\t\t\t\t (-invD[1,1,:]*invD[1,2,:] - invD[1,2,:]*invD[2,2,:])*de_dpi[:]\n\tdG_dpi[2,0,:], dG_dpi[2,1,:], dG_dpi[2,2,:] = (-invD[2,1,:]*invD[1, 0, :] - invD[2, 2, :]*invD[2,0,:])*de_dpi[:], \\\n\t\t\t\t\t\t (-invD[2,1,:]*invD[1, 1, :] - invD[2,2,:]*invD[2, 1, :])*de_dpi[:], \\\n\t\t\t\t\t\t (-invD[2,1,:]*invD[1,2,:] - invD[2,2,:]*invD[2,2,:])*de_dpi[:]\n\t\n\n\tdG_dsigmav[0,0,:], dG_dsigmav[0,1,:], dG_dsigmav[0,2,:] = (-invD[0,1,:]*invD[1, 0, :] - invD[0, 2, :]*invD[2,0,:])*de_dsigmav[:], \\\n\t\t\t\t\t\t\t\t (-invD[0,1,:]*invD[1, 1, :] - invD[0,2,:]*invD[2, 1, :])*de_dsigmav[:], \\\n\t\t\t\t\t\t\t\t (-invD[0,1,:]*invD[1,2,:] - invD[0,2,:]*invD[2,2,:])*de_dsigmav[:]\n\tdG_dsigmav[1,0,:], dG_dsigmav[1,1,:], dG_dsigmav[1,2,:] = (-invD[1,1,:]*invD[1, 0, :] - invD[1, 2, :]*invD[2,0,:])*de_dsigmav[:], \\\n\t\t\t\t\t\t\t\t (-invD[1,1,:]*invD[1, 1, :] - invD[1,2,:]*invD[2, 1, :])*de_dsigmav[:], \\\n\t\t\t\t\t\t\t\t (-invD[1,1,:]*invD[1,2,:] - invD[1,2,:]*invD[2,2,:])*de_dsigmav[:]\n\tdG_dsigmav[2,0,:], dG_dsigmav[2,1,:], dG_dsigmav[2,2,:] = (-invD[2,1,:]*invD[1, 0, :] - invD[2, 2, :]*invD[2,0,:])*de_dsigmav[:], \\\n\t\t\t\t\t\t\t\t (-invD[2,1,:]*invD[1, 1, :] - invD[2,2,:]*invD[2, 1, :])*de_dsigmav[:], \\\n\t\t\t\t\t\t\t\t (-invD[2,1,:]*invD[1,2,:] - invD[2,2,:]*invD[2,2,:])*de_dsigmav[:]\n\n\tf_dpi = np.zeros((N), dtype=np.float64) \n\t\n\t\n\tfor i in range(N):\n\t\tf_dpi_1, f_dpi_3 = 0., 0.0 \n\t\tfor ia in range(3):\n\t\t\tfor ib in range(3):\n\t\t\t\tf_dpi_1 += invD[ia,ib,i]*cprime_pi[ia,i]*a_c[ib][i]\n\t\t\t\tf_dpi_3 += (-0.5)*(dG_dpi[ia,ib,i]*a_c[ia][i]*a_c[ib][i])\n\t\t\t\t\t\n\t\tf_dpi_2 = (-0.5)*dlnd_dpi[i]\n\t\tf_dpi[i] = f_dpi_1 + f_dpi_2 + f_dpi_3\n\t\t\n\n\tf_vx, f_vy, f_vz, f_sigmav = np.zeros(N), np.zeros(N), np.zeros(N), np.zeros(N) \n\n\tf_vx = np.sum(invD[0,0,:]*cprime_vx[0,:]*a_c[0][:] + invD[0,1,:]*cprime_vx[0,:]*a_c[1][:] + invD[0,2,:]*cprime_vx[0,:]*a_c[2][:] + \\\n\t\t invD[1,0,:]*cprime_vx[1,:]*a_c[0][:] + invD[1,1,:]*cprime_vx[1,:]*a_c[1][:] + invD[1,2,:]*cprime_vx[1,:]*a_c[2][:] + \\\n\t\t invD[2,0,:]*cprime_vx[2,:]*a_c[0][:] + invD[2,1,:]*cprime_vx[2,:]*a_c[1][:] + invD[2,2,:]*cprime_vx[2,:]*a_c[2][:])\n\t\n\tf_vy = np.sum(invD[0,0,:]*cprime_vy[0,:]*a_c[0][:] + invD[0,1,:]*cprime_vy[0,:]*a_c[1][:] + invD[0,2,:]*cprime_vy[0,:]*a_c[2][:] + \\\n\t\t invD[1,0,:]*cprime_vy[1,:]*a_c[0][:] + invD[1,1,:]*cprime_vy[1,:]*a_c[1][:] + invD[1,2,:]*cprime_vy[1][:]*a_c[2][:] + \\\n\t\t invD[2,0,:]*cprime_vy[2,:]*a_c[0][:] + invD[2,1,:]*cprime_vy[2,:]*a_c[1][:] + invD[2,2,:]*cprime_vy[2,:]*a_c[2][:])\n\n\tf_vz = np.sum(invD[0,0,:]*cprime_vz[0,:]*a_c[0][:] + invD[0,1,:]*cprime_vz[0,:]*a_c[1][:] + invD[0,2,:]*cprime_vz[0,:]*a_c[2][:] + \\\n\t\t invD[1,0,:]*cprime_vz[1,:]*a_c[0][:] + invD[1,1,:]*cprime_vz[1,:]*a_c[1][:] + invD[1,2,:]*cprime_vz[1,:]*a_c[2][:] + \\\n\t\t invD[2,0,:]*cprime_vz[2,:]*a_c[0][:] + invD[2,1,:]*cprime_vz[2,:]*a_c[1][:] + invD[2,2,:]*cprime_vz[2,:]*a_c[2][:])\n\t\n\tf_sigmav = np.sum(-0.5*(dG_dsigmav[0,0,:]*a_c[0][:]*a_c[0][:] + dG_dsigmav[0,1,:]*a_c[1][:]*a_c[0][:]+ dG_dsigmav[0,2,:]*a_c[2][:]*a_c[0][:] + \\\n\t\t dG_dsigmav[1,0,i]*a_c[1][:]*a_c[0][:] + dG_dsigmav[1,1,:]*a_c[1][:]*a_c[1][:]+ dG_dsigmav[1,2,:]*a_c[1][:]*a_c[2][:] + \t\n\t\t dG_dsigmav[2,0,i]*a_c[2][:]*a_c[0][:] + dG_dsigmav[2,1,:]*a_c[2][:]*a_c[1][:]+ dG_dsigmav[2,2,:]*a_c[2][:]*a_c[2][:]))\n\t\n\n\tf_sigmav = f_sigmav - 0.5*np.sum(dlnd_dsigmav)\t\n\tf = np.concatenate((f_dpi, np.array([f_vx, f_vy, f_vz, f_sigmav]))) ### Grad L(theta), see Eq. 17\n\treturn -2.*f \t\t\t\t\t\t ### Grad U(theta), see Eq. 18","def c(\n dp: np.ndarray,\n ddp: np.ndarray,\n ) -> np.ndarray:\n\n return \\\n np.sqrt((ddp[2, :] * dp[1, :] - dp[2, :] * ddp[1, :])**2 +\n (ddp[0, :] * dp[2, :] - dp[0, :] * ddp[2, :])**2 +\n (ddp[1, :] * dp[0, :] - dp[1, :] * ddp[0, :])**2) / \\\n (dp[0, :]**2 + dp[1, :]**2 + dp[2, :]**2)**1.5","def test_deriv_cost_function():\n # Setup scenario\n b_lower = 0.35\n b = 0.6\n v = [1.0, 2.0, 3.0]\n\n # Calculate expected result\n n = len(v)\n tmp = np.ones(n) * (b-b_lower)\n ps = [x**(k-1) for k,x in zip(range(n), tmp)]\n bs = np.array([i * x for i,x in zip(range(n), ps)])\n alphas = np.array(v)\n expected = np.dot(alphas, bs)\n\n # Calculate actual result\n actual = deriv_cost_function(b_lower, v, b)\n \n # Compare\n assert expected == actual","def derivative(a, y, z):\n return (a - y) * Sigmoid.derivative(z)","def costFunction(self):\n priorDiff = np.matrix(self.model.stateVector - self.model.prior).T\n measurementDiff = np.matrix(self.model.observation\n - self.model.modelCalculation).T\n chisq = measurementDiff.T * self.errSinv * measurementDiff\n chisq += priorDiff.T * self.priorSinv * priorDiff\n \n return chisq[0,0]","def get_y_depletion(accrate, x0, z):\n return 6.8e8 * (accrate/0.1) * (0.01/z) * (x0/0.71)","def partial_derivative(self, parameter_location):\n self.decrement_parameter(parameter_location)\n cost_minus = self.evaluate_function()\n\n self.increment_parameter(parameter_location)\n self.increment_parameter(parameter_location)\n cost_plus = self.evaluate_function()\n\n derivative = self._derivative(cost_minus, cost_plus)\n\n self.decrement_parameter(parameter_location)\n return derivative","def fun(_, y):\n return np.array([-self.r * self.beta * y[1] * y[0] / self.N,\n self.r * self.beta * y[1] * y[0] / self.N - self.gamma * y[1],\n self.gamma * y[1]])","def f(t, x, y):\n Iq, UC, U = x # time continous state vector\n dIq = (Uq(t) - R*Iq - UC - U) / L\n dUC = Iq / C\n dU = Iq / Cp\n return array([dIq, dUC, dU])","def fitness(self, x):\n u = np.asarray([x[0]])\n C = self.C_func(u)\n P = self.P\n return np.asarray([np.sum(np.sum((C - P) ** 2, axis=0) ** (1 / 2))])","def cost_derivation(update_param: np.ndarray,\n dependent_param: np.ndarray,\n label: int\n ) -> np.ndarray:\n return (sigmoid(update_param @ dependent_param) - label)*dependent_param","def f(X, params):\r\n x_i, x_i1, y_i, y_i1, y_ip, y_ip1 = params\r\n A = (x_i1 - X) / (x_i1 - x_i)\r\n B = (X - x_i) / (x_i1 - x_i)\r\n C = (1./6) * (A**3 - A) * (x_i1-x_i)**2 \r\n D = (1./6) * (B**3 - B) * (x_i1-x_i)**2\r\n return A*y_i + B*y_i1 + C*y_ip + D*y_ip1","def _l1m_objective(a,X,*args):\n \n return(np.sum(np.apply_along_axis(_euclidnorm,1,_diffmat_objective(a,X))))","def f1(x, a, b):\n #return x**43 - b*x**42 + x**7 - x**6 * a + 84*x - 42 * b - 42 * a\n return (x**42 + 42)/(x-a) + (x**6 + 42)/(x-b)","def coherence_partial_spec(fxy, fxx, fyy, fxr, fry, frr):\r\n coh = coherency_spec\r\n Rxr = coh(fxr, fxx, frr)\r\n Rry = coh(fry, fyy, frr)\r\n Rxy = coh(fxy, fxx, fyy)\r\n\r\n return (((np.abs(Rxy - Rxr * Rry)) ** 2) /\r\n ((1 - ((np.abs(Rxr)) ** 2)) * (1 - ((np.abs(Rry)) ** 2))))","def b_gradient_descent(self, LB,UB,eta, tol,iter):\n bgd=[]\n bgd_x=[LB]\n iteration=0\n # current_pt=X\n first_derivative=sym.diff(self.gdfunc)\n #print(first_derivative)\n x=sym.Symbol('x')\n first_derivative=sym.lambdify(x,first_derivative)\n learn_rate=eta\n \n new_x=LB\n bgd_x.append(LB)\n \n for i in range(iter):\n for j in np.arange(LB,UB,0.1):\n prev_x=new_x\n new_x=prev_x-(learn_rate*first_derivative(prev_x))\n #print(\"i = \",j,\"gradient =\",(learn_rate*first_derivative(j)),iteration)\n iteration=iteration+1\n #print(iteration)\n if iteration >=iter:\n break \n if new_x <= tol:\n #print(\"new_x = \",new_x,\"gradient =\",(learn_rate*first_derivative(prev_x)), iteration) \n break\n \n \n \n \n #print(new_x)\n bgd_x.append(new_x)\n \n \n bgd.append(bgd_x)\n bgd.append(new_x)\n bgd.append(iteration)\n\n return bgd","def darcy_func(self):\n i, o = self.inl[0].to_flow(), self.outl[0].to_flow()\n\n if abs(i[0]) < 1e-4:\n return i[1] - o[1]\n\n visc_i = visc_mix_ph(i, T0=self.inl[0].T.val_SI)\n visc_o = visc_mix_ph(o, T0=self.outl[0].T.val_SI)\n v_i = v_mix_ph(i, T0=self.inl[0].T.val_SI)\n v_o = v_mix_ph(o, T0=self.outl[0].T.val_SI)\n\n re = 4 * abs(i[0]) / (np.pi * self.D.val * (visc_i + visc_o) / 2)\n\n return ((i[1] - o[1]) - 8 * abs(i[0]) * i[0] * (v_i + v_o) / 2 *\n self.L.val * lamb(re, self.ks.val, self.D.val) /\n (np.pi ** 2 * self.D.val ** 5))","def activ_fn_derivative(z):\n return 1 - np.square(np.tanh(z))","def grad(self, A, y, x):\n z = y * A.dot(x) # decision value for each observation\n grad_x = -1*A[z < 1].T.dot(y[z < 1])\n # Gradient normalized by the num obs\n return grad_x / y.size","def _calc_var(self, f, a, b, z):\n\n c_1 = (t.exp(a[...,0] * f[...,0] + b[...,0]) *\n (a[...,0]**2 * f[...,0]**2\n - 2 * a[...,0] * f[...,0] + 2)\n ) / a[...,0]**3\n c_2 = ((t.exp(a[...,1:-1] * f[...,1:] + b[...,1:-1]) *\n (a[...,1:-1]**2 * f[...,1:]**2 - 2 * a[...,1:-1] * f[...,1:] + 2) -\n t.exp(a[...,1:-1] * f[...,:-1] + b[...,1:-1]) *\n (a[...,1:-1]**2 * f[...,:-1]**2 - 2 * a[...,1:-1] * f[...,:-1] + 2)\n ) / a[...,1:-1]**3).sum(-1)\n c_3 = (t.exp(a[...,-1] * f[...,-1] + b[...,-1]) *\n (a[...,-1]**2 * f[...,-1]**2 - 2 * a[...,-1] * f[...,-1] + 2)\n ) / a[...,-1]**3\n\n return 1/z * (c_1 + c_2 + c_3)"],"string":"[\n \"def cost_derivative(self, output_activations, y):\\r\\n return (output_activations-y)\",\n \"def cost_derivative(output_activations, y):\\n return (output_activations - y)\",\n \"def cost_derivative(self, output_activations, y):\\n\\t\\treturn (output_activations - y)\",\n \"def deriv_costFunction(self, x, y):\\n self.yEst = self.forward_propagate(x)\\n\\n delta_o = np.multiply( ( self.yEst - y ), self.deriv_sigmoid(self.z_o) )\\n #partial deriv of cost wrt hidden -> output weights\\n partial_J_w_ho = np.dot( self.a_h.T, delta_o )\\n\\n ones_o = np.ones( delta_o.shape[0] )\\n #partial deriv of cost wrt output biases\\n partial_J_b_o = np.dot( ones_o, delta_o )\\n\\n delta_h = np.dot( delta_o, self.w_ho.T ) * self.deriv_sigmoid( self.z_h )\\n #partial deriv of cost wrt input -> hidden weights\\n partial_J_w_ih = np.dot( x.T, delta_h )\\n \\n ones_h = np.ones( delta_h.shape[0] )\\n #partial deriv of cost wrt hidden biases\\n partial_J_b_h = np.dot( ones_h, delta_h)\\n\\n return partial_J_w_ih, partial_J_w_ho, partial_J_b_h, partial_J_b_o\",\n \"def _fv(self):\\n return self.beta * (self.x ** self.c)\",\n \"def F(cst, x):\\n [u0, v0, u1, v1, u2, v2, coeffs] = cst\\n [u, v, g1, g2, g3] = x\\n a = g1*u1 - u0\\n b = g2*u2 - u0\\n c = g3*u - u0\\n l = g1*v1 - v0 \\n m = g2*v2 - v0\\n n = g3*v - v0\\n r = g1 - 1\\n s = g2 - 1\\n t = g3 - 1\\n return np.array([\\n coeffs[0]*(a**2-l**2) + 2*coeffs[1]*(a*b-l*m) + coeffs[2]*(b**2-m**2) + 2*coeffs[3]*(a*c-l*n) + 2*coeffs[4]*(b*c-m*n) + c**2 - n**2,\\n coeffs[0]*(l**2-r**2) + 2*coeffs[1]*(l*m-r*s) + coeffs[2]*(m**2-s**2) + 2*coeffs[3]*(l*n-r*t) + 2*coeffs[4]*(m*n-s*t) + n**2 - t**2,\\n coeffs[0]*a*l + coeffs[1]*(l*b+m*a) + coeffs[2]*m*b + coeffs[3]*(l*c+n*a) + coeffs[4]*(m*c+b*n) + c*n,\\n coeffs[0]*a*r + coeffs[1]*(r*b+s*a) + coeffs[2]*s*b + coeffs[3]*(r*c+t*a) + coeffs[4]*(s*c+b*t) + c*t,\\n coeffs[0]*r*l + coeffs[1]*(l*s+m*r) + coeffs[2]*m*s + coeffs[3]*(l*t+n*r) + coeffs[4]*(m*t+s*n) + t*n \\n ])\",\n \"def cost_derivative(self, output_activations, y):\\n return 2 * (output_activations - y)\",\n \"def cost_derivative(self,output_results,y):\\r\\n\\t\\treturn (output_results-y)\",\n \"def _gradients(self, partial):\\r\\n dL_dfhat, I_KW_i = self._shared_gradients_components()\\r\\n dlik_dthetaL, dlik_grad_dthetaL, dlik_hess_dthetaL = self.noise_model._laplace_gradients(self.f_hat, self.data, extra_data=self.extra_data)\\r\\n\\r\\n #len(dlik_dthetaL)\\r\\n num_params = len(self._get_param_names())\\r\\n # make space for one derivative for each likelihood parameter\\r\\n dL_dthetaL = np.zeros(num_params)\\r\\n for thetaL_i in range(num_params):\\r\\n #Explicit\\r\\n dL_dthetaL_exp = ( np.sum(dlik_dthetaL[:, thetaL_i])\\r\\n #- 0.5*np.trace(mdot(self.Ki_W_i, (self.K, np.diagflat(dlik_hess_dthetaL[thetaL_i]))))\\r\\n + np.dot(0.5*np.diag(self.Ki_W_i)[:,None].T, dlik_hess_dthetaL[:, thetaL_i])\\r\\n )\\r\\n\\r\\n #Implicit\\r\\n dfhat_dthetaL = mdot(I_KW_i, self.K, dlik_grad_dthetaL[:, thetaL_i])\\r\\n dL_dthetaL_imp = np.dot(dL_dfhat, dfhat_dthetaL)\\r\\n dL_dthetaL[thetaL_i] = dL_dthetaL_exp + dL_dthetaL_imp\\r\\n\\r\\n return dL_dthetaL\",\n \"def get_partial_derivatives(self) -> List[Callable]:\\n return [self.dfdm, self.dfdc]\",\n \"def c_coefficients(x1,x2,x3,y1,y2,y3,initial_slope,final_slope):\\n\\tC = c_matrix(x1,x2,x3)\\n\\ty = y_vector(x1,x2,x3,y1,y2,y3,initial_slope,final_slope)\\n\\tCCoefficients = np.dot(inv(C),y)\\n\\treturn(CCoefficients)\",\n \"def coefC(x0,y0,x1,y1):\\n return (x1*y0-x0*y1)/(x1-x0)\",\n \"def lp_acent(A,b,c,x_0):\\n #Parameters\\n b = b.flatten()\\n c = c.flatten()\\n ALPHA = 0.01\\n BETA = 0.5\\n EPSILON = 1e-6\\n MAXITERS = 100\\n if (np.min(x_0)<=0) and (np.linalg.norm>1e-3):\\n print 'failed' \\n return 0\\n #m = len(b)\\n #n = len(x_0)\\n lambda_hist = []\\n x = x_0\\n for iter in range(MAXITERS):\\n # H = np.diag(1/np.power(x,3))\\n g = c-np.power(x,-1)\\n #print g.shape\\n #solving KKT system\\n w = np.linalg.solve(np.dot(np.dot(A,np.diag(np.power(x,2))),A.T),\\n np.dot(np.dot(-A,np.diag(np.power(x,2))),g))\\n dx = np.dot(-np.diag(np.power(x,2)),np.dot(A.T,w)+g)\\n lambdasqr = np.dot(-g.T,dx) #dx'*T*dx: newton incremental\\n lambda_hist.append(lambdasqr/2)\\n if lambdasqr/2 <= EPSILON:\\n break\\n # backtracking line search\\n t = 1\\n # brin the point inside the domain\\n while np.min(x+t*dx)<=0:\\n t =BETA*t\\n while np.dot(c.T,np.dot(t,dx))-np.sum(np.log(x+t*dx))+np.sum(np.log(x))-ALPHA*t*np.dot(g.T,dx)>0:\\n t = BETA*t\\n x = x+t*dx\\n if iter == MAXITERS:\\n print 'ERROR: MAXITERS reached'\\n else:\\n #plt.figure()\\n #plt.plot(range(len(lambda_hist)),lambda_hist,'b-',range(len(lambda_hist)),lambda_hist,'bo')\\n return x,w,lambda_hist\",\n \"def costFun(self, x):\\n\\ttmp = x.reshape(self.inp_shape)\\n\\tc = np.float64(self.calcCost(np.asarray(tmp,dtype=np.float32))) + self.alpha * np.dot(x.T, x)\\n\\treturn c\",\n \"def get_partial_derivatives(self) -> List[Callable]:\\n return [self.dfda, self.dfdb, self.dfdc]\",\n \"def coefA(x0,y0,x1,y1):\\n return -(y1-y0)/(x1-x0)\",\n \"def compute_cost_derivative(AL, Y):\\n pass\",\n \"def gradient(C, w, b):\\n return list(partial_deriv(C, b)) + list(partial_deriv(C, wi) for wi in w)\",\n \"def jacobian(self, x):\\n x_ = np.atleast_2d(x)\\n if self.normalize:\\n x_ = (x_ - self.sample_mean) / self.sample_std\\n s_ = (self.samples - self.sample_mean) / self.sample_std\\n else:\\n s_ = self.samples\\n\\n fx, jf = self.reg_model(x_)\\n rx, drdx = self.corr_model(x=x_, s=s_, params=self.corr_model_params, dx=True)\\n y_grad = np.einsum('ikj,jm->ik', jf, self.beta) + np.einsum('ijk,jm->ki', drdx.T, self.gamma)\\n if self.normalize:\\n y_grad = y_grad * self.value_std / self.sample_std\\n if x_.shape[1] == 1:\\n y_grad = y_grad.flatten()\\n return y_grad\",\n \"def get_partial_derivatives(self) -> List[Callable]:\\n pass\",\n \"def cost_derivative_for_output(output_activations, y):\\n return output_activations - y\",\n \"def f(z, X, Y, _lambda):\\r\\n w = z[:-1]\\r\\n beta = np.squeeze(z[-1])\\r\\n term_1_d = (X * (Y[:, np.newaxis] - g(X.dot(w) + beta))).sum(axis=0)\\r\\n term_d_1 = (Y[:, np.newaxis] - g(X.dot(w) + beta)).sum() + 2 * _lambda * beta\\r\\n return np.hstack((term_1_d, term_d_1))[:, np.newaxis]\",\n \"def L_fun(x):\\n \\n f_x0 = f(ad.create_vector('x0', x0, seed_vector=x));\\n f_x0 = np.array(f_x0) #ensure that f_x0 is np.array\\n action = sum_values(ad.get_deriv(f_x0))\\n return action\",\n \"def get_partial_derivatives(self) -> List[Callable]:\\n return [self.dfdmu, self.dfdsig]\",\n \"def det(a, b, c):\\n d = (b[0]*c[1]-c[0]*b[1])+(c[0]*a[1]-a[0]*c[1])+(a[0]*b[1]-a[1]*b[0])\\n return d\",\n \"def compute_partials(self, inputs, partials):\\n SOC = inputs['SOC']\\n temperature = inputs['temperature']\\n P_bat = inputs['P_bat']\\n\\n # dI_dP\\n dV_dvoc = IR * self.exponential\\n dV_dT = - IR * self.voc * np.exp(alpha*(temperature[4, :] - T0)/T0) * alpha / T0\\n dVoc_dSOC = np.exp(SOC[0, :]) / (np.e-1)\\n\\n self.dI_dP = 1.0 / self.V\\n tmp = -P_bat/(self.V**2)\\n self.dI_dT = tmp * dV_dT\\n self.dI_dSOC = tmp * dV_dvoc * dVoc_dSOC\",\n \"def cd(x0,partial,learning_rate=0.01,iterations=10,**kwargs):\\n x = x0; N = len(x)\\n for i in range(iterations):\\n indices = random.sample(list(range(N)),N)\\n for j in indices:\\n x[j] -= learning_rate*partial(x0,j)\\n return x\",\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 cubic_evolve(self,nt=1):\\n #loop through time steps\\n for l in range(nt):\\n # temporary array\\n y_temp = np.zeros(self.y.shape[0])\\n # loop through array\\n for i in range(self.y.shape[0]):\\n # idx left to departure point\\n x_dep = self.x[i]-self.u[i]*self.dt\\n j = int(np.floor(x_dep/self.dx))\\n # alpha\\n a = (self.x[i]-self.u[i]*self.dt - j*self.dx)/self.dx\\n # calculate next time step\\n f = lambda x: x % self.y.shape[0] if x >= self.y.shape[0] else x\\n y_temp[i] = - a * (1-a)*(2-a)/6 * self.y[f(j-1)]\\n y_temp[i] += (1-a**2)*(2-a)/2 * self.y[f(j)]\\n y_temp[i] += a*(1+a)*(2-a)/2 * self.y[f(j+1)]\\n y_temp[i] -= a*(1-a**2)/6 * self.y[f(j+2)]\\n self.y = np.copy(y_temp)\\n return self.y\",\n \"def test_partial_sum_2d(self): # pylint:disable=no-self-use\\n x = [1, 2, 3]\\n y = [4, 5, 6]\\n c = [7, 8, 9]\\n\\n gamma = dcor_internals._partial_sum_2d(x, y, c)\\n expected_gamma = [17., 16., 15.]\\n\\n np.testing.assert_allclose(gamma, expected_gamma)\",\n \"def f(self, x: np.array) -> np.array:\\n return self.a * x**2 + self.b * x + self.c\",\n \"def slip_to_coefficients(x, y, a):\\n partials = np.zeros((x.size, 3))\\n partials[:, 0] = (x / a) * (9 * (x / a) / 8 - 3 / 4)\\n partials[:, 1] = (1 - 3 * (x / a) / 2) * (1 + 3 * (x / a) / 2)\\n partials[:, 2] = (x / a) * (9 * (x / a) / 8 + 3 / 4)\\n coefficients = np.linalg.inv(partials) @ y\\n return coefficients\",\n \"def _cost_function_derivative(self, y_pred, y, X, m):\\n\\n derivatives= np.zeros((X.shape[0],1))\\n for j in range(X.shape[0]):\\n auxsum = 0\\n for i in range(m):\\n auxsum+=(y_pred[0][i] -y[0][i])*X[j][i]\\n derivatives[j][0] = self.theta[j][0] - self.alpha * 1/m * auxsum\\n\\n #empty_derivatives = np.zeros((X.shape[0],1))\\n return derivatives\",\n \"def compute_partials(self, inputs, partials):\\n I_bat = inputs['I_bat']\\n SOC = inputs['SOC']\\n\\n self.dCh_dg, self.dCh_drho = KSfunction.derivatives(I_bat - self.Imax, self.rho)\\n self.dDs_dg, self.dDs_drho = KSfunction.derivatives(self.Imin - I_bat, self.rho)\\n self.dS0_dg, self.dS0_drho = KSfunction.derivatives(self.SOC0 - SOC, self.rho)\\n self.dS1_dg, self.dS1_drho = KSfunction.derivatives(SOC - self.SOC1, self.rho)\\n\\n self.dCh_dg = self.dCh_dg.flatten()\\n self.dCh_drho = self.dCh_drho.flatten()\\n self.dDs_dg = self.dDs_dg.flatten()\\n self.dDs_drho = self.dDs_drho.flatten()\\n self.dS0_dg = self.dS0_dg.flatten()\\n self.dS0_drho = self.dS0_drho.flatten()\\n self.dS1_dg = self.dS1_dg.flatten()\\n self.dS1_drho = self.dS1_drho.flatten()\",\n \"def fixed_cost(self):\\n return np.einsum('i->', self.c[self.f])\",\n \"def gradient(self, x):\\n u = np.asarray([x[0]])\\n C = self.C_func(u)\\n dC = self.dC_func(u, order=1)\\n P = self.P\\n numerator = np.sum((C - P) * dC, axis=0)\\n denominator = np.sum(np.sum((C - P) ** 2, axis=0) ** (1 / 2))\\n if np.abs(denominator) > 0:\\n gradient = numerator/denominator\\n else:\\n gradient = np.asarray(0)[np.newaxis]\\n return gradient\",\n \"def d_coefficients(x1,x2,x3,CCoefficients):\\n\\tDCoefficients = np.array([\\t(CCoefficients[1]-CCoefficients[0])/(3*(x2-x1)), \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t(CCoefficients[2]-CCoefficients[1])/(3*(x3-x2))\\t], \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\tfloat)\\n\\treturn(DCoefficients)\",\n \"def b_coefficients(x1,x2,x3,y1,y2,y3,CCoefficients,DCoefficients):\\n\\tBCoefficients = np.array([\\t((y2-y1)/(x2-x1)-CCoefficients[0]*(x2-x1) - DCoefficients[0]*((x2-x1)**2)), \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t((y3-y2)/(x3-x2)-CCoefficients[1]*(x3-x2) - DCoefficients[1]*((x3-x2)**2)) \\t]).astype(float)\\n\\treturn(BCoefficients)\",\n \"def df(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 dfx = 2 * D / x**3 + A / B**2 * math.exp(- x / B) - 42 * C / x**8\\n\\n return dfx\",\n \"def fit(self, f: callable, a: float, b: float, d: int, maxtime: float) -> callable:\\r\\n\\r\\n # replace these lines with your solution\\r\\n initial_T = time.time()\\r\\n\\r\\n def get_points(f, a, b, n):\\r\\n x = np.linspace(a, b, n)\\r\\n y_lst = f(x)\\r\\n y = np.array(y_lst)\\r\\n\\r\\n return x, y\\r\\n\\r\\n def build_vector(x, y, size, deg):\\r\\n if deg == size:\\r\\n y_n = y.sum()\\r\\n else:\\r\\n y_n = np.dot(y, (x ** (size - deg)))\\r\\n pol1 = np.zeros(size + 1)\\r\\n for i in range(size + 1):\\r\\n pol1[i] = (x ** (2 * size - deg - i)).sum()\\r\\n return pol1, y_n\\r\\n\\r\\n def build_coeff_matrix(f, a, b, n, d):\\r\\n x, y = get_points(f, a, b, n)\\r\\n deg = d\\r\\n b = np.array([])\\r\\n coeff_matrix = np.array([])\\r\\n for i in range(d + 1):\\r\\n x_n, y_n = build_vector(x, y, d, i)\\r\\n deg -= 1\\r\\n coeff_matrix = np.append(coeff_matrix, x_n)\\r\\n b = np.append(b, y_n)\\r\\n coeff_matrix = np.reshape(coeff_matrix, (d + 1, d + 1))\\r\\n return coeff_matrix, b\\r\\n\\r\\n def solve_coeff_matrix(coeff_matrix, b):\\r\\n A_inverse = np.linalg.inv(coeff_matrix)\\r\\n coeffs = A_inverse.dot(b)\\r\\n return coeffs\\r\\n\\r\\n def build_function_from_coeffs(coeffs):\\r\\n f = np.poly1d(coeffs)\\r\\n return f\\r\\n\\r\\n n = 100 # fisrt sample size\\r\\n while (time.time() - initial_T) + 0.2 < maxtime: # while i still have time loop again\\r\\n Ax, B = build_coeff_matrix(f, a, b, n, d=d)\\r\\n if time.time() - initial_T + 0.2 >= maxtime: # first break point\\r\\n break\\r\\n coeffs = solve_coeff_matrix(coeff_matrix=Ax, b=B)\\r\\n if time.time() - initial_T + 0.2 >= maxtime: # second break point\\r\\n break\\r\\n result = build_function_from_coeffs(coeffs)\\r\\n if time.time() - initial_T + 0.2 >= maxtime: # third break point\\r\\n break\\r\\n n += 200 # increasing sample size\\r\\n\\r\\n return result\",\n \"def c(\\n dp: np.ndarray,\\n ddp: np.ndarray,\\n ) -> np.ndarray:\\n\\n return \\\\\\n np.abs(ddp[0, :]*dp[1, :] - dp[0, :]*ddp[1, :]) / \\\\\\n (dp[0, :]**2 + dp[1, :]**2)**1.5\",\n \"def dV(X):\\n return -4 * a * np.power(X, 3) + 2 * b * X\",\n \"def compute_gradient(c, x, y):\\n\\n vectors = np.array([[0, 1], [0, -1], [1, 0], [-1, 0]])\\n rows, cols = c.shape\\n\\n result = np.empty_like(x)\\n\\n for i in nb.prange(rows):\\n for j in nb.prange(cols):\\n c_remainder = c[i, j] % 4\\n gradient_co = vectors[c_remainder]\\n result[i, j] = gradient_co[0] * x[i, j] + gradient_co[1] * y[i, j]\\n\\n return result\",\n \"def gradient_of_selection(f_jk,benefit_function,b,c=1,*params):\\n f_jk['gos'] = f_jk.A*(b*benefit_function(f_jk.j+1,f_jk.k+1,*params)-c) - f_jk.B*b*benefit_function(f_jk.j,f_jk.k+1,*params)\\n gos = f_jk.groupby('n')['gos'].sum() \\n gos = gos*(Z-gos.index.values)*gos.index.values/(Z**2)*DELTA\\n gos.loc[0]=gos.loc[100]=0\\n return gos\",\n \"def func_deriv(x,remain):\\n #df_x0 = -1*remain[0]/x[0]**2\\n #df_x1 = -1*remain[2]/x[1]**2\\n #df_x2 = -1*remain[1]/x[2]**2\\n return np.array(-1*remain/x**2)\",\n \"def V_fit(x, a, b, c, d, e, f):\\n x1 = x[0] # I\\n x2 = x[1] # dT\\n m = (a * x1 ** 2 + b * x1 + c)\\n b = (d * x1 ** 2 + e * x1 + f)\\n return m * x2 + b\",\n \"def partial ( index , func , x , h = 0 , I = 2 , err = False ) :\\n \\n if len(x) <= index :\\n raise AttributeError(\\\"Invalid argument length/index %d/%d\\\" % ( len(x) , index ) )\\n \\n _x = [ float(a) for a in x ]\\n \\n ## create wrapper function \\n def _wrap ( z ) :\\n _z = _x[index] \\n _x[index] = z\\n _r = func ( *_x )\\n _x[index] = _z\\n return _r\\n \\n x_i = _x[ index ]\\n return derivative ( _wrap , x = x_i , h = h , I = I , err = err )\",\n \"def _antipode(self, x, c):\\n lambda_x = self._lambda_x(x, c)\\n x_sqnorm = tf.reduce_sum(tf.pow(x, 2), axis=-1, keepdims=True)\\n scale = -1.0 / (lambda_x * c * x_sqnorm)\\n return scale * x\",\n \"def return_quadratic_cost_function_expansion_variables(\\n X,U,dt,\\n RunningCost=\\\"Minimize Input Energy\\\"):\\n\\n if type(RunningCost)==str:\\n assert RunningCost in ['Minimize Input Energy',\\n 'Minimize time away from target angle',\\n 'Minimize time away from target angular velocity'],\\\\\\n \\\"RunningCost must be either 'Minimize Input Energy','Minimize time away from target angle', or 'Minimize time away from target angular velocity'.\\\"\\n else:\\n assert type(RunningCost)==list, \\\"RunningCost must be a list of cost types.\\\"\\n for el in RunningCost:\\n assert type(el)==str, \\\"Each element of RunningCost must be a string. Not \\\" + str(type(el)) + \\\".\\\"\\n assert el in ['Minimize Input Energy',\\n 'Minimize time away from target angle',\\n 'Minimize time away from target angular velocity'],\\\\\\n \\\"Each element of RunningCost must be either 'Minimize Input Energy','Minimize time away from target angle', or 'Minimize time away from target angular velocity'. '\\\" + el + \\\"' not accepted.\\\"\\n\\n # returns a list of length len(Time)-1, each element with shape (1,1), where n is the number of states.\\n l_func = return_l_func(RunningCost=RunningCost)\\n l = list(\\n map(\\n lambda X,U: l_func(X,U,dt),\\n X[:,1:].T,\\n U\\n )\\n )\\n\\n # returns a list of length len(Time)-1, each element with shape (n,1), where n is the number of states.\\n lx_func = return_lx_func(RunningCost=RunningCost)\\n lx = list(\\n map(\\n lambda X,U: lx_func(X,U,dt),\\n X[:,1:].T,\\n U\\n )\\n )\\n\\n # returns a list of length len(Time)-1, each element with shape (m,1), where n is the number of states.\\n lu_func = return_lu_func(RunningCost=RunningCost)\\n lu = list(\\n map(\\n lambda X,U: lu_func(X,U,dt),\\n X[:,1:].T,\\n U\\n )\\n )\\n\\n # returns a list of length len(Time)-1, each element with shape (m,n), where m is the number of inputs and n is the number of states.\\n lux_func = return_lux_func(RunningCost=RunningCost)\\n lux = list(\\n map(\\n lambda X,U: lux_func(X,U,dt),\\n X[:,1:].T,\\n U\\n )\\n )\\n\\n # returns a list of length len(Time)-1, each element with shape (n,m), where n is the number of states and m is the number of inputs.\\n lxu_func = return_lxu_func(RunningCost=RunningCost)\\n lxu = list(\\n map(\\n lambda X,U: lxu_func(X,U,dt),\\n X[:,1:].T,\\n U\\n )\\n )\\n\\n # returns a list of length len(Time)-1, each element with shape (m,m), where m is the number of inputs.\\n luu_func = return_luu_func(RunningCost=RunningCost)\\n luu = list(\\n map(\\n lambda X,U: luu_func(X,U,dt),\\n X[:,1:].T,\\n U\\n )\\n )\\n\\n # returns a list of length len(Time)-1, each element with shape (n,n), where n is the number of states.\\n lxx_func = return_lxx_func(RunningCost=RunningCost)\\n lxx = list(\\n map(\\n lambda X,U: lxx_func(X,U,dt),\\n X[:,1:].T,\\n U\\n )\\n )\\n\\n return(l,lx,lu,lux,lxu,luu,lxx)\",\n \"def jacobian(self, b):\\n \\n # Substitute parameters in partial derivatives\\n subs = [pd.subs(zip(self._b, b)) for pd in self._pderivs]\\n # Evaluate substituted partial derivatives for all x-values\\n vals = [sp.lambdify(self._x, sub, \\\"numpy\\\")(self.xvals) for sub in subs]\\n # Arrange values in column-major order\\n return np.column_stack(vals)\",\n \"def DynamicsCo(x, t, T0, alpha, cost_co, cost_ch, K_co, K_ch, n, r):\\n y=np.zeros([np.size(x)])\\n D=np.zeros([2]) \\n #define fitnss\\n D[0]=dmax*x[0]**n/(K_co**n+x[0]**n) #cooperator\\n D[1]=dmax*x[0]**n/(K_ch**n+x[0]**n) #cheater \\n #degradation\\n deg=fmax*x[1]/(x[1]+Kd) \\n #ODE of eco-evo dynamics\\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\\n y[1]=x[1]*(r*(1-cost_co)*(1-x[1]-x[2])-D[0]-alpha)#d Co/dt\\n y[2]=x[2]*(r*(1-cost_ch)*(1-x[1]-x[2])-D[1]-alpha) #d Ch/dt\\n \\n return y\",\n \"def grad(self, x):\\n l2 = L2(1.0, rng=self.rng)\\n grad_Ab = 0\\n for i in xrange(len(self.A)):\\n Ai = self.A[i]\\n Ab = Ai.dot(x)\\n grad_Ab += Ai.T.dot(l2.grad(Ab))\\n\\n return self.l * grad_Ab\",\n \"def _evalAndDer(self, x):\\n if _isscalar(x):\\n pos = np.searchsorted(self.x_list, x)\\n if pos == 0:\\n y = self.coeffs[0, 0] + self.coeffs[0, 1] * (x - self.x_list[0])\\n dydx = self.coeffs[0, 1]\\n elif pos < self.n:\\n alpha = (x - self.x_list[pos - 1]) / (\\n self.x_list[pos] - self.x_list[pos - 1]\\n )\\n y = self.coeffs[pos, 0] + alpha * (\\n self.coeffs[pos, 1]\\n + alpha * (self.coeffs[pos, 2] + alpha * self.coeffs[pos, 3])\\n )\\n dydx = (\\n self.coeffs[pos, 1]\\n + alpha\\n * (2 * self.coeffs[pos, 2] + alpha * 3 * self.coeffs[pos, 3])\\n ) / (self.x_list[pos] - self.x_list[pos - 1])\\n else:\\n alpha = x - self.x_list[self.n - 1]\\n y = (\\n self.coeffs[pos, 0]\\n + x * self.coeffs[pos, 1]\\n - self.coeffs[pos, 2] * np.exp(alpha * self.coeffs[pos, 3])\\n )\\n dydx = self.coeffs[pos, 1] - self.coeffs[pos, 2] * self.coeffs[\\n pos, 3\\n ] * np.exp(alpha * self.coeffs[pos, 3])\\n else:\\n m = len(x)\\n pos = np.searchsorted(self.x_list, x)\\n y = np.zeros(m)\\n dydx = np.zeros(m)\\n if y.size > 0:\\n out_bot = pos == 0\\n out_top = pos == self.n\\n in_bnds = np.logical_not(np.logical_or(out_bot, out_top))\\n\\n # Do the \\\"in bounds\\\" evaluation points\\n i = pos[in_bnds]\\n coeffs_in = self.coeffs[i, :]\\n alpha = (x[in_bnds] - self.x_list[i - 1]) / (\\n self.x_list[i] - self.x_list[i - 1]\\n )\\n y[in_bnds] = coeffs_in[:, 0] + alpha * (\\n coeffs_in[:, 1]\\n + alpha * (coeffs_in[:, 2] + alpha * coeffs_in[:, 3])\\n )\\n dydx[in_bnds] = (\\n coeffs_in[:, 1]\\n + alpha * (2 * coeffs_in[:, 2] + alpha * 3 * coeffs_in[:, 3])\\n ) / (self.x_list[i] - self.x_list[i - 1])\\n\\n # Do the \\\"out of bounds\\\" evaluation points\\n y[out_bot] = self.coeffs[0, 0] + self.coeffs[0, 1] * (\\n x[out_bot] - self.x_list[0]\\n )\\n dydx[out_bot] = self.coeffs[0, 1]\\n alpha = x[out_top] - self.x_list[self.n - 1]\\n y[out_top] = (\\n self.coeffs[self.n, 0]\\n + x[out_top] * self.coeffs[self.n, 1]\\n - self.coeffs[self.n, 2] * np.exp(alpha * self.coeffs[self.n, 3])\\n )\\n dydx[out_top] = self.coeffs[self.n, 1] - self.coeffs[\\n self.n, 2\\n ] * self.coeffs[self.n, 3] * np.exp(alpha * self.coeffs[self.n, 3])\\n return y, dydx\",\n \"def cost_function(x, N, w, dt):\\n yh = np.abs(fftkernel(x, w / dt)) # density\\n # formula for density\\n C = np.sum(yh ** 2) * dt - 2 * np.sum(yh * x) * \\\\\\n dt + 2 / np.sqrt(2 * np.pi) / w / N\\n C = C * N * N\\n # formula for rate\\n # C = dt*sum( yh.^2 - 2*yh.*y_hist + 2/sqrt(2*pi)/w*y_hist )\\n return C, yh\",\n \"def calc_nonlinear_rhs(self, A):\\n cff = -1/(4*self.dx) \\n N = self.N\\n rhs = np.zeros((N,))\\n alpha = self.alpha\\n\\n # Central difference for the interior points\\n rhs[1:N-1] = cff*alpha[1:-1] * (A[2:]*A[2:] - A[0:-2]*A[0:-2])\\n\\n # Boundary term forward difference\\n rhs[0] = 0.5*cff*alpha[0]*(A[1]*A[1] - A[0]*A[0])\\n\\n return rhs\",\n \"def compute_cost(AL, Y, parameters ,lambd):\\n L = len(parameters) // 2\\n m = Y.shape[1]\\n cost = -1 / m * np.sum(np.nan_to_num(Y * np.log(AL) + (1-Y) * np.log(1-AL)))\\n cost+= 0.5*(lambd/m)*sum(np.linalg.norm(parameters['W' + str(i)])**2 for i in range(1,L))\\n return cost\",\n \"def linear_evolve(self,nt=1):\\n for l in range(nt):\\n y_temp = np.empty(self.y.shape[0])\\n for i in range(self.y.shape[0]):\\n \\n # idx left to the departure point\\n j = int(np.floor((self.x[i]-self.u[i]*self.dt)/self.dx))\\n # idx right to the departure point\\n k = j+1\\n print i, j, k\\n # linear interpolation\\n alpha = (self.x[i]-self.u[i]*self.dt - j*self.dx)/self.dx\\n y_temp[i] = (1-alpha)*self.y[j] + alpha*self.y[k]\\n # copy array to current time\\n self.y = np.copy(y_temp)\\n stop\\n #return current varibale\\n return self.y\",\n \"def _linear_dispersion_coeff(beta, q):\\n return np.sqrt(beta) / (2 * np.sin(np.pi * q))\",\n \"def F_lambda(theta, b, q, d, r, M, C, sigma_xx, L):\\r\\n theta = np.reshape(theta, (q, r))\\r\\n b = np.reshape(b, (d, r))\\r\\n total = 0.0\\r\\n for k in range(d):\\r\\n for l in range(r):\\r\\n total += np.linalg.norm(b[k][l])\\r\\n t1 = -2.0 * np.trace(\\r\\n np.matmul(np.matmul(np.matmul(b.T, M.T), C), theta))\\r\\n t2 = np.trace(np.matmul(np.matmul(b.T, sigma_xx), b))\\r\\n return t1 + t2 + L * total\",\n \"def TestFunc1(x):\\r\\n return 12*x[0]*x[0] + 4*x[1]*x[1] - 12*x[0]*x[1] + 2*x[1]\",\n \"def cdm(x0,partial,learning_rate=0.01,momentum_weight=0.9,iterations=10,\\n initial_momentum=0,**kwargs):\\n x = x0; N = len(x)\\n if initial_momentum == 0:\\n momentum = np.zeros(x0.shape)\\n else:\\n momentum = initial_momentum\\n for i in range(iterations):\\n indices = random.sample(range(N),N)\\n for j in indices:\\n momentum[j] = momentum_weight*momentum[j]+\\\\\\n (1-momentum_weight)*partial(x0,j)\\n x[j] -= learning_rate*momentum[j]\\n return x, momentum\",\n \"def fn(a, y):\\n return 0.5*np.linalg.norm(a-y)**2\",\n \"def lr_cost_function_grad(theta: np.ndarray, X: np.ndarray, y: np.ndarray, l: float) -> np.ndarray:\\n # Initialize some useful values\\n m = len(y) # number of training examples\\n\\n # You need to return the following variable correctly.\\n grad = np.zeros(theta.shape)\\n\\n # ====================== YOUR CODE HERE ======================\\n # Instructions: Compute the partial derivatives and set grad to the partial\\n # derivatives of the cost w.r.t. each parameter in theta.\\n\\n # =============================================================\\n return grad\",\n \"def grad(self, x):\\n norm_beta = np.linalg.norm(x)\\n if norm_beta > utils.TOLERANCE:\\n return (self.l / norm_beta) * x\\n else:\\n D = x.shape[0]\\n u = (self.rng(D, 1) * 2.0) - 1.0 # [-1, 1]^D\\n norm_u = np.linalg.norm(u)\\n a = self.rng() # [0, 1]\\n\\n return (self.l * (a / norm_u)) * u\",\n \"def fd_jacobian(self,y):\\n res0 = self.residual(y)\\n eps = 1e-6\\n dofs = y.shape[0]\\n jac_approx = np.zeros((dofs,dofs))\\n for i in range(dofs):\\n y_temp = np.copy(y)\\n y_temp[i]+=eps\\n\\n r2 = self.residual(y_temp)\\n dr = (r2-res0)/eps\\n for j in range(dofs):\\n jac_approx[j,i] = dr[j]\\n \\n return jac_approx\",\n \"def derivatives(x_p, y_p):\\r\\n # set up the matrix equation\\r\\n n = x_p.shape[0]\\r\\n M = np.zeros( [n,n] )\\r\\n d = np.zeros( [n,1] )\\r\\n \\r\\n # fill in the constants where they can be\\r\\n for i in np.arange(1,n-1 ): # for all but the first and last row\\r\\n M[i,i-1 ] = ( x_p[i] - x_p[i-1] ) / 6.\\r\\n M[i,i] = ( x_p[i+1] - x_p[i-1] ) / 3.\\r\\n M[i,i+1] = ( x_p[i+1] - x_p[i] ) /6.\\r\\n d[i,0 ] = ( y_p[i+1] - y_p[i] ) / ( x_p[i+1] - x_p[i] ) - ( y_p[i] - y_p[i-1] ) / ( x_p[i] - x_p[i-1] )\\r\\n \\r\\n M[0,0],M[-1,-1] = 1.,1. # compactly sets the BCs\\r\\n \\r\\n LU = lu.LU_decomp(M) # solves the matrix equations\\r\\n return lu.FB_sub(LU.Low, LU.Upp, d) # find and return 2nd derivatives\\r\",\n \"def pdf(self, x):\\r\\n return self._coef * reduce(mul, [xx ** (aa-1) for (xx, aa) in zip(x, self._alpha)])\",\n \"def jacobian(self,x,p,fun):\\n n = self.n\\n y = fun(x,p)\\n h = 1e-4\\n nout = np.size(y)\\n dfdx = np.zeros((nout,n))\\n for j in range(n):\\n dx1 = np.zeros(n)\\n dx2 = np.zeros(n)\\n dx1[j] = -h\\n dx2[j] = h\\n dfdx[:,j] = (fun(x+dx2,p)-fun(x+dx1,p))/(2*h)\\n return dfdx\",\n \"def DynamicsCheat(x, t, T0, alpha, cost, K, n, r):\\n D=dmax*x[0]**n/(x[0]**n+K**n)\\n #defune the degradation effect\\n deg=0\\n #define ODEs\\n y=np.zeros([np.size(x)])\\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\\n y[1]=x[1]*(r*(1-cost)*(1-x[1])-D-alpha)#d Co/dt\\n \\n return y\",\n \"def derivatives(self, x=[], function='sigmoid', alpha=0.01, y_pred = [], y = []):\\n if function == \\\"sigmoid\\\":\\n dadz = self.activation(x,\\\"sigmoid\\\")*(1-self.activation(x,\\\"sigmoid\\\"))\\n return dadz\\n\\n if function == \\\"swish\\\":\\n dadz = self.activation(x,\\\"sigmoid\\\") + x * self.activation(x,\\\"sigmoid\\\") * (1-self.activation(x,\\\"sigmoid\\\"))\\n return dadz\\n \\n if function == \\\"linear\\\":\\n dadz = np.ones(np.shape(x))\\n return dadz\\n\\n if function == \\\"relu\\\":\\n dadz = np.greater(x, 0).astype(int)\\n return dadz\\n\\n if function == \\\"leakyrelu\\\":\\n dadz = 1 * (x > 0) + alpha * (x<0)\\n return dadz\\n \\n if function == \\\"mse\\\":\\n assert(np.shape(y_pred)) == np.shape(y)\\n if y.ndim > 1:\\n m = np.shape(y)[0] #number of samples\\n n = np.shape(y)[1] #number of output elements\\n dCdy_pred = np.sum((y_pred - y), axis=0)*(1/(m*n))*2\\n\\n else:\\n m = 1\\n n = len(y) \\n dCdy_pred = (y_pred - y)*(1/(m*n))*2\\n return dCdy_pred\",\n \"def _compute_correction(self, initial_state, final_state, a, b, c, s):\\r\\n pertub = self.pertub\\r\\n pertub_s = pertub *10\\r\\n \\r\\n pred_no_pertub = self._motion_update_one_shot(initial_state, a, b, c, s)\\r\\n pred_pertub_a = self._motion_update_one_shot(initial_state, a +pertub, b, c, s)\\r\\n pred_pertub_b = self._motion_update_one_shot(initial_state, a, b +pertub, c, s)\\r\\n # no need to correct C, C is constrained by kappa_final\\r\\n # # pred_pertub_c = self._motion_update_one_shot(initial_state, a, b, c +pertub, s)\\r\\n pred_pertub_s = self._motion_update_one_shot(initial_state, a, b, c, s +pertub_s)\\r\\n\\r\\n d_state = np.zeros((3,1))\\r\\n d_pertub_state = np.zeros((3,3))\\r\\n Jacobian = np.zeros((3,3))\\r\\n for i in range(0, 3):\\r\\n d_pertub_state[i][0] = (final_state[i] - pred_pertub_a[i]) # a\\r\\n d_pertub_state[i][1] = (final_state[i] - pred_pertub_b[i]) # b\\r\\n # d_pertub_state[i][2] = (final_state[i] - pred_pertub_c[i]) # c (no update)\\r\\n d_pertub_state[i][2] = (final_state[i] - pred_pertub_s[i]) # s\\r\\n \\r\\n d_state[i] = final_state[i] - pred_no_pertub[i]\\r\\n \\r\\n Jacobian[i][0] = (d_pertub_state[i][0] - d_state[i])/pertub # a\\r\\n Jacobian[i][1] = (d_pertub_state[i][1] - d_state[i])/pertub # b\\r\\n # Jacobian[i][2] = (d_pertub_state[i][2] - d_state[i])/pertub # c (no update)\\r\\n Jacobian[i][2] = (d_pertub_state[i][2] - d_state[i])/pertub_s # s\\r\\n\\r\\n # inv_Jacobian = np.linalg.inv(Jacobian)\\r\\n inv_Jacobian = np.linalg.pinv(Jacobian)\\r\\n correction = np.dot(inv_Jacobian, d_state)\\r\\n # pdb.set_trace()\\r\\n return correction\",\n \"def grad_wrt_L(samples, laplacian, activations, diffusion_factors):\\n num_vertices = samples.shape[1]\\n grad = np.zeros(shape=(num_vertices, num_vertices))\\n eigenvalues, eigenvectors = np.linalg.eigh(laplacian)\\n for i, tau in enumerate(diffusion_factors):\\n H_tau = activations[:, num_vertices*i:num_vertices*(i+1)]\\n A = H_tau.T @ samples\\n grad -= 2 * (- tau * grad_tr_A_exp_L(- tau * eigenvalues, eigenvectors, A))\\n for j, tau_bis in enumerate(diffusion_factors):\\n H_tau_bis = activations[:, num_vertices*j:num_vertices*(j+1)]\\n A = H_tau_bis.T @ H_tau\\n grad += - ((tau+tau_bis) * grad_tr_A_exp_L(-(tau+tau_bis)*eigenvalues, eigenvectors, A))\\n return grad\",\n \"def derivative_func(t, x, Approx_func):\\n return x.dot(Approx_func)\",\n \"def cofiCostFunc(self,params, *args):\\n\\t\\tY, R, num_users, num_products, num_features,l = args[0], args[1],args[2], args[3],args[4],args[5]\\n\\n\\t\\taux = params.reshape((num_products + num_users, num_features))\\n\\n\\t\\tX = aux[0:num_products , :]\\n\\n\\t\\tTheta = aux[num_products:, :] \\n\\n\\t\\ttest = np.dot(X,Theta.transpose())\\n\\t\\ttest = test - Y\\n\\t\\ttest = np.multiply(test , R)\\n\\t\\ttest = np.power(test,2)\\n\\t\\ttest = test.sum()\\n\\t\\ttest = 0.5 * test\\n\\n\\t\\tJ = 0;\\n\\t\\tregularization = (l * 0.5) * np.power(X,2).sum() + np.power(Theta,2).sum()\\n\\n\\t\\tJ = test# + regularization\\n\\n\\t\\treturn J\",\n \"def grad(y, y_pred, z, act_fn):\\n return (y_pred - y) * act_fn.grad(z)\",\n \"def _evalAndDer(self, x):\\n m = len(x)\\n fx = np.zeros((m, self.funcCount))\\n for j in range(self.funcCount):\\n fx[:, j] = self.functions[j](x)\\n i = self.argcompare(fx, axis=1)\\n y = fx[np.arange(m), i]\\n dydx = np.zeros_like(y)\\n for j in range(self.funcCount):\\n c = i == j\\n dydx[c] = self.functions[j].derivative(x[c])\\n return y, dydx\",\n \"def _evalAndDer(self, x):\\n m = len(x)\\n fx = np.zeros((m, self.funcCount))\\n for j in range(self.funcCount):\\n fx[:, j] = self.functions[j](x)\\n i = self.argcompare(fx, axis=1)\\n y = fx[np.arange(m), i]\\n dydx = np.zeros_like(y)\\n for j in range(self.funcCount):\\n c = i == j\\n dydx[c] = self.functions[j].derivative(x[c])\\n return y, dydx\",\n \"def gradient(init_par, alpha, delta, obs, sigma_obs, ccoef, N):\\n\\n\\n\\t## Initial parameters\\n\\n\\tparallax, v, sigma_v = init_par[:-4], init_par[-4:-1], init_par[-1] \\n\\tplx_obs, mualpha_obs, mudelta_obs = obs[:, 0], obs[:, 1], obs[:, 2]\\n\\n\\t### Define normal triad and proper motions\\n\\tp, q, r = normalTriad(alpha, delta)\\n\\tmualpha_mod = np.dot(np.transpose(p),v)*parallax/_A\\n\\tmudelta_mod = np.dot(np.transpose(q),v)*parallax/_A\\n\\t\\n\\tplx_mod, mualpha_mod, mudelta_mod = parallax, mualpha_mod, mudelta_mod\\n\\tsigma_plx, sigma_mualpha, sigma_mudelta = np.transpose(sigma_obs)\\n\\ta,like, expo, detD = np.ones(N),np.ones(N),np.ones(N), np.ones(N) \\n\\n\\t### Eq. 8 in Lindegren+2000 (Covariance Matrix)\\n\\tC = np.zeros((3,3,N),dtype=np.float64)\\n\\tC[0,0,:],C[1,1,:],C[2,2,:] = sigma_plx**2.,sigma_mualpha**2., sigma_mudelta**2.\\n\\tcorr_coefficient_plx_mualpha, corr_coefficient_plx_mudelta, corr_coefficient_mualpha_mudelta = np.zeros(N), np.zeros(N), np.zeros(N)\\n\\tcorr_coefficient_plx_mualpha[:], corr_coefficient_plx_mudelta[:], corr_coefficient_mualpha_mudelta[:] = ccoef[:, 0], ccoef[:, 1], ccoef[:, 2] \\n\\t\\n\\tC[0,1,:], C[0,2,:] = corr_coefficient_plx_mualpha*sigma_plx*sigma_mualpha, corr_coefficient_plx_mudelta*sigma_plx*sigma_mudelta\\n\\tC[1,0,:], C[1,2,:] = corr_coefficient_plx_mualpha*sigma_plx*sigma_mualpha, corr_coefficient_mualpha_mudelta*sigma_mualpha*sigma_mudelta\\n\\tC[2,0,:], C[2,1,:] = corr_coefficient_plx_mudelta*sigma_plx*sigma_mudelta, corr_coefficient_mualpha_mudelta*sigma_mualpha*sigma_mudelta\\n\\n\\t### Eq. 16 in Lindegren+2000 (Definition of D matrix)\\t\\n\\tE = np.zeros((3,3,N),dtype=np.float64)\\n\\tE[1,1,:],E[2,2,:] = (sigma_v*parallax[:]/_A)**2., (sigma_v*parallax[:]/_A)**2.\\n\\tD,invD = np.zeros((3,3,N),dtype=np.float64),np.zeros((3,3,N),dtype=np.float64)\\n\\tD = np.add(E,C)\\n\\tfor i in range(N):\\n\\t\\tdetD[i] = matrix_det(D[:,:,i]) \\n\\t\\tinvD[:,:,i] = matrix_inv(D[:,:,i])\\n\\t\\t\\n\\t\\n\\ta_c = np.ones((3,N))\\n\\ta_c = [plx_obs - plx_mod, mualpha_obs - mualpha_mod, mudelta_obs-mudelta_mod]\\n\\t\\n\\t### First derivatives in Eq. A3 \\n\\tcprime_pi, cprime_vx, cprime_vy, cprime_vz, = np.ones((3,N)), np.ones((3,N)), \\\\\\n\\t\\t\\t\\t\\t\\t\\tnp.ones((3,N)), np.ones((3,N)), \\n\\tcprime_pi[0,:] = 1.\\n\\tcprime_pi[1,:] = np.dot(np.transpose(p),v)/_A\\n\\tcprime_pi[2,:] = np.dot(np.transpose(q),v)/_A\\n\\t\\n\\tcprime_vx[0,:] = 0.\\n\\tcprime_vx[1,:] = -np.sin(alpha)*plx_mod/_A \\n\\tcprime_vx[2,:] = -np.sin(delta)*np.cos(alpha)*plx_mod/_A\\n\\n\\t\\n\\tcprime_vy[0,:] = 0.\\n\\tcprime_vy[1,:] = np.cos(alpha)*plx_mod/_A \\n\\tcprime_vy[2,:] = -np.sin(delta)*np.sin(alpha)*plx_mod/_A\\n\\n\\tcprime_vz[0,:] = 0.\\n\\tcprime_vz[1,:] = 0. \\n\\tcprime_vz[2,:] = np.cos(delta)*plx_mod/_A\\n\\n\\tdlnd_dpi, dlnd_dsigmav = np.zeros(N), np.zeros(N)\\n\\tde_dpi, de_dsigmav = np.zeros(N), np.zeros(N)\\n\\t\\n\\n\\t### See Eq. A5 \\n\\tde_dpi[:] = ((sigma_v/_A)**2.)*2.*plx_mod[:]\\n\\tde_dsigmav[:] = ((plx_mod[:]/_A)**2.)*2.*sigma_v\\n\\t\\n\\tdlnd_dpi[:] = (invD[1,1,:] + invD[2,2,:])*de_dpi[:] \\n\\tdlnd_dsigmav[:] = (invD[1,1,:] + invD[2,2,:])*de_dsigmav[:]\\n\\t\\n\\t\\n\\t\\n\\t### See Eq. A6\\n\\tdG_dpi, dG_dsigmav = np.zeros((3,3,N)), np.zeros((3,3,N)) \\n\\t\\n\\tdG_dpi[0,0,:], dG_dpi[0,1,:], dG_dpi[0,2,:] = (-invD[0,1,:]*invD[1, 0, :] - invD[0, 2, :]*invD[2,0,:])*de_dpi[:], \\\\\\n\\t\\t\\t\\t\\t\\t (-invD[0,1,:]*invD[1, 1, :] - invD[0,2,:]*invD[2, 1, :])*de_dpi[:], \\\\\\n\\t\\t\\t\\t\\t\\t (-invD[0,1,:]*invD[1,2,:] - invD[0,2,:]*invD[2,2,:])*de_dpi[:]\\n\\tdG_dpi[1,0,:], dG_dpi[1,1,:], dG_dpi[1,2,:] = (-invD[1,1,:]*invD[1, 0, :] - invD[1, 2, :]*invD[2,0,:])*de_dpi[:], \\\\\\n\\t\\t\\t\\t\\t\\t (-invD[1,1,:]*invD[1, 1, :] - invD[1,2,:]*invD[2, 1, :])*de_dpi[:], \\\\\\n\\t\\t\\t\\t\\t\\t (-invD[1,1,:]*invD[1,2,:] - invD[1,2,:]*invD[2,2,:])*de_dpi[:]\\n\\tdG_dpi[2,0,:], dG_dpi[2,1,:], dG_dpi[2,2,:] = (-invD[2,1,:]*invD[1, 0, :] - invD[2, 2, :]*invD[2,0,:])*de_dpi[:], \\\\\\n\\t\\t\\t\\t\\t\\t (-invD[2,1,:]*invD[1, 1, :] - invD[2,2,:]*invD[2, 1, :])*de_dpi[:], \\\\\\n\\t\\t\\t\\t\\t\\t (-invD[2,1,:]*invD[1,2,:] - invD[2,2,:]*invD[2,2,:])*de_dpi[:]\\n\\t\\n\\n\\tdG_dsigmav[0,0,:], dG_dsigmav[0,1,:], dG_dsigmav[0,2,:] = (-invD[0,1,:]*invD[1, 0, :] - invD[0, 2, :]*invD[2,0,:])*de_dsigmav[:], \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t (-invD[0,1,:]*invD[1, 1, :] - invD[0,2,:]*invD[2, 1, :])*de_dsigmav[:], \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t (-invD[0,1,:]*invD[1,2,:] - invD[0,2,:]*invD[2,2,:])*de_dsigmav[:]\\n\\tdG_dsigmav[1,0,:], dG_dsigmav[1,1,:], dG_dsigmav[1,2,:] = (-invD[1,1,:]*invD[1, 0, :] - invD[1, 2, :]*invD[2,0,:])*de_dsigmav[:], \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t (-invD[1,1,:]*invD[1, 1, :] - invD[1,2,:]*invD[2, 1, :])*de_dsigmav[:], \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t (-invD[1,1,:]*invD[1,2,:] - invD[1,2,:]*invD[2,2,:])*de_dsigmav[:]\\n\\tdG_dsigmav[2,0,:], dG_dsigmav[2,1,:], dG_dsigmav[2,2,:] = (-invD[2,1,:]*invD[1, 0, :] - invD[2, 2, :]*invD[2,0,:])*de_dsigmav[:], \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t (-invD[2,1,:]*invD[1, 1, :] - invD[2,2,:]*invD[2, 1, :])*de_dsigmav[:], \\\\\\n\\t\\t\\t\\t\\t\\t\\t\\t (-invD[2,1,:]*invD[1,2,:] - invD[2,2,:]*invD[2,2,:])*de_dsigmav[:]\\n\\n\\tf_dpi = np.zeros((N), dtype=np.float64) \\n\\t\\n\\t\\n\\tfor i in range(N):\\n\\t\\tf_dpi_1, f_dpi_3 = 0., 0.0 \\n\\t\\tfor ia in range(3):\\n\\t\\t\\tfor ib in range(3):\\n\\t\\t\\t\\tf_dpi_1 += invD[ia,ib,i]*cprime_pi[ia,i]*a_c[ib][i]\\n\\t\\t\\t\\tf_dpi_3 += (-0.5)*(dG_dpi[ia,ib,i]*a_c[ia][i]*a_c[ib][i])\\n\\t\\t\\t\\t\\t\\n\\t\\tf_dpi_2 = (-0.5)*dlnd_dpi[i]\\n\\t\\tf_dpi[i] = f_dpi_1 + f_dpi_2 + f_dpi_3\\n\\t\\t\\n\\n\\tf_vx, f_vy, f_vz, f_sigmav = np.zeros(N), np.zeros(N), np.zeros(N), np.zeros(N) \\n\\n\\tf_vx = np.sum(invD[0,0,:]*cprime_vx[0,:]*a_c[0][:] + invD[0,1,:]*cprime_vx[0,:]*a_c[1][:] + invD[0,2,:]*cprime_vx[0,:]*a_c[2][:] + \\\\\\n\\t\\t invD[1,0,:]*cprime_vx[1,:]*a_c[0][:] + invD[1,1,:]*cprime_vx[1,:]*a_c[1][:] + invD[1,2,:]*cprime_vx[1,:]*a_c[2][:] + \\\\\\n\\t\\t invD[2,0,:]*cprime_vx[2,:]*a_c[0][:] + invD[2,1,:]*cprime_vx[2,:]*a_c[1][:] + invD[2,2,:]*cprime_vx[2,:]*a_c[2][:])\\n\\t\\n\\tf_vy = np.sum(invD[0,0,:]*cprime_vy[0,:]*a_c[0][:] + invD[0,1,:]*cprime_vy[0,:]*a_c[1][:] + invD[0,2,:]*cprime_vy[0,:]*a_c[2][:] + \\\\\\n\\t\\t invD[1,0,:]*cprime_vy[1,:]*a_c[0][:] + invD[1,1,:]*cprime_vy[1,:]*a_c[1][:] + invD[1,2,:]*cprime_vy[1][:]*a_c[2][:] + \\\\\\n\\t\\t invD[2,0,:]*cprime_vy[2,:]*a_c[0][:] + invD[2,1,:]*cprime_vy[2,:]*a_c[1][:] + invD[2,2,:]*cprime_vy[2,:]*a_c[2][:])\\n\\n\\tf_vz = np.sum(invD[0,0,:]*cprime_vz[0,:]*a_c[0][:] + invD[0,1,:]*cprime_vz[0,:]*a_c[1][:] + invD[0,2,:]*cprime_vz[0,:]*a_c[2][:] + \\\\\\n\\t\\t invD[1,0,:]*cprime_vz[1,:]*a_c[0][:] + invD[1,1,:]*cprime_vz[1,:]*a_c[1][:] + invD[1,2,:]*cprime_vz[1,:]*a_c[2][:] + \\\\\\n\\t\\t invD[2,0,:]*cprime_vz[2,:]*a_c[0][:] + invD[2,1,:]*cprime_vz[2,:]*a_c[1][:] + invD[2,2,:]*cprime_vz[2,:]*a_c[2][:])\\n\\t\\n\\tf_sigmav = np.sum(-0.5*(dG_dsigmav[0,0,:]*a_c[0][:]*a_c[0][:] + dG_dsigmav[0,1,:]*a_c[1][:]*a_c[0][:]+ dG_dsigmav[0,2,:]*a_c[2][:]*a_c[0][:] + \\\\\\n\\t\\t dG_dsigmav[1,0,i]*a_c[1][:]*a_c[0][:] + dG_dsigmav[1,1,:]*a_c[1][:]*a_c[1][:]+ dG_dsigmav[1,2,:]*a_c[1][:]*a_c[2][:] + \\t\\n\\t\\t dG_dsigmav[2,0,i]*a_c[2][:]*a_c[0][:] + dG_dsigmav[2,1,:]*a_c[2][:]*a_c[1][:]+ dG_dsigmav[2,2,:]*a_c[2][:]*a_c[2][:]))\\n\\t\\n\\n\\tf_sigmav = f_sigmav - 0.5*np.sum(dlnd_dsigmav)\\t\\n\\tf = np.concatenate((f_dpi, np.array([f_vx, f_vy, f_vz, f_sigmav]))) ### Grad L(theta), see Eq. 17\\n\\treturn -2.*f \\t\\t\\t\\t\\t\\t ### Grad U(theta), see Eq. 18\",\n \"def c(\\n dp: np.ndarray,\\n ddp: np.ndarray,\\n ) -> np.ndarray:\\n\\n return \\\\\\n np.sqrt((ddp[2, :] * dp[1, :] - dp[2, :] * ddp[1, :])**2 +\\n (ddp[0, :] * dp[2, :] - dp[0, :] * ddp[2, :])**2 +\\n (ddp[1, :] * dp[0, :] - dp[1, :] * ddp[0, :])**2) / \\\\\\n (dp[0, :]**2 + dp[1, :]**2 + dp[2, :]**2)**1.5\",\n \"def test_deriv_cost_function():\\n # Setup scenario\\n b_lower = 0.35\\n b = 0.6\\n v = [1.0, 2.0, 3.0]\\n\\n # Calculate expected result\\n n = len(v)\\n tmp = np.ones(n) * (b-b_lower)\\n ps = [x**(k-1) for k,x in zip(range(n), tmp)]\\n bs = np.array([i * x for i,x in zip(range(n), ps)])\\n alphas = np.array(v)\\n expected = np.dot(alphas, bs)\\n\\n # Calculate actual result\\n actual = deriv_cost_function(b_lower, v, b)\\n \\n # Compare\\n assert expected == actual\",\n \"def derivative(a, y, z):\\n return (a - y) * Sigmoid.derivative(z)\",\n \"def costFunction(self):\\n priorDiff = np.matrix(self.model.stateVector - self.model.prior).T\\n measurementDiff = np.matrix(self.model.observation\\n - self.model.modelCalculation).T\\n chisq = measurementDiff.T * self.errSinv * measurementDiff\\n chisq += priorDiff.T * self.priorSinv * priorDiff\\n \\n return chisq[0,0]\",\n \"def get_y_depletion(accrate, x0, z):\\n return 6.8e8 * (accrate/0.1) * (0.01/z) * (x0/0.71)\",\n \"def partial_derivative(self, parameter_location):\\n self.decrement_parameter(parameter_location)\\n cost_minus = self.evaluate_function()\\n\\n self.increment_parameter(parameter_location)\\n self.increment_parameter(parameter_location)\\n cost_plus = self.evaluate_function()\\n\\n derivative = self._derivative(cost_minus, cost_plus)\\n\\n self.decrement_parameter(parameter_location)\\n return derivative\",\n \"def fun(_, y):\\n return np.array([-self.r * self.beta * y[1] * y[0] / self.N,\\n self.r * self.beta * y[1] * y[0] / self.N - self.gamma * y[1],\\n self.gamma * y[1]])\",\n \"def f(t, x, y):\\n Iq, UC, U = x # time continous state vector\\n dIq = (Uq(t) - R*Iq - UC - U) / L\\n dUC = Iq / C\\n dU = Iq / Cp\\n return array([dIq, dUC, dU])\",\n \"def fitness(self, x):\\n u = np.asarray([x[0]])\\n C = self.C_func(u)\\n P = self.P\\n return np.asarray([np.sum(np.sum((C - P) ** 2, axis=0) ** (1 / 2))])\",\n \"def cost_derivation(update_param: np.ndarray,\\n dependent_param: np.ndarray,\\n label: int\\n ) -> np.ndarray:\\n return (sigmoid(update_param @ dependent_param) - label)*dependent_param\",\n \"def f(X, params):\\r\\n x_i, x_i1, y_i, y_i1, y_ip, y_ip1 = params\\r\\n A = (x_i1 - X) / (x_i1 - x_i)\\r\\n B = (X - x_i) / (x_i1 - x_i)\\r\\n C = (1./6) * (A**3 - A) * (x_i1-x_i)**2 \\r\\n D = (1./6) * (B**3 - B) * (x_i1-x_i)**2\\r\\n return A*y_i + B*y_i1 + C*y_ip + D*y_ip1\",\n \"def _l1m_objective(a,X,*args):\\n \\n return(np.sum(np.apply_along_axis(_euclidnorm,1,_diffmat_objective(a,X))))\",\n \"def f1(x, a, b):\\n #return x**43 - b*x**42 + x**7 - x**6 * a + 84*x - 42 * b - 42 * a\\n return (x**42 + 42)/(x-a) + (x**6 + 42)/(x-b)\",\n \"def coherence_partial_spec(fxy, fxx, fyy, fxr, fry, frr):\\r\\n coh = coherency_spec\\r\\n Rxr = coh(fxr, fxx, frr)\\r\\n Rry = coh(fry, fyy, frr)\\r\\n Rxy = coh(fxy, fxx, fyy)\\r\\n\\r\\n return (((np.abs(Rxy - Rxr * Rry)) ** 2) /\\r\\n ((1 - ((np.abs(Rxr)) ** 2)) * (1 - ((np.abs(Rry)) ** 2))))\",\n \"def b_gradient_descent(self, LB,UB,eta, tol,iter):\\n bgd=[]\\n bgd_x=[LB]\\n iteration=0\\n # current_pt=X\\n first_derivative=sym.diff(self.gdfunc)\\n #print(first_derivative)\\n x=sym.Symbol('x')\\n first_derivative=sym.lambdify(x,first_derivative)\\n learn_rate=eta\\n \\n new_x=LB\\n bgd_x.append(LB)\\n \\n for i in range(iter):\\n for j in np.arange(LB,UB,0.1):\\n prev_x=new_x\\n new_x=prev_x-(learn_rate*first_derivative(prev_x))\\n #print(\\\"i = \\\",j,\\\"gradient =\\\",(learn_rate*first_derivative(j)),iteration)\\n iteration=iteration+1\\n #print(iteration)\\n if iteration >=iter:\\n break \\n if new_x <= tol:\\n #print(\\\"new_x = \\\",new_x,\\\"gradient =\\\",(learn_rate*first_derivative(prev_x)), iteration) \\n break\\n \\n \\n \\n \\n #print(new_x)\\n bgd_x.append(new_x)\\n \\n \\n bgd.append(bgd_x)\\n bgd.append(new_x)\\n bgd.append(iteration)\\n\\n return bgd\",\n \"def darcy_func(self):\\n i, o = self.inl[0].to_flow(), self.outl[0].to_flow()\\n\\n if abs(i[0]) < 1e-4:\\n return i[1] - o[1]\\n\\n visc_i = visc_mix_ph(i, T0=self.inl[0].T.val_SI)\\n visc_o = visc_mix_ph(o, T0=self.outl[0].T.val_SI)\\n v_i = v_mix_ph(i, T0=self.inl[0].T.val_SI)\\n v_o = v_mix_ph(o, T0=self.outl[0].T.val_SI)\\n\\n re = 4 * abs(i[0]) / (np.pi * self.D.val * (visc_i + visc_o) / 2)\\n\\n return ((i[1] - o[1]) - 8 * abs(i[0]) * i[0] * (v_i + v_o) / 2 *\\n self.L.val * lamb(re, self.ks.val, self.D.val) /\\n (np.pi ** 2 * self.D.val ** 5))\",\n \"def activ_fn_derivative(z):\\n return 1 - np.square(np.tanh(z))\",\n \"def grad(self, A, y, x):\\n z = y * A.dot(x) # decision value for each observation\\n grad_x = -1*A[z < 1].T.dot(y[z < 1])\\n # Gradient normalized by the num obs\\n return grad_x / y.size\",\n \"def _calc_var(self, f, a, b, z):\\n\\n c_1 = (t.exp(a[...,0] * f[...,0] + b[...,0]) *\\n (a[...,0]**2 * f[...,0]**2\\n - 2 * a[...,0] * f[...,0] + 2)\\n ) / a[...,0]**3\\n c_2 = ((t.exp(a[...,1:-1] * f[...,1:] + b[...,1:-1]) *\\n (a[...,1:-1]**2 * f[...,1:]**2 - 2 * a[...,1:-1] * f[...,1:] + 2) -\\n t.exp(a[...,1:-1] * f[...,:-1] + b[...,1:-1]) *\\n (a[...,1:-1]**2 * f[...,:-1]**2 - 2 * a[...,1:-1] * f[...,:-1] + 2)\\n ) / a[...,1:-1]**3).sum(-1)\\n c_3 = (t.exp(a[...,-1] * f[...,-1] + b[...,-1]) *\\n (a[...,-1]**2 * f[...,-1]**2 - 2 * a[...,-1] * f[...,-1] + 2)\\n ) / a[...,-1]**3\\n\\n return 1/z * (c_1 + c_2 + c_3)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63106906","0.6288777","0.6248431","0.61870795","0.61130613","0.60892075","0.6084112","0.6036914","0.60203856","0.59552675","0.5933606","0.5922783","0.59008473","0.5899504","0.58983827","0.5898196","0.5894403","0.58335376","0.57893485","0.5781006","0.57793933","0.5776582","0.5767814","0.5762219","0.5751444","0.5732533","0.5718493","0.5716975","0.5703724","0.56740713","0.5672002","0.56649876","0.56638724","0.56567794","0.565202","0.5646467","0.56415176","0.56382924","0.56284964","0.5622467","0.5616817","0.5611487","0.5605861","0.55948484","0.5588426","0.55735433","0.5571023","0.5570196","0.55658495","0.5547034","0.5541092","0.5521411","0.55090594","0.5499074","0.5493457","0.5490972","0.5482658","0.54823107","0.5472325","0.54694045","0.54613113","0.54593635","0.5456948","0.5452964","0.5450558","0.54379606","0.54376334","0.5426106","0.54170597","0.5413135","0.54120153","0.54082656","0.5402408","0.54006445","0.53998446","0.5396255","0.5396255","0.5390791","0.5389257","0.53858423","0.5385142","0.53791434","0.53725636","0.537169","0.5368421","0.5368309","0.53655636","0.5364973","0.5364213","0.53628427","0.53619015","0.5359652","0.5356774","0.53401434","0.5338487","0.5334851","0.53328484"],"string":"[\n \"0.63106906\",\n \"0.6288777\",\n \"0.6248431\",\n \"0.61870795\",\n \"0.61130613\",\n \"0.60892075\",\n \"0.6084112\",\n \"0.6036914\",\n \"0.60203856\",\n \"0.59552675\",\n \"0.5933606\",\n \"0.5922783\",\n \"0.59008473\",\n \"0.5899504\",\n \"0.58983827\",\n \"0.5898196\",\n \"0.5894403\",\n \"0.58335376\",\n \"0.57893485\",\n \"0.5781006\",\n \"0.57793933\",\n \"0.5776582\",\n \"0.5767814\",\n \"0.5762219\",\n \"0.5751444\",\n \"0.5732533\",\n \"0.5718493\",\n \"0.5716975\",\n \"0.5703724\",\n \"0.56740713\",\n \"0.5672002\",\n \"0.56649876\",\n \"0.56638724\",\n \"0.56567794\",\n \"0.565202\",\n \"0.5646467\",\n \"0.56415176\",\n \"0.56382924\",\n \"0.56284964\",\n \"0.5622467\",\n \"0.5616817\",\n \"0.5611487\",\n \"0.5605861\",\n \"0.55948484\",\n \"0.5588426\",\n \"0.55735433\",\n \"0.5571023\",\n \"0.5570196\",\n \"0.55658495\",\n \"0.5547034\",\n \"0.5541092\",\n \"0.5521411\",\n \"0.55090594\",\n \"0.5499074\",\n \"0.5493457\",\n \"0.5490972\",\n \"0.5482658\",\n \"0.54823107\",\n \"0.5472325\",\n \"0.54694045\",\n \"0.54613113\",\n \"0.54593635\",\n \"0.5456948\",\n \"0.5452964\",\n \"0.5450558\",\n \"0.54379606\",\n \"0.54376334\",\n \"0.5426106\",\n \"0.54170597\",\n \"0.5413135\",\n \"0.54120153\",\n \"0.54082656\",\n \"0.5402408\",\n \"0.54006445\",\n \"0.53998446\",\n \"0.5396255\",\n \"0.5396255\",\n \"0.5390791\",\n \"0.5389257\",\n \"0.53858423\",\n \"0.5385142\",\n \"0.53791434\",\n \"0.53725636\",\n \"0.537169\",\n \"0.5368421\",\n \"0.5368309\",\n \"0.53655636\",\n \"0.5364973\",\n \"0.5364213\",\n \"0.53628427\",\n \"0.53619015\",\n \"0.5359652\",\n \"0.5356774\",\n \"0.53401434\",\n \"0.5338487\",\n \"0.5334851\",\n \"0.53328484\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62181246"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":80998,"cells":{"query":{"kind":"string","value":"Derivative of the sigmoid function."},"document":{"kind":"string","value":"def sigmoid_prime(z):\n return sigmoid(z)*(1-sigmoid(z))"},"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 sigmoid_derivative(x):\n return x * (1-x)","def sigmoid_derivative(x):\n return x * (1.0 - x)","def sigmoid_derivative(x):\n\n return sigmoid(x) * (1 - sigmoid(x))","def derivative_sigmoid(x):\n return x * (1 - x)","def derivative_sigmoid(x):\n return x * (1 - x)","def sigmoid_derivative(x):\n\n s = sigmoid(x)\n ds = s * (1 - s)\n\n return ds","def sigmoid_derivative(x):\r\n\r\n ### START CODE HERE ### (≈ 2 lines of code)\r\n s = 1.0 /(1 + 1/np.exp(x))\r\n ds = s*(1-s)\r\n ### END CODE HERE ###\r\n\r\n return ds","def sigmoid_gradient(z):\n #derivative of sigmoid\n return z * (1 - z)","def sigmoid_derivative(z):\n s = 1./(1. + np.exp(-z))\n ds = s * (1 - s)\n return ds","def grad_sigmoid(self):\n grad = self.sigmoid(self.x) * (1 - self.sigmoid(self.x))\n return grad","def derivative(a, y, z):\n return (a - y) * Sigmoid.derivative(z)","def der_sigmoid(y):\n return y * (1 - y)","def grad_sigmoid(self):\n return self.sigmoid(self.x)*(self.sigmoid(-self.x))\n raise NotImplementedError(\"Sigmoid gradient not implemented\")","def sigmoid_grad(x):\n sig = sigmoid(x)\n return np.multiply(sig, 1 - sig)","def grad_sigmoid(self):\r\n return self.sigmoid(self.x) * (1 - self.sigmoid(self.x))","def derivative_activation(z):\n return activation(z) * (1 - activation(z))","def sigmoid_grad(self, X):\n var=self.sigmoid(X)\n return var*(1-var)","def deriv_sigmoid(self,z):\n return np.exp(-z) / ( (1 + np.exp(-z)) ** 2 )","def sigmoid_grad(z):\n return Sigmoid(z) * (1 - Sigmoid(z))","def gradient(cls, x):\n y = Sigmoid.apply(x)\n return np.multiply(y, 1 - y)","def sigmoid(x, der=False):\n return sigmoid(x)*(1-sigmoid(x)) if der else 1 / (1 + np.exp(-x))","def __sigmoid(z, derivative=False):\n if derivative:\n return z * (1 - z)\n else:\n return 1 / (1 + np.exp(-z))","def delta(z, a, y):\n\t\treturn np.subtract(a, y) * sigmoid_derivative(z)","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 _derivative_(self, x, diff_param=None):\n return 2*exp(-x**2)/sqrt(pi)","def sigmoid(a, d = False):\n if d:\n return a*(1-a)\n else:\n return 1/(1+np.exp(-a))","def sigmoid_backward(dA, Z):\r\n dsig = sigmoid(Z) * (1 - sigmoid(Z))\r\n return dA * dsig","def delta(z, a, y):\n\t\treturn np.subtract(a, y) * sigmoid_derivative(z) ######## A MODIFIER","def test_sigmoid_derivative_returns_correct_value(self):\n self.assertAlmostEqual(sigmoid_derivative(0), 0.25)\n self.assertAlmostEqual(sigmoid_derivative(1), 0.19661193324)","def derivatives(self, x=[], function='sigmoid', alpha=0.01, y_pred = [], y = []):\n if function == \"sigmoid\":\n dadz = self.activation(x,\"sigmoid\")*(1-self.activation(x,\"sigmoid\"))\n return dadz\n\n if function == \"swish\":\n dadz = self.activation(x,\"sigmoid\") + x * self.activation(x,\"sigmoid\") * (1-self.activation(x,\"sigmoid\"))\n return dadz\n \n if function == \"linear\":\n dadz = np.ones(np.shape(x))\n return dadz\n\n if function == \"relu\":\n dadz = np.greater(x, 0).astype(int)\n return dadz\n\n if function == \"leakyrelu\":\n dadz = 1 * (x > 0) + alpha * (x<0)\n return dadz\n \n if function == \"mse\":\n assert(np.shape(y_pred)) == np.shape(y)\n if y.ndim > 1:\n m = np.shape(y)[0] #number of samples\n n = np.shape(y)[1] #number of output elements\n dCdy_pred = np.sum((y_pred - y), axis=0)*(1/(m*n))*2\n\n else:\n m = 1\n n = len(y) \n dCdy_pred = (y_pred - y)*(1/(m*n))*2\n return dCdy_pred","def testDerivation(self):\n result = Sigmoid.deriv(self, 12)\n self.assertEqual(-132, result)","def softmax_derivative(x):\n der = derivative(softmax,x,dx=1e-9)\n return der","def diff_sigmoid(z):\r\n diff_z = np.multiply(z, (1.0 - z))\r\n return diff_z\r\n pass","def dalf(x):\n return derivative(alf, x, dx=1e-6)","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 sigmoid(x):\n return 1 / (1 - (power(e,-x)))","def sigmoid(d: D) -> NumDict:\n\n return 1 / (1 + (-d).exp())","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 derivative_func(t, x, Approx_func):\n return x.dot(Approx_func)","def gradient(cls, x):\n return 1 - TanH.apply(x) ** 2","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 sigmoid(x):\n return 1 / (1 + (e**(-x))) #changed the '-' to a '+' because it didnt work otherwise\n #return 1 / (1 + math.exp(-x))","def derivative(func: Callable, x: float, delta: float) -> float:\n return (func(x + delta) - func(x - delta)) / (2.0 * delta)","def ddalf(x):\n return derivative(dalf, x, dx=1e-6)","def ddalf(x):\n return derivative(dalf, x, dx=1e-6)","def sigmoid(x):\n return 1 / (1 + exp(-x))","def sigmoid(x):\n return 1 / (1 + exp(-x))","def gradientFunction(theta, X, y):\n y = y[:, 0]\n m = y.shape # number of training samples\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\n grad /= m\n return 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 hard_sigmoid_derivative(u):\r\n if u > 1:\r\n ro = 0\r\n elif u < 0:\r\n ro = 0\r\n else:\r\n ro = 1\r\n return ro","def sigmoid(z):\n return 1 / (1 + e ** -z)","def gradient_descent(f, df, x, sigma=0.5, epsilon=1e-8):\n pass","def activ_fn_derivative(z):\n return 1 - np.square(np.tanh(z))","def sigmoid(x):\n return 1 / (1 + math.exp(-x))","def log_deriv(error):\n return logistic(error) * (1 - logistic(error))","def derivative(self,x,dx=None):\n if dx is None:\n x = np.array(x,copy=False)\n if len(x.shape)>0:\n dx = np.convolve(x,[1,-1],mode='valid')\n dx = np.insert(dx,0,np.mean(dx))/2\n else:\n dx = 1\n return (self(x+dx)-self(x))/dx","def sigmoid(x):\n return 1/(1 + math.exp(-x))","def sigmoid(x):\n return 1/(1+np.exp(-1*x))","def sigmoid(x):\n return 1 / (1 + math.exp(-x))","def sigmoid(x):\r\n return 1 / (1 + np.exp(-x))","def sigmoid(x):\n return 1.0/(1.0+exp(-x))","def sigmoid(x):\n return 1 / (1 + np.exp(-x))","def sigmoid(x):\n return 1 / (1 + np.exp(-x))","def sigmoid(x):\n return 1 / (1 + np.exp(-x))","def sigmoid(x):\n return 1 / (1 + np.exp(-x))","def sigmoid(x):\n return 1 / (1 + np.exp(-x))","def sigmoid(x):\n return 1 / (1 + np.exp(-x))","def deriv(self, x, d=None):\n if self.weights is None:\n self.compute_weights()\n\n val = 0.0\n for i in range(self.M):\n val += self.weights[i]*self.model_list[i].deriv(x, d)\n return val","def sigmoid(x):\n return 1 / (1 * np.exp(-x))","def sigmoid(x):\n\n return 1 / (1 + math.exp(-x))","def sigmoid(x):\n\n return 1 / (1 + math.exp(-x))","def calculate_gradient(y, tx, w):\n\n\tret = tx.T.dot(sigmoid(np.dot(tx, w)) - y)\n\treturn ret","def sigmoid(X):\n g = 1/(1 + np.exp(-X))\n return g","def sigmoid_function(z):\n\n return 1 / (1 + math.exp(-z))","def gradient_hidden(self, h):\n if self.relu:\n return 1.0*(h > 0)\n else:\n return 1 - h * h","def sigmoid(x):\n return 1. / (1. + np.exp(-x))","def sigmoid(X):\n return 1 / (1 + np.exp(-X))","def sigmoid(X):\n return 1 / (1 + np.exp(-X))","def delta(z, a, y):\n return (a-y) * sigmoid_prime(z)","def sigmoid(x):\n return 1.0/(1 + np.exp(-x))","def sigmoid(x):\n return 1.0 / (1.0 + np.exp(-x))","def GetDerivative(self, *args):\n return _ITKCostFunctionsPython.itkSingleValuedCostFunction_GetDerivative(self, *args)","def sigmoid(z):\n \n return 1 / (1 + np.exp(-z))#your code here","def sigmoid(x):\r\n\r\n return 1 / (1 + np.exp(-x))","def compute_gradient(self, X, y, weights):\n sigmoid = self.sigmoid(np.dot(X, weights))\n return np.dot(X.T, y - sigmoid)","def calculate_gradient(y, tx, w):\n return tx.T.dot(sigmoid(tx.dot(w))-np.reshape(y,(len(y),1)))","def sigmoid(x, exponent):\n \n return 1/(1+np.exp(-exponent*x))-0.5","def sigmoid(x):\n\treturn 1 / (1 + m.exp(-x))","def sigmoid(z):\r\n \r\n return vSigmoid(z);","def GDS(x, theta, y, lamb, alpha):\n\tm = y.shape[0]\n\tdif = (1/m) * x.T @ (sigmoid(x,theta) - y) #classical differentiation term, output is (n,1)\n\tdif_reg = (lamb/m) * theta #regularization term\n\treturn (dif + dif_reg) * alpha","def sigmoid(x):\r\n #pred_x = (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))\r\n pred_x = 1.0 / (1.0 + np.exp(-x))\r\n return pred_x\r\n pass","def sigmoid(z): \n return 1/(1 + np.e**(-z))","def cost_derivative(output_activations, y):\n return (output_activations - y)","def derivative ( self ):\n return self.__derivative","def f1(phi, phi_o, d):\n return 1 - sigmoid_decay(phi, phi_o, d)","def sigmoid_d50(x, D50, dx):\n y = 48 / (1 + np.exp((x - D50) / dx))\n return y","def tanh(d: D) -> NumDict:\n\n return (2 * sigmoid(d)) - 1","def gradientFunctionReg(theta, X, y, Lambda): \n y = np.squeeze(y)\n m = y.shape # number of training samples\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\n grad[1:] = grad[1:] + Lambda*theta[1:]\n grad /= m\n\n return grad","def sigmoid(self, x):\n y = 1/(1 + np.exp((-x)))\n return y \n raise NotImplementedError(\"Sigmoid not implemented\")","def log_likelihood_gradient(y, tx, w):\n return tx.T.dot(sigmoid(tx.dot(w))-y)"],"string":"[\n \"def sigmoid_derivative(x):\\n return x * (1-x)\",\n \"def sigmoid_derivative(x):\\n return x * (1.0 - x)\",\n \"def sigmoid_derivative(x):\\n\\n return sigmoid(x) * (1 - sigmoid(x))\",\n \"def derivative_sigmoid(x):\\n return x * (1 - x)\",\n \"def derivative_sigmoid(x):\\n return x * (1 - x)\",\n \"def sigmoid_derivative(x):\\n\\n s = sigmoid(x)\\n ds = s * (1 - s)\\n\\n return ds\",\n \"def sigmoid_derivative(x):\\r\\n\\r\\n ### START CODE HERE ### (≈ 2 lines of code)\\r\\n s = 1.0 /(1 + 1/np.exp(x))\\r\\n ds = s*(1-s)\\r\\n ### END CODE HERE ###\\r\\n\\r\\n return ds\",\n \"def sigmoid_gradient(z):\\n #derivative of sigmoid\\n return z * (1 - z)\",\n \"def sigmoid_derivative(z):\\n s = 1./(1. + np.exp(-z))\\n ds = s * (1 - s)\\n return ds\",\n \"def grad_sigmoid(self):\\n grad = self.sigmoid(self.x) * (1 - self.sigmoid(self.x))\\n return grad\",\n \"def derivative(a, y, z):\\n return (a - y) * Sigmoid.derivative(z)\",\n \"def der_sigmoid(y):\\n return y * (1 - y)\",\n \"def grad_sigmoid(self):\\n return self.sigmoid(self.x)*(self.sigmoid(-self.x))\\n raise NotImplementedError(\\\"Sigmoid gradient not implemented\\\")\",\n \"def sigmoid_grad(x):\\n sig = sigmoid(x)\\n return np.multiply(sig, 1 - sig)\",\n \"def grad_sigmoid(self):\\r\\n return self.sigmoid(self.x) * (1 - self.sigmoid(self.x))\",\n \"def derivative_activation(z):\\n return activation(z) * (1 - activation(z))\",\n \"def sigmoid_grad(self, X):\\n var=self.sigmoid(X)\\n return var*(1-var)\",\n \"def deriv_sigmoid(self,z):\\n return np.exp(-z) / ( (1 + np.exp(-z)) ** 2 )\",\n \"def sigmoid_grad(z):\\n return Sigmoid(z) * (1 - Sigmoid(z))\",\n \"def gradient(cls, x):\\n y = Sigmoid.apply(x)\\n return np.multiply(y, 1 - y)\",\n \"def sigmoid(x, der=False):\\n return sigmoid(x)*(1-sigmoid(x)) if der else 1 / (1 + np.exp(-x))\",\n \"def __sigmoid(z, derivative=False):\\n if derivative:\\n return z * (1 - z)\\n else:\\n return 1 / (1 + np.exp(-z))\",\n \"def delta(z, a, y):\\n\\t\\treturn np.subtract(a, y) * sigmoid_derivative(z)\",\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 _derivative_(self, x, diff_param=None):\\n return 2*exp(-x**2)/sqrt(pi)\",\n \"def sigmoid(a, d = False):\\n if d:\\n return a*(1-a)\\n else:\\n return 1/(1+np.exp(-a))\",\n \"def sigmoid_backward(dA, Z):\\r\\n dsig = sigmoid(Z) * (1 - sigmoid(Z))\\r\\n return dA * dsig\",\n \"def delta(z, a, y):\\n\\t\\treturn np.subtract(a, y) * sigmoid_derivative(z) ######## A MODIFIER\",\n \"def test_sigmoid_derivative_returns_correct_value(self):\\n self.assertAlmostEqual(sigmoid_derivative(0), 0.25)\\n self.assertAlmostEqual(sigmoid_derivative(1), 0.19661193324)\",\n \"def derivatives(self, x=[], function='sigmoid', alpha=0.01, y_pred = [], y = []):\\n if function == \\\"sigmoid\\\":\\n dadz = self.activation(x,\\\"sigmoid\\\")*(1-self.activation(x,\\\"sigmoid\\\"))\\n return dadz\\n\\n if function == \\\"swish\\\":\\n dadz = self.activation(x,\\\"sigmoid\\\") + x * self.activation(x,\\\"sigmoid\\\") * (1-self.activation(x,\\\"sigmoid\\\"))\\n return dadz\\n \\n if function == \\\"linear\\\":\\n dadz = np.ones(np.shape(x))\\n return dadz\\n\\n if function == \\\"relu\\\":\\n dadz = np.greater(x, 0).astype(int)\\n return dadz\\n\\n if function == \\\"leakyrelu\\\":\\n dadz = 1 * (x > 0) + alpha * (x<0)\\n return dadz\\n \\n if function == \\\"mse\\\":\\n assert(np.shape(y_pred)) == np.shape(y)\\n if y.ndim > 1:\\n m = np.shape(y)[0] #number of samples\\n n = np.shape(y)[1] #number of output elements\\n dCdy_pred = np.sum((y_pred - y), axis=0)*(1/(m*n))*2\\n\\n else:\\n m = 1\\n n = len(y) \\n dCdy_pred = (y_pred - y)*(1/(m*n))*2\\n return dCdy_pred\",\n \"def testDerivation(self):\\n result = Sigmoid.deriv(self, 12)\\n self.assertEqual(-132, result)\",\n \"def softmax_derivative(x):\\n der = derivative(softmax,x,dx=1e-9)\\n return der\",\n \"def diff_sigmoid(z):\\r\\n diff_z = np.multiply(z, (1.0 - z))\\r\\n return diff_z\\r\\n pass\",\n \"def dalf(x):\\n return derivative(alf, x, dx=1e-6)\",\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 sigmoid(x):\\n return 1 / (1 - (power(e,-x)))\",\n \"def sigmoid(d: D) -> NumDict:\\n\\n return 1 / (1 + (-d).exp())\",\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 derivative_func(t, x, Approx_func):\\n return x.dot(Approx_func)\",\n \"def gradient(cls, x):\\n return 1 - TanH.apply(x) ** 2\",\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 sigmoid(x):\\n return 1 / (1 + (e**(-x))) #changed the '-' to a '+' because it didnt work otherwise\\n #return 1 / (1 + math.exp(-x))\",\n \"def derivative(func: Callable, x: float, delta: float) -> float:\\n return (func(x + delta) - func(x - delta)) / (2.0 * delta)\",\n \"def ddalf(x):\\n return derivative(dalf, x, dx=1e-6)\",\n \"def ddalf(x):\\n return derivative(dalf, x, dx=1e-6)\",\n \"def sigmoid(x):\\n return 1 / (1 + exp(-x))\",\n \"def sigmoid(x):\\n return 1 / (1 + exp(-x))\",\n \"def gradientFunction(theta, X, y):\\n y = y[:, 0]\\n m = y.shape # number of training samples\\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\\n grad /= m\\n return 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 hard_sigmoid_derivative(u):\\r\\n if u > 1:\\r\\n ro = 0\\r\\n elif u < 0:\\r\\n ro = 0\\r\\n else:\\r\\n ro = 1\\r\\n return ro\",\n \"def sigmoid(z):\\n return 1 / (1 + e ** -z)\",\n \"def gradient_descent(f, df, x, sigma=0.5, epsilon=1e-8):\\n pass\",\n \"def activ_fn_derivative(z):\\n return 1 - np.square(np.tanh(z))\",\n \"def sigmoid(x):\\n return 1 / (1 + math.exp(-x))\",\n \"def log_deriv(error):\\n return logistic(error) * (1 - logistic(error))\",\n \"def derivative(self,x,dx=None):\\n if dx is None:\\n x = np.array(x,copy=False)\\n if len(x.shape)>0:\\n dx = np.convolve(x,[1,-1],mode='valid')\\n dx = np.insert(dx,0,np.mean(dx))/2\\n else:\\n dx = 1\\n return (self(x+dx)-self(x))/dx\",\n \"def sigmoid(x):\\n return 1/(1 + math.exp(-x))\",\n \"def sigmoid(x):\\n return 1/(1+np.exp(-1*x))\",\n \"def sigmoid(x):\\n return 1 / (1 + math.exp(-x))\",\n \"def sigmoid(x):\\r\\n return 1 / (1 + np.exp(-x))\",\n \"def sigmoid(x):\\n return 1.0/(1.0+exp(-x))\",\n \"def sigmoid(x):\\n return 1 / (1 + np.exp(-x))\",\n \"def sigmoid(x):\\n return 1 / (1 + np.exp(-x))\",\n \"def sigmoid(x):\\n return 1 / (1 + np.exp(-x))\",\n \"def sigmoid(x):\\n return 1 / (1 + np.exp(-x))\",\n \"def sigmoid(x):\\n return 1 / (1 + np.exp(-x))\",\n \"def sigmoid(x):\\n return 1 / (1 + np.exp(-x))\",\n \"def deriv(self, x, d=None):\\n if self.weights is None:\\n self.compute_weights()\\n\\n val = 0.0\\n for i in range(self.M):\\n val += self.weights[i]*self.model_list[i].deriv(x, d)\\n return val\",\n \"def sigmoid(x):\\n return 1 / (1 * np.exp(-x))\",\n \"def sigmoid(x):\\n\\n return 1 / (1 + math.exp(-x))\",\n \"def sigmoid(x):\\n\\n return 1 / (1 + math.exp(-x))\",\n \"def calculate_gradient(y, tx, w):\\n\\n\\tret = tx.T.dot(sigmoid(np.dot(tx, w)) - y)\\n\\treturn ret\",\n \"def sigmoid(X):\\n g = 1/(1 + np.exp(-X))\\n return g\",\n \"def sigmoid_function(z):\\n\\n return 1 / (1 + math.exp(-z))\",\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 sigmoid(x):\\n return 1. / (1. + np.exp(-x))\",\n \"def sigmoid(X):\\n return 1 / (1 + np.exp(-X))\",\n \"def sigmoid(X):\\n return 1 / (1 + np.exp(-X))\",\n \"def delta(z, a, y):\\n return (a-y) * sigmoid_prime(z)\",\n \"def sigmoid(x):\\n return 1.0/(1 + np.exp(-x))\",\n \"def sigmoid(x):\\n return 1.0 / (1.0 + np.exp(-x))\",\n \"def GetDerivative(self, *args):\\n return _ITKCostFunctionsPython.itkSingleValuedCostFunction_GetDerivative(self, *args)\",\n \"def sigmoid(z):\\n \\n return 1 / (1 + np.exp(-z))#your code here\",\n \"def sigmoid(x):\\r\\n\\r\\n return 1 / (1 + np.exp(-x))\",\n \"def compute_gradient(self, X, y, weights):\\n sigmoid = self.sigmoid(np.dot(X, weights))\\n return np.dot(X.T, y - sigmoid)\",\n \"def calculate_gradient(y, tx, w):\\n return tx.T.dot(sigmoid(tx.dot(w))-np.reshape(y,(len(y),1)))\",\n \"def sigmoid(x, exponent):\\n \\n return 1/(1+np.exp(-exponent*x))-0.5\",\n \"def sigmoid(x):\\n\\treturn 1 / (1 + m.exp(-x))\",\n \"def sigmoid(z):\\r\\n \\r\\n return vSigmoid(z);\",\n \"def GDS(x, theta, y, lamb, alpha):\\n\\tm = y.shape[0]\\n\\tdif = (1/m) * x.T @ (sigmoid(x,theta) - y) #classical differentiation term, output is (n,1)\\n\\tdif_reg = (lamb/m) * theta #regularization term\\n\\treturn (dif + dif_reg) * alpha\",\n \"def sigmoid(x):\\r\\n #pred_x = (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))\\r\\n pred_x = 1.0 / (1.0 + np.exp(-x))\\r\\n return pred_x\\r\\n pass\",\n \"def sigmoid(z): \\n return 1/(1 + np.e**(-z))\",\n \"def cost_derivative(output_activations, y):\\n return (output_activations - y)\",\n \"def derivative ( self ):\\n return self.__derivative\",\n \"def f1(phi, phi_o, d):\\n return 1 - sigmoid_decay(phi, phi_o, d)\",\n \"def sigmoid_d50(x, D50, dx):\\n y = 48 / (1 + np.exp((x - D50) / dx))\\n return y\",\n \"def tanh(d: D) -> NumDict:\\n\\n return (2 * sigmoid(d)) - 1\",\n \"def gradientFunctionReg(theta, X, y, Lambda): \\n y = np.squeeze(y)\\n m = y.shape # number of training samples\\n grad = X.T.dot(sigmoid(theta.dot(X.T))-1*y)\\n grad[1:] = grad[1:] + Lambda*theta[1:]\\n grad /= m\\n\\n return grad\",\n \"def sigmoid(self, x):\\n y = 1/(1 + np.exp((-x)))\\n return y \\n raise NotImplementedError(\\\"Sigmoid not implemented\\\")\",\n \"def log_likelihood_gradient(y, tx, w):\\n return tx.T.dot(sigmoid(tx.dot(w))-y)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.84754366","0.8450928","0.8396931","0.83485264","0.83485264","0.8298343","0.80539966","0.7753385","0.77070266","0.7498153","0.7464916","0.7454039","0.7401582","0.7385017","0.73829913","0.7346935","0.7321687","0.73094004","0.7192053","0.7113881","0.7092362","0.7078831","0.7029014","0.70273757","0.69446236","0.68655735","0.6825908","0.6791096","0.67865175","0.6777258","0.67513657","0.6699031","0.66788644","0.66580355","0.665712","0.66448903","0.66248435","0.6617182","0.660039","0.65769714","0.6570592","0.65705764","0.6556815","0.65558916","0.65399027","0.65399027","0.65281373","0.65281373","0.6527877","0.6492288","0.6476499","0.64620984","0.6461357","0.64541733","0.64251685","0.6417301","0.64109075","0.6396677","0.6389712","0.63885486","0.6386201","0.6384595","0.6384245","0.6384245","0.6384245","0.6384245","0.6384245","0.6384245","0.63816947","0.6381341","0.6379581","0.6379581","0.63778317","0.6371513","0.63555825","0.63510185","0.63486135","0.6348341","0.6348341","0.6348188","0.63413966","0.6313521","0.63077","0.63061273","0.6303397","0.63014543","0.6298837","0.62968314","0.62932473","0.6286993","0.628454","0.6280976","0.6279159","0.62788993","0.62785167","0.627547","0.62717015","0.62644607","0.62582153","0.6251117","0.62281543"],"string":"[\n \"0.84754366\",\n \"0.8450928\",\n \"0.8396931\",\n \"0.83485264\",\n \"0.83485264\",\n \"0.8298343\",\n \"0.80539966\",\n \"0.7753385\",\n \"0.77070266\",\n \"0.7498153\",\n \"0.7464916\",\n \"0.7454039\",\n \"0.7401582\",\n \"0.7385017\",\n \"0.73829913\",\n \"0.7346935\",\n \"0.7321687\",\n \"0.73094004\",\n \"0.7192053\",\n \"0.7113881\",\n \"0.7092362\",\n \"0.7078831\",\n \"0.7029014\",\n \"0.70273757\",\n \"0.69446236\",\n \"0.68655735\",\n \"0.6825908\",\n \"0.6791096\",\n \"0.67865175\",\n \"0.6777258\",\n \"0.67513657\",\n \"0.6699031\",\n \"0.66788644\",\n \"0.66580355\",\n \"0.665712\",\n \"0.66448903\",\n \"0.66248435\",\n \"0.6617182\",\n \"0.660039\",\n \"0.65769714\",\n \"0.6570592\",\n \"0.65705764\",\n \"0.6556815\",\n \"0.65558916\",\n \"0.65399027\",\n \"0.65399027\",\n \"0.65281373\",\n \"0.65281373\",\n \"0.6527877\",\n \"0.6492288\",\n \"0.6476499\",\n \"0.64620984\",\n \"0.6461357\",\n \"0.64541733\",\n \"0.64251685\",\n \"0.6417301\",\n \"0.64109075\",\n \"0.6396677\",\n \"0.6389712\",\n \"0.63885486\",\n \"0.6386201\",\n \"0.6384595\",\n \"0.6384245\",\n \"0.6384245\",\n \"0.6384245\",\n \"0.6384245\",\n \"0.6384245\",\n \"0.6384245\",\n \"0.63816947\",\n \"0.6381341\",\n \"0.6379581\",\n \"0.6379581\",\n \"0.63778317\",\n \"0.6371513\",\n \"0.63555825\",\n \"0.63510185\",\n \"0.63486135\",\n \"0.6348341\",\n \"0.6348341\",\n \"0.6348188\",\n \"0.63413966\",\n \"0.6313521\",\n \"0.63077\",\n \"0.63061273\",\n \"0.6303397\",\n \"0.63014543\",\n \"0.6298837\",\n \"0.62968314\",\n \"0.62932473\",\n \"0.6286993\",\n \"0.628454\",\n \"0.6280976\",\n \"0.6279159\",\n \"0.62788993\",\n \"0.62785167\",\n \"0.627547\",\n \"0.62717015\",\n \"0.62644607\",\n \"0.62582153\",\n \"0.6251117\",\n \"0.62281543\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":80999,"cells":{"query":{"kind":"string","value":"TM_fluid returns the 2x2 Transfer Matrix of a fluid layer"},"document":{"kind":"string","value":"def TM_fluid(layer, kx, om):\n\n h = layer.d\n rho = layer.medium.rho\n K = layer.medium.K\n k = om*np.sqrt(rho/K)\n ky = np.sqrt(k**2-kx**2)\n T = np.zeros((2, 2), dtype=complex)\n T[0, 0] = np.cos(ky*h)\n T[1, 0] = (om**2*rho/ky)*np.sin(ky*h)\n T[0, 1] = -(ky/(om**2*rho))*np.sin(ky*h)\n T[1, 1] = np.cos(ky*h)\n return T"},"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 fluid_func(self):\n residual = []\n for fluid, x in self.inl[0].fluid.val.items():\n res = x * self.inl[0].m.val_SI\n for o in self.outl:\n res -= o.fluid.val[fluid] * o.m.val_SI\n residual += [res]\n return residual","def fluid_func(self):\n residual = []\n for i in range(self.num_i):\n for fluid, x in self.inl[0].fluid.val.items():\n residual += [x - self.outl[0].fluid.val[fluid]]\n return residual","def __tensor_flatten__(self):\n return self._local_tensor, self._spec","def getTransportMatrix(self):\n\t\treturn self.trMtrx","def heat_flux_out(T_inf, T_old, hc_air, emmi):\n\n #nz = T_old.shape[0]\n ny = T_old.shape[0]\n nx = T_old.shape[1]\n\n Q_out = np.zeros((ny, nx))\n h_eff = np.zeros((ny, nx))\n T_eff = np.zeros((ny, nx))\n for i in range(nx):\n for j in range(ny):\n T_eff[j, i] = ((T_old[j, i]**3) + (T_inf * T_old[j, i]**2)\n + (T_old[j, i] * T_inf**2) + T_inf**3)\n\n h_eff[j, i] = hc_air + (emmi*STEF_BOL_C*T_eff[j, i])\n\n Q_out[j, i] = h_eff[j, i] * (T_old[j, i] - T_inf)\n\n return Q_out","def T(self) -> BaseMatrix:","def T(self) -> BaseMatrix:","def calc_ti(self):\n m = 0\n for i in self.inl:\n m += i.m.val_SI * i.fluid.val[self.fuel_alias.val]\n\n for o in self.outl:\n m -= o.m.val_SI * o.fluid.val[self.fuel_alias.val]\n\n return m * self.lhv","def fluid_deriv(self):\n deriv = np.zeros((self.fluid_constraints['num_eq'],\n 2 * self.num_i + self.num_vars,\n self.num_nw_vars))\n for i in range(self.num_i):\n for j in range(self.num_nw_fluids):\n deriv[i * self.num_nw_fluids + j, i, j + 3] = 1\n deriv[i * self.num_nw_fluids + j, self.num_i + i, j + 3] = -1\n return deriv","def T(self):\n # TODO - your code here\n matrix_transpose = [];\n \n for j in range(self.w):\n matrix_transpose.append(self.get_column(j));\n \n return Matrix(matrix_transpose);","def u_t(self):\n\t\tdim = self.dim \n\t\ttim_all = self.tim_all\n\t\t#ctrl = self.ctrl\n\t\tH0 = self.H0\n\t\tHctrl = self.Hctrl\n\n\t\tu_all = np.zeros((tim_all+1,dim,dim),dtype = complex)\n\t\tu_all[0,:,:] = np.eye(dim)\n\n\t\tfor tim in xrange(tim_all):\n\t\t\tH = H0 + Hctrl[tim]#np.matrix( ctrl[i,tim] * np.array(Hctrl[i]))\n\t\t\tu_all[tim+1,:,:] = np.dot(self.u_dt(H,tim), u_all[tim,:,:])\n\n\n\t\treturn u_all","def getHeatFlux(self, T):\n\t\tQ = self.heat_transfer_coefficient * (self.T_wall - T)\n\t\treturn Q","def T(self):\n return F.Transpose.apply(self)","def transferMatrix(self, i1=0, i2=-1, plane=\"x\"):\n B2 = self.normMat(i2, plane=plane)\n B1 = self.normMat(i1, plane=plane)\n psi = 2 * np.pi * (self[\"mu\" + plane][i2] - self[\"mu\" + plane][i1])\n R = np.array([[np.cos(psi), np.sin(psi)], [-np.sin(psi), np.cos(psi)]])\n return np.dot(np.dot(B2, R), np.linang.inv(B1))","def Flux(self, flux, r_lim, z_lim):\n if flux == 'mass':\n set_integrand = lambda x: x\n\n elif flux == 'momentum':\n set_integrand = lambda x: x**2\n\n elif flux == 'buoyancy':\n b = self.read_vars(['b'])['b']\n set_integrand = lambda x: x*b\n\n npx = self.params['npx']\n Lx = self.params['Lx']\n Ly = self.params['Ly']\n Lz = self.params['Lz']\n nz = self.params['nz']\n\n dx = Lx/npx\n t = self.read_vars(['t'])['t']\n n_time = t.shape[0]\n\n r_max = r_lim # as in forced_plume_nudging.py\n z_max = z_lim\n new_nz = int(nz*z_lim)\n\n flux = np.zeros(n_time)\n\n fields = self.read_vars(['w', 'x', 'y', 'z'])\n w = velocity_interpolation(fields['w'], axis=1)\n\n XX, YY = np.meshgrid(fields['x']/Lx - 0.5,\n fields['y']/Ly - 0.5)\n\n r = np.sqrt(XX**2 + YY**2)\n mask_1 = ma.masked_outside(r, 0, r_max)\n #mask_2 = ma.masked_outside(ZZ, 0, z_max)\n\n # defining integrand\n integrand = set_integrand(w)\n\n for t in range(n_time):\n aux = np.zeros(new_nz)\n for z_i in range(new_nz):\n field_new = ma.masked_array(integrand[t, z_i], mask_1.mask)\n aux[z_i] = field_new.sum()\n\n flux[t] = aux.sum()\n\n return flux","def full_matrix(self):\n # print(self.b,np.shape(self.b))\n # print(self.b_u[:, np.newaxis])\n # print(self.b_i[np.newaxis:, ],\"TTTT\")\n # print(self.P.dot(self.Q.T))\n if (self.type=='bias'):\n return self.b + self.b_u[:, np.newaxis] + self.b_i[np.newaxis:, ] + self.P.dot(self.Q.T)\n elif (self.type=='nonbias'):\n return self.P.dot(self.Q.T)","def mtf_unitransformer_base():\n hparams = mtf_transformer2_base()\n hparams.add_hparam(\"autoregressive\", True)\n # HYPERPARAMETERS FOR THE SINGLE LAYER STACK\n hparams.add_hparam(\"layers\", [\"self_att\", \"drd\"] * 6)\n # number of heads in multihead attention\n hparams.add_hparam(\"num_heads\", 8)\n # default of 0 for standard transformer behavior\n # 1 means a single set of keys and values that are read by all query heads\n hparams.add_hparam(\"num_memory_heads\", 0)\n # share attention keys and values\n hparams.add_hparam(\"shared_kv\", False)\n # if nonzero then use local attention\n hparams.add_hparam(\"local_attention_radius\", 128)\n return hparams","def mtr_tr_dense_local(sz):\n hparams = mtr_tr_dense(sz)\n hparams.decoder_layers = [\"local_self_att\", \"enc_att\", \"drd\"] * 6\n hparams.local_attention_radius = 32\n return hparams","def get_mfp(self, T):\n\n self.air.T = T\n self.air.set_TempPres_dependents()\n\n self.mfp = (\n (np.sqrt(2.) * np.pi * self.air.d ** 2. * self.air.n) ** -1.\n )\n\n return self.mfp","def build_transfer_mx(self, t_params=None, apply_abs=True):\n if t_params is None: t_params = self.t_params\n tmx = _np.sum([t_params[ind] * self.t_basis[ind] for ind in range(self.dim)], axis=0) + _np.eye(self.n)\n return _np.abs(tmx) if apply_abs else tmx","def FitFundamentalMatrix(mss):\n\n\tbatch_size = mss.shape[0]\n\tnum_correspondences = mss.shape[1]\t\n\n\tmss_src, T_src = utils.normalise2dpts(mss[:, :, :2])\n\tmss_target, T_target = utils.normalise2dpts(mss[:, :, 2:])\n\n\tones = torch.tensor([1]).double().cuda().view(1, 1, 1).repeat(batch_size, num_correspondences, 1)\n\tmss_src = torch.cat([mss_src, ones], dim = 2)\n\tmss_target = torch.cat([mss_target, ones], dim = 2)\n\n\trow = torch.cat([\n\t\tmss_src * mss_target[:, :, 0].view(batch_size, num_correspondences, 1), \n\t\tmss_src * mss_target[:, :, 1].view(batch_size, num_correspondences, -1),\n\t\tmss_src \n\t], dim = 2)\n\n\n\touter_product = row.unsqueeze(3) * row.unsqueeze(2)\n\tmat = outer_product.sum(dim = 1)\n\n\n\tU = []\n\tS = []\n\tVT = []\n\n\tfor i in range(batch_size):\n\n\t\t_, V = torch.symeig(mat[i])\n\t\tu, s, v = torch.svd(V[:, 0].view(3, 3))\n\t\tvt = v.permute(1, 0)\n\t\ts[2] = 0\n\n\t\tU.append(u.unsqueeze(0))\n\t\tS.append(torch.diag(s).unsqueeze(0))\n\t\tVT.append(vt.unsqueeze(0))\n\n\tU = torch.cat(U, dim = 0)\n\tS = torch.cat(S, dim = 0)\n\tVT = torch.cat(VT, dim = 0)\n\n\tF = torch.bmm(torch.bmm(U, S), VT)\n\tF = torch.bmm(T_src, torch.bmm(F.permute(0, 2, 1), T_target.permute(0, 2, 1)))\n\tF = F / F[:, 2, 2].view(batch_size, 1, 1)\n\n\tutils.nan_check(F)\n\n\treturn F","def miccai2018_net_t1t2(vol_size, enc_nf, dec_nf, int_steps=7, use_miccai_int=False, indexing='ij', bidir=False, vel_resize=1/2): \n ndims = len(vol_size)\n assert ndims in [1, 2, 3], \"ndims should be one of 1, 2, or 3. found: %d\" % ndims\n\n # get unet\n unet_model_channel1 = unet_core(vol_size, enc_nf, dec_nf, full_size=False)\n [srcT1, tgtT1] = unet_model_channel1.inputs\n x_out_T1 = unet_model_channel1.outputs[-1]\n unet_model_channel2 = unet_core(vol_size, enc_nf, dec_nf, full_size=False)\n [srcT2, tgtT2] = unet_model_channel2.inputs\n x_out_T2 = unet_model_channel2.outputs[-1]\n\n # velocity mean and logsigma layers\n Conv = getattr(KL, 'Conv%dD' % ndims)\n flow_mean_T1 = Conv(ndims, kernel_size=3, padding='same',\n kernel_initializer=RandomNormal(mean=0.0, stddev=1e-5), name='flow_T1')(x_out_T1)\n # we're going to initialize the velocity variance very low, to start stable.\n flow_log_sigma_T1 = Conv(ndims, kernel_size=3, padding='same',\n kernel_initializer=RandomNormal(mean=0.0, stddev=1e-10),\n bias_initializer=keras.initializers.Constant(value=-10),\n name='log_sigma_T1')(x_out_T1)\n flow_params_T1 = concatenate([flow_mean_T1, flow_log_sigma_T1])\n flow_T1 = Sample(name=\"z_sample_T1\")([flow_mean_T1, flow_log_sigma_T1])\n \n # integrate if diffeomorphic (i.e. treating 'flow' above as stationary velocity field)\n if use_miccai_int:\n # for the miccai2018 submission, the squaring layer\n # scaling was essentially built in by the network\n # was manually composed of a Transform and and Add Layer.\n v = flow_T1\n for _ in range(int_steps):\n v1 = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([v, v])\n v = keras.layers.add([v, v1])\n flow_T1 = v\n\n else:\n # new implementation in neuron is cleaner.\n z_sample = flow_T1\n flow_T1 = nrn_layers.VecInt(method='ss', name='flow-int_T1', int_steps=int_steps)(z_sample)\n if bidir:\n rev_z_sample = Negate()(z_sample)\n neg_flow_T1 = nrn_layers.VecInt(method='ss', name='neg_flow-int_T1', int_steps=int_steps)(rev_z_sample)\n # get up to final resolution\n flow_T1 = trf_resize(flow_T1, vel_resize, name='diffflow_T1')\n if bidir:\n neg_flow_T1 = trf_resize(neg_flow_T1, vel_resize, name='neg_diffflow_T1')\n # transform\n y_T1 = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([srcT1, flow_T1])\n if bidir:\n y_tgt_T1 = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([tgtT1, neg_flow_T1])\n \n flow_mean_T2 = Conv(ndims, kernel_size=3, padding='same',\n kernel_initializer=RandomNormal(mean=0.0, stddev=1e-5), name='flow_T2')(x_out_T2)\n # we're going to initialize the velocity variance very low, to start stable.\n flow_log_sigma_T2 = Conv(ndims, kernel_size=3, padding='same',\n kernel_initializer=RandomNormal(mean=0.0, stddev=1e-10),\n bias_initializer=keras.initializers.Constant(value=-10),\n name='log_sigma_T2')(x_out_T2)\n flow_params_T2 = concatenate([flow_mean_T2, flow_log_sigma_T2])\n flow_T2 = Sample(name=\"z_sample_T2\")([flow_mean_T2, flow_log_sigma_T2])\n # integrate if diffeomorphic (i.e. treating 'flow' above as stationary velocity field)\n if use_miccai_int:\n # for the miccai2018 submission, the squaring layer\n # scaling was essentially built in by the network\n # was manually composed of a Transform and and Add Layer.\n v = flow_T2\n for _ in range(int_steps):\n v1 = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([v, v])\n v = keras.layers.add([v, v1])\n flow_T2 = v\n\n else:\n # new implementation in neuron is cleaner.\n z_sample = flow_T2\n flow_T2 = nrn_layers.VecInt(method='ss', name='flow-int_T2', int_steps=int_steps)(z_sample)\n if bidir:\n rev_z_sample = Negate()(z_sample)\n neg_flow_T2 = nrn_layers.VecInt(method='ss', name='neg_flow-int_T2', int_steps=int_steps)(rev_z_sample)\n # get up to final resolution\n flow_T2 = trf_resize(flow_T2, vel_resize, name='diffflow_T2')\n if bidir:\n neg_flow_T2 = trf_resize(neg_flow_T2, vel_resize, name='neg_diffflow_T2')\n # transform\n y_T2 = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([srcT2, flow_T2])\n if bidir:\n y_tgt_T2 = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([tgtT2, neg_flow_T2])\n\n # velocity sample\n flow_params = MergeInputs3D()([flow_params_T1, flow_params_T2])\n ndims = len(flow_params.get_shape()) - 2\n flow_mean = flow_params[..., 0:ndims]\n flow_log_sigma = flow_params[..., ndims:]\n flow = Sample(name=\"z_sample\")([flow_mean, flow_log_sigma])\n\n # integrate if diffeomorphic (i.e. treating 'flow' above as stationary velocity field)\n if use_miccai_int:\n # for the miccai2018 submission, the squaring layer\n # scaling was essentially built in by the network\n # was manually composed of a Transform and and Add Layer.\n v = flow\n for _ in range(int_steps):\n v1 = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([v, v])\n v = keras.layers.add([v, v1])\n flow = v\n\n else:\n # new implementation in neuron is cleaner.\n z_sample = flow\n flow = nrn_layers.VecInt(method='ss', name='flow-int', int_steps=int_steps)(z_sample)\n if bidir:\n rev_z_sample = Negate()(z_sample)\n neg_flow = nrn_layers.VecInt(method='ss', name='neg_flow-int', int_steps=int_steps)(rev_z_sample)\n\n # get up to final resolution\n flow = trf_resize(flow, vel_resize, name='diffflow')\n\n if bidir:\n neg_flow = trf_resize(neg_flow, vel_resize, name='neg_diffflow')\n\n # transform\n y_T1_byflow = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([srcT1, flow])\n y_T2_byflow = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([srcT2, flow])\n if bidir:\n y_tgt_T1_bynegflow = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([tgtT1, neg_flow])\n y_tgt_T2_bynegflow = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([tgtT2, neg_flow])\n\n # prepare outputs and losses\n outputs = [y_T1_byflow,y_T2_byflow, flow_params, y_T1, y_T2]\n if bidir:\n outputs = [y_T1_byflow,y_T1_byflow,y_tgt_T1_bynegflow, y_tgt_T2_bynegflow, flow_params,y_T1, y_tgt_T1,y_T2, y_tgt_T2]\n # build the model\n return Model(inputs=[srcT1, tgtT1, srcT2, tgtT2], outputs=outputs)","def assemble_matrices(self):\n \n #Pointer reassignment for convenience\n N = self.ngrids\n\n #Begin with a linked-list data structure for the transmissibilities,\n #and one-dimenstional arrays for the diagonal of B and the flux vector\n T = lil_matrix((N, N), dtype=np.double)\n B = np.zeros(N, dtype=np.double)\n Q = np.zeros(N, dtype=np.double)\n\n #Read in boundary condition types and values\n bcs = self.input_data['boundary conditions']\n bc_type_1 = bcs['left']['type'].lower()\n bc_type_2 = bcs['right']['type'].lower()\n bc_value_1 = bcs['left']['value']\n bc_value_2 = bcs['right']['value']\n \n #Loop over all grid cells\n for i in range(N):\n\n #Apply left BC\n if i == 0:\n T[i, i+1] = -self.compute_transmissibility(i, i + 1)\n\n if bc_type_1 == 'neumann':\n T[i, i] = T[i,i] - T[i, i+1]\n elif bc_type_1 == 'dirichlet':\n #Computes the transmissibility of the ith block\n T0 = self.compute_transmissibility(i, i)\n T[i, i] = T[i,i] - T[i, i+1] + 2.0 * T0\n Q[i] = 2.0 * T0 * bc_value_1\n else:\n pass #TODO: Add error checking here if no bc is specified\n\n #Apply right BC\n elif i == (N - 1):\n T[i, i-1] = -self.compute_transmissibility(i, i - 1)\n\n if bc_type_2 == 'neumann':\n T[i, i] = T[i,i] - T[i, i-1]\n elif bc_type_2 == 'dirichlet':\n #Computes the transmissibility of the ith block\n T0 = self.compute_transmissibility(i, i)\n T[i, i] = T[i, i] - T[i, i-1] + 2.0 * T0\n Q[i] = 2.0 * T0 * bc_value_2\n else:\n pass #TODO:Add error checking here if no bc is specified\n\n #If there is no boundary condition compute interblock transmissibilties\n else:\n T[i, i-1] = -self.compute_transmissibility(i, i-1)\n T[i, i+1] = -self.compute_transmissibility(i, i+1)\n T[i, i] = (self.compute_transmissibility(i, i-1) +\n self.compute_transmissibility(i, i+1))\n\n #Compute accumulations\n B[i] = self.compute_accumulation(i)\n\n #If constant-rate wells are present, add them to the flux vector\n if self.rate_well_grids is not None:\n Q[self.rate_well_grids] += self.rate_well_values\n\n \n #Return sparse data-structures\n return (T.tocsr(), \n csr_matrix((B, (np.arange(N), np.arange(N))), shape=(N,N)), \n Q)","def T(self):\n try:\n return self.__T\n except AttributeError:\n raise AttributeError(\"Haven't run stitching, so we don't have the T matrix\")","def flux(self, u):\n flu = np.zeros((3,2), dtype=np.float64)\n flu[0,0] = u[1]\n flu[1,0] = u[0] * (u[1]/u[0])**2 + 0.5 * 9.81*u[0]**2\n flu[2,0] = u[1] * u[2]/u[0] #FIXME attenzione che c'è il punto controllare se sono scalari o vettori'\n flu[0,1] = u[2]\n flu[1,1] = u[2] * u[1]/u[0]\n flu[2,1] = u[0] * (u[2]/u[0])**2 + 0.5 * 9.81*u[0]**2\n return flu","def TNFR1_to_SecondaryComplex():\n \n Parameter('TNFa_0' , 5000) # 3000 corresponds to 50ng/ml TNFa\n Parameter('TNFR1_0' , 200) # 200 receptors per cell\n Parameter('TRADD_0' , 1000) # molecules per cell (arbitrarily assigned)1000\n Parameter('CompI_0' , 0) # complexes per cell\n Parameter('RIP1_0' , 20000) # molecules per cell 20000\n Parameter('NFkB_0' , 0) # molecules per cell\n \n Initial(TNFa(blig=None), TNFa_0) # TNFa Ligand\n Initial(TNFR1(blig=None, bDD=None, state='norm'), TNFR1_0) # TNFR1\n Initial(TRADD(bDD1=None, bDD2=None, state='inactive'), TRADD_0) # TRADD\n Initial(CompI(bDD=None, state='unmod'), CompI_0) # Complex I\n Initial(RIP1(bDD=None, bRHIM = None, state = 'ub'), RIP1_0) # RIP1\n Initial(NFkB(bf=None), NFkB_0)\n\n # =========================================\n # TNFR1 ligation, formation of Complex I and release of RIP1 and TRADD rules\n # -----------------------------------------\n # TNFa+ TNFR1 <-> TNFa:TNFR1\n # TNFa:TNFR1 + TRADD <-> TNFa:TNFR1:TRADD >> CompI\n # CompI + RIP1 <-> CompI:RIP1 >> [active]CompI:RIP1-Ub\n # CompI + RIP1-Ub <-> CompI:RIP1-Ub \n \n # [active]CompI:RIP1-Ub >> NFkB # This reaction will consume the receptor.\n # [active]CompI:RIP1-Ub >> [active]CompI:RIP1\n # [active]CompI:RIP1 >> [active]CompI # A20 mediated degradation of RIP1\n # [active]CompI:RIP1 >> [active]CompI + RIP1\n # [active]CompI >> [active]TRADD + [norm]TNFR1 #receptor recycle typically distroys the ligand.\n\n # RIP1 >> RIP1-Ub #These reactions were added because Doug Green reported that FADD and RIP1 bind\n # RIP1-Ub >> RIP1 #independently of receptor, and FADD:RIP1 formation leads to Caspase 8 activation.\n #These reaction decrease the amount of RIP1 by spontaneously ubiquitinating it. \n\n # ------------------------------------------\n \n # -------------Complex I assembly----------------\n bind(TNFa(blig=None), 'blig', TNFR1(blig=None, bDD=None, state='norm'), 'blig', [KF, KR])\n bind(TNFR1(blig = ANY, bDD = None, state = 'norm'), 'bDD', TRADD(bDD1=None, bDD2=None, state='inactive'), 'bDD1', [KF, KR])\n preCompI = TNFa(blig=ANY)%TNFR1(blig=ANY, bDD=ANY, state = 'norm')%TRADD(bDD1 = ANY, bDD2=None, state = 'inactive')\n Rule('CompI_formation', preCompI >> CompI(bDD=None, state = 'unmod'), KC)\n \n # --------------Complex I - RIP1 Modification-----------------\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='unmod'), 'bDD',[KF, KR])\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[KF, KR]) \n \n Rule('CompI_Ub', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'unmod')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), KC)\n Rule('CompI_Ub2', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), KC)\n Rule('CompI_deUb', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub')>>CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None,state='unmod'),KC)\n bind(CompI(bDD=None, state='mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state = 'unmod'), 'bDD', [Parameter('k2', 0), KR])\n #Rule('RIP1_rel', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='unmod') >> CompI(bDD=None, state='mod') + RIP1(bDD=None, bRHIM = None, state = 'unmod'), KC3)\n #bind(CompI(bDD=None, state = 'mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[KF, KR])\n #Rule('RIP1_deg', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='unmod') >> CompI(bDD=None, state='mod'),KC3)\n Rule('TNFR1_recycle', CompI(bDD=None, state='mod') >> TRADD(bDD1=None, bDD2 = None, state='active') + TNFR1(blig = None, bDD = None, state = 'norm'), KC)\n Rule('NFkB_expression', CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub') + NFkB(bf=None), KE)\n # --------------RIP1 Ubiquitination---------------------------\n Rule('RIP1_Ub', RIP1(bDD=None, bRHIM = None, state='unmod')>> RIP1(bDD=None, bRHIM = None, state='ub'), KC2)\n # Rule('RIP1_deUb', RIP1(bDD=None, bRHIM = None, state='ub')>> RIP1(bDD=None, bRHIM = None, state='unmod'), KR)","def TNFR1_to_SecondaryComplex():\n \n Parameter('TNFa_0' , 6000) # 6000 corresponds to 100ng/ml TNFa\n Parameter('TNFR1_0' , 4800) # 4800 receptors per cell\n Parameter('TRADD_0' , 9000) # molecules per cell (arbitrarily assigned) 9000\n Parameter('RIP1_0' , 12044) # molecules per cell (arbitrarily assigned) 12044\n Parameter('CompI_0' , 0) # complexes per cell\n Parameter('NFkB_0' , 0) # molecules per cell\n alias_model_components()\n \n Initial(TNFa(blig=None), TNFa_0) # TNFa Ligand\n Initial(TNFR1(blig=None, bDD=None, state='norm'), TNFR1_0) # TNFR1\n Initial(TRADD(bDD1=None, bDD2=None, state='inactive'), TRADD_0) # TRADD\n Initial(CompI(bDD=None, state='unmod'), CompI_0) # Complex I\n Initial(RIP1(bDD=None, bRHIM = None, bPARP = None, state = 'ub'), RIP1_0) # RIP1\n Initial(NFkB(bf=None), NFkB_0)\n \n # =========================================\n # TNFR1 ligation, formation of Complex I and release of RIP1 and TRADD rules\n # -----------------------------------------\n # TNFa+ TNFR1 <-> TNFa:TNFR1\n # TNFa:TNFR1 + TRADD <-> TNFa:TNFR1:TRADD >> CompI\n # CompI + RIP1 <-> CompI:RIP1 >> [active]CompI:RIP1-Ub\n # CompI + RIP1-Ub <-> CompI:RIP1-Ub\n \n # [active]CompI:RIP1-Ub >> NFkB # This reaction will consume the receptor.\n # [active]CompI:RIP1-Ub >> [active]CompI:RIP1\n # [active]CompI:RIP1 >> [active]CompI # A20 mediated degradation of RIP1\n # [active]CompI:RIP1 >> [active]CompI + RIP1\n # [active]CompI >> [active]TRADD + [norm]TNFR1 #receptor recycle typically distroys the ligand.\n \n # RIP1 >> RIP1-Ub #These reactions were added because Doug Green reported that FADD and RIP1 bind\n # RIP1-Ub >> RIP1 #independently of receptor, and FADD:RIP1 formation leads to Caspase 8 activation.\n #These reaction decrease the amount of RIP1 by spontaneously ubiquitinating it.\n \n # ------------------------------------------\n \n # -------------Complex I assembly----------------\n bind(TNFa(blig=None), 'blig', TNFR1(blig=None, bDD=None, state='norm'), 'blig', [2e-7, 1e-4])\n bind(TNFR1(blig = ANY, bDD = None, state = 'norm'), 'bDD', TRADD(bDD1=None, bDD2=None, state='inactive'), 'bDD1', [1e-6, 0.2])\n preCompI = TNFa(blig=ANY)%TNFR1(blig=ANY, bDD=ANY, state = 'norm')%TRADD(bDD1 = ANY, bDD2=None, state = 'inactive')\n Rule('CompI_formation', preCompI >> CompI(bDD=None, state = 'unmod'), Parameter('k2', 1))\n \n # --------------Complex I - RIP1 Modification-----------------\n # Complex I recruits RIP1\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='unmod'), 'bDD',[1e-6, 1e-3])\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[1e-6, 1e-3])\n \n # Complex I undergos modifications (e.g. Ubiquitination) and elicits NFkB signaling\n Rule('CompI_Ub', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'unmod')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), Parameter('k3', 1))\n Rule('CompI_Ub2', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), Parameter('k4', 1))\n Rule('NFkB_signaling', CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub') + NFkB(bf=None), Parameter('k5', 1e-3))\n\n # De-ubiquitination and degradation or release of RIP1 from complex I\n Rule('CompI_deUb', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub')>>CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None,state='unmod'), Parameter('k6',1))\n Rule('RIP1_deg', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub') >> CompI(bDD=None, state='mod'), Parameter('k7',1))\n \n bind(CompI(bDD=None, state='mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state = 'unmod'), 'bDD', [1e-10,1])\n \n # Receptor recycle\n Rule('TNFR1_recycle', CompI(bDD=None, state='mod') >> TRADD(bDD1=None, bDD2 = None, state='active') + TNFR1(blig = None, bDD = None, state = 'norm'), Parameter('k8',1))\n \n # --------------RIP1 Ubiquitination---------------------------\n Rule('RIP1_Ub', RIP1(bDD=None, bRHIM = None, state='unmod')>> RIP1(bDD=None, bRHIM = None, state='ub'), Parameter('k9', 1e-7))","def T(self):\n # TODO - your code here\n transpose = []\n for col in range(self.w):\n new_row = []\n for row in range(self.h):\n new_row.append(self.g[row][col])\n transpose.append(new_row)\n return Matrix(transpose)\n # TODO - your code here","def get_u_tile(cls, s, s2):\n a_weight = F.softmax(s, dim=2) # [B, t1, t2]\n a_weight.data.masked_fill_(a_weight.data != a_weight.data, 0) # remove nan from softmax on -inf\n u_tile = torch.bmm(a_weight, s2) # [B, t1, t2] * [B, t2, D] -> [B, t1, D]\n return u_tile","def get_transmission(I, A, darkch, omega, w):\n return 1 - omega * get_dark_channel(I / A, w)","def _stack(matrix, fluid1, fluid2=None):\n # Cast input\n m = np.array(matrix, ndmin=1)\n f1 = np.array(fluid1, ndmin=1)\n\n # If array is identical, reduce to one value\n if np.all(m[:-1]-m[1:] == 0):\n m = np.array([m[0]])\n if np.all(f1[:-1]-f1[1:] == 0):\n f1 = np.array([f1[0]])\n\n # Return depending if `fluid2` or not\n if fluid2:\n f2 = np.array(fluid2, ndmin=1)\n if np.all(f2[:-1]-f2[1:] == 0):\n f2 = np.array([f2[0]])\n eperm = np.column_stack((np.tile(m, f1.size*f2.size),\n f1.repeat(m.size*f2.size),\n np.tile(f2.repeat(m.size), f1.size)))\n return eperm\n else:\n return np.column_stack((np.tile(m, f1.size), f1.repeat(m.size)))","def get_unitary(self, params: Sequence[float] = []) -> UnitaryMatrix:\n self.check_parameters(params)\n if hasattr(self, 'utry'):\n return self.utry\n\n return self.gate.get_unitary(params)","def Controlled2(U):\n '''Generalized controlled unitary tensor construction\n Parameters:\n -----------\n U: input tensor which is assumed to be a square Matrix\n\n Returns:\n --------\n Controlled unitary\n\n '''\n shp = U.shape\n new_ten = scipy.linalg.block_diag(np.eye(*shp), U)\n return new_ten.reshape(2, shp[0], 2, shp[1], 2, shp[2])","def Static_T(Temp_m,M):\n return Temp_m/(1+(gamma-1)/2*M**2)","def getTransposeMatrix(self) -> CMatrix4:\n ...","def getMatrixRepresentation(self):\n \n S = self.spinSystem\n dim = S.dimension\n matRep = np.zeros([dim, dim], dtype = complex)\n\n for i, b1 in enumerate(S.basis.Bras):\n for j, b2 in enumerate(S.basis.Kets):\n ket = self.__mul__(b2)\n\n matRep[i,j] += b1*ket\n\n return matRep","def T(self, q = np.zeros(2) , dq = np.zeros(2) , ddq = np.zeros(2) , uD = 0 , t = 0 ): \n \n R = self.R[uD]\n \n e = self.F( q , dq , ddq , t ) # actuator efforts computed for manipulator side only\n \n Tl = self.Tlosses( q , dq , ddq ) # see alex logbook : virtual effort related to motor losses (inertial and viscous rotor forces)\n \n T = np.dot( np.linalg.inv(R) , e ) + np.dot( R , Tl ) \n \n return T","def T(self, q = np.zeros(2) , dq = np.zeros(2) , ddq = np.zeros(2) , uD = 0 , t = 0 ): \n \n R = self.R[uD]\n \n e = self.F( q , dq , ddq , t ) # actuator efforts computed for manipulator side only\n \n Tl = self.Tlosses( q , dq , ddq ) # see alex logbook : virtual effort related to motor losses (inertial and viscous rotor forces)\n \n T = np.dot( np.linalg.inv(R) , e ) + np.dot( R , Tl ) \n \n return T","def Flux_levels(self, flux, r_lim=0.45):\n if flux == 'mass':\n set_integrand = lambda x: x\n\n elif flux == 'momentum':\n set_integrand = lambda x: x**2\n\n elif flux == 'buoyancy':\n b = self.read_vars(['b'])['b']\n set_integrand = lambda x: x*b\n\n npx = self.params['npx']\n Lx = self.params['Lx']\n Ly = self.params['Ly']\n Lz = self.params['Lz']\n nz = self.params['nz']\n dx = self.params['dx']\n dy = self.params['dy']\n\n t = self.read_vars(['t'])['t']\n n_time = t.shape[0]\n\n r_max = r_lim # as in forced_plume_nudging.py\n z_max = 0.95\n\n\n flux = np.zeros((n_time, nz))\n\n fields = self.read_vars(['w', 'x', 'y', 'z'])\n w = velocity_interpolation(fields['w'], axis=1)\n\n XX, YY = np.meshgrid(fields['x']/Lx - 0.5,\n fields['y']/Ly - 0.5)\n\n r = np.sqrt(XX**2 + YY**2)\n mask_1 = ma.masked_outside(r, 0, r_max)\n #mask_2 = ma.masked_outside(ZZ, 0, z_max)\n\n # defining integrand\n integrand = set_integrand(w)\n\n for t in range(n_time):\n for z_i in range(nz):\n field_new = ma.masked_array(integrand[t, z_i], mask_1.mask)\n flux[t, z_i] = field_new.sum()\n\n return flux","def _fluctuation_matrix(reference_frame, trajectories_path, atom_subset, topology, chunk, first_frame):\n residual_sum_squares = np.zeros((len(atom_subset)))\n \n ## now can compute the difference between the trajectory and its reference\n ## ri(t) - riref Using the mdtraj trajectory attribute xyz to extract\n ## the cartesian coordinates of trajectory and reference in a numpy array\n ## chunk.xyz.shape = (frames, atom, coordinate dimensions)\n \n \n number_of_frames=0 \n trajectory_time=[]\n for chunk_i in md.iterload(trajectories_path, chunk = chunk, top=topology, atom_indices = atom_subset):\n trajectory_time.append(chunk_i.time)\n for atom in range(len(atom_subset)):\n diff = np.subtract(chunk_i.xyz[:, atom, :] * 10, reference_frame[atom])\n residual_sum_squares[atom] = residual_sum_squares[atom] + ((diff ** 2).sum(axis = 1).sum(axis=0))\n number_of_frames += chunk_i.xyz.shape[0]\n ## the result is a matrix with all fluctuations squared\n ## shape(number of frames * atom numbers, 3)\n ## from 0 to number of frames we have information of first atom\n ## then from number of frames to number of frames * 2 second atoms\n ## and so forth\n \n return residual_sum_squares, number_of_frames, trajectory_time","def get_remat(self) -> ndarray:\n return self.data.weight[:, None]*self.revar.mapping.mat","def basis(T, dimensions, t):\n # Undo change of basis from realizer, and then transform into window\n B = canonical_basis(dimensions, t)\n return B.dot(T)","def extract_utri( m, context = FloatContext ):\n rows, cols = shape_mat(m)\n return [ [context.zero]*i + row[i:]\n for i, row in enumerate(m) ]","def _apply_unitary(self, state, mat, wires):\n # translate to wire labels used by device\n device_wires = self.map_wires(wires)\n\n dim = 2 ** len(device_wires)\n mat_batch_size = self._get_batch_size(mat, (dim, dim), dim**2)\n state_batch_size = self._get_batch_size(state, (2,) * self.num_wires, 2**self.num_wires)\n\n shape = [2] * (len(device_wires) * 2)\n state_axes = device_wires\n # If the matrix is broadcasted, it is reshaped to have leading axis of size mat_batch_size\n if mat_batch_size:\n shape.insert(0, mat_batch_size)\n if state_batch_size:\n raise NotImplementedError(\n \"Applying a broadcasted unitary to an already broadcasted state via \"\n \"_apply_unitary is not supported. Broadcasting sizes are \"\n f\"({mat_batch_size}, {state_batch_size}).\"\n )\n # If the state is broadcasted, the affected state axes need to be shifted by 1.\n if state_batch_size:\n state_axes = [ax + 1 for ax in state_axes]\n mat = self._cast(self._reshape(mat, shape), dtype=self.C_DTYPE)\n axes = (np.arange(-len(device_wires), 0), state_axes)\n tdot = self._tensordot(mat, state, axes=axes)\n\n # tensordot causes the axes given in `wires` to end up in the first positions\n # of the resulting tensor. This corresponds to a (partial) transpose of\n # the correct output state\n # We'll need to invert this permutation to put the indices in the correct place\n unused_idxs = [idx for idx in range(self.num_wires) if idx not in device_wires]\n perm = list(device_wires) + unused_idxs\n # If the matrix is broadcasted, all but the first dimension are shifted by 1\n if mat_batch_size:\n perm = [idx + 1 for idx in perm]\n perm.insert(0, 0)\n if state_batch_size:\n # As the state broadcasting dimension always is the first in the state, it always\n # ends up in position `len(device_wires)` after the tensordot. The -1 causes it\n # being permuted to the leading dimension after transposition\n perm.insert(len(device_wires), -1)\n\n inv_perm = np.argsort(perm) # argsort gives inverse permutation\n return self._transpose(tdot, inv_perm)","def tmatrix(self, source, drain):\n if self.gf_r is None:\n self.gf()\n\n G_sd = self.device.connections[drain].dot(self.gf_r).dot(self.device.connections[source].conj().T)\n\n gamma_source = self.calculators[source].gamma()\n gamma_drain = self.calculators[drain].gamma()\n\n vals, vecs = linalg.eig(gamma_source)\n vald, vecd = linalg.eig(gamma_drain)\n\n return numpy.diag((-self.calculators[drain].v_r.real)**.5).\\\n dot(self.calculators[drain].states_ri).dot(G_sd).\\\n dot(self.calculators[source].states_li.conj().T).\\\n dot(numpy.diag(self.calculators[source].v_l.real**.5))","def get_mmt():\r\n # M^T\r\n MT = np.array([[-1, 0, 0, 0, 0, 0, 0, 0, 0],\r\n [1, -1, 0, 0, 0, 0, 0, 0, 0],\r\n [0, 1, -1, 0, 0, 0, 0, 0, 0],\r\n [0, 0, 1, -1, 0, 0, 0, 0, 0],\r\n [0, 0, 0, 1, -1, 0, 0, 0, 0],\r\n [0, 0, 0, 0, 1, -1, 0, 0, 0],\r\n [0, 0, 0, 0, 0, 1, -1, 0, 0],\r\n [0, 0, 0, 0, 0, 0, 1, -1, 0],\r\n [0, 0, 0, 0, 0, 0, 0, 1, -1],\r\n [0, 0, 0, 0, 0, 0, 0, 0, 1]])\r\n\r\n M = np.transpose(MT)\r\n return M, MT","def canonical_basis(dimensions, t):\n t = np.atleast_1d(t)\n B = np.asarray([readout(dimensions, r) for r in t])\n return B","def reac_beam2DU_global(coord, I, Emod , U):\r\n vec = coord[1, :] - coord[0, :]\r\n L = np.linalg.norm(vec)\r\n nx = vec[0]/L\r\n ny = vec[1]/L\r\n \r\n Q = np.array([\r\n [-ny, nx, 0, 0, 0, 0],\r\n [0, 0, 1.0, 0, 0, 0],\r\n [0, 0, 0, -ny, nx, 0],\r\n [0, 0, 0, 0, 0, 1.0]])\r\n\r\n kl = (I*Emod/(L*L*L)) * np.array([\r\n [12.0, 6, -12.0, 6*L],\r\n [6, 4*L*L, -6*L, 2*L*L],\r\n [-12.0, -6*L, 12.0, -6*L],\r\n [6*L, 2*L*L, -6*L, 4*L*L]])\r\n kG = np.dot(np.dot(Q.T, kl), Q)\r\n fl = np.dot(kG , U)\r\n return fl","def mtf_bitransformer_tiny():\n hparams = mtf_bitransformer_base()\n hparams.batch_size = 2\n hparams.mesh_shape = \"\"\n hparams.d_model = 128\n hparams.encoder_layers = [\"self_att\", \"drd\"] * 2\n hparams.decoder_layers = [\"self_att\", \"enc_att\", \"drd\"] * 2\n hparams.num_heads = 4\n hparams.d_ff = 512\n return hparams","def optimizeFluidArray(self):\n print(\"Run the function for optimization.\")\n self.fluidNodes = np.empty(self.voidSpace, dtype = np.int64)\n ySize = self.ny; xSize = self.nx\n print(\"Start to fill effective fluid nodes.\")\n tmpIndicesDomain = -np.ones(self.isDomain.shape, dtype = np.int64)\n tmpIndicesFN = 0\n for i in sp.arange(ySize):\n for j in sp.arange(xSize):\n if (self.isDomain[i, j] == 1):\n# if (self.effectiveDomain[i, j] == 255.):\n tmpIndices = i * xSize + j\n self.fluidNodes[tmpIndicesFN] = tmpIndices\n tmpIndicesDomain[i, j] = tmpIndicesFN\n tmpIndicesFN += 1\n self.neighboringNodes = np.zeros(self.fluidNodes.size * 8, dtype = np.int64)\n if self.interactionType == \"'EFS'\":\n if self.explicitScheme == 8:\n self.neighboringNodesISO8 = np.zeros(self.fluidNodes.size * 24, \\\n dtype = np.int64)\n elif self.explicitScheme == 10:\n self.neighboringNodesISO10 = np.zeros(self.fluidNodes.size * 36, \\\n dtype = np.int64)\n totalNodes = self.fluidNodes.size\n #use cuda to generate the array for neighboring nodes\n print(\"Start to fill neighboring nodes\")\n deviceFluidNodes = cuda.to_device(self.fluidNodes)\n devicetmpIndicesDomain = cuda.to_device(tmpIndicesDomain)\n# deviceIsDomain = cuda.to_device(self.isDomain)\n deviceNeighboringNodes = cuda.to_device(self.neighboringNodes)\n blockNumX = int(self.xDimension / self.threadNum) \n blockNumY = math.ceil(self.fluidNodes.size / self.xDimension)\n threadPerBlock1D = (self.threadNum, 1)\n grid = (blockNumX, blockNumY)\n\n fillNeighboringNodes[grid, threadPerBlock1D](totalNodes, self.nx, self.ny, \\\n self.xDimension, deviceFluidNodes, devicetmpIndicesDomain, \\\n deviceNeighboringNodes)\n self.neighboringNodes = deviceNeighboringNodes.copy_to_host()\n if self.interactionType == \"'EFS'\":\n if self.explicitScheme == 8:\n deviceNeighboringNodesISO8 = cuda.to_device(self.neighboringNodesISO8)\n fillNeighboringNodesISO8[grid, threadPerBlock1D](totalNodes, self.nx, self.ny, \\\n self.xDimension, deviceFluidNodes, devicetmpIndicesDomain, \\\n deviceNeighboringNodesISO8)\n self.neighboringNodesISO8 = deviceNeighboringNodesISO8.copy_to_host()\n elif self.explicitScheme == 10:\n deviceNeighboringNodesISO10 = cuda.to_device(self.neighboringNodesISO10)\n fillNeighboringNodesISO10[grid, threadPerBlock1D](totalNodes, self.nx, self.ny, \\\n self.xDimension, deviceFluidNodes, devicetmpIndicesDomain, \\\n deviceNeighboringNodesISO10)\n self.neighboringNodesISO10 = deviceNeighboringNodesISO10.copy_to_host()\n \n print(\"Redefine the fluid nodes.\")\n# cuda.current_context().trashing.clear()\n self.optFluidPDF = np.empty([self.typesFluids, self.fluidNodes.size, 9])\n self.optFluidRho = np.empty([self.typesFluids, self.fluidNodes.size])\n self.optMacroVelocity = np.zeros(self.fluidNodes.size)\n self.optMacroVelocityX = np.zeros(self.fluidNodes.size, dtype = np.float64)\n self.optMacroVelocityY = np.zeros(self.fluidNodes.size, dtype = np.float64)\n self.optForceX = np.zeros([self.typesFluids, self.fluidNodes.size], \\\n dtype = np.float64)\n self.optForceY = np.zeros([self.typesFluids, self.fluidNodes.size], \\\n dtype = np.float64)\n tmpDomain = np.array([i == 1 for i in self.isDomain.reshape(ySize * xSize)])\n for i in sp.arange(self.typesFluids):\n self.optFluidRho[i] = self.fluidsDensity.reshape(self.typesFluids, \\\n ySize * xSize)[i, tmpDomain]\n self.optFluidPDF[i] = self.fluidPDF.reshape(self.typesFluids, ySize * \\\n xSize, 9)[i, tmpDomain]","def __createSpecTempT(self):\n\t\tspecTempT = np.copy(self.specTemplates)\n\t\tspecTempT = np.transpose(specTempT)\n\t\tspecTempT = specTempT * self.covInv\n\t\t\t\t\n\t\treturn specTempT","def get_trans_net():\n return nn.Sequential(nn.Linear(2, 64), nn.LeakyReLU(), nn.Linear(64, 64), nn.LeakyReLU(), nn.Linear(64, 2))","def test_trotter_hamiltonian_scalar_mul(nqubits=3):\n local_ham = hamiltonians.TFIM(nqubits, h=1.0, trotter=True)\n target_ham = 2 * hamiltonians.TFIM(nqubits, h=1.0, numpy=True)\n local_dense = (2 * local_ham).dense\n np.testing.assert_allclose(local_dense.matrix, target_ham.matrix)\n\n local_ham = hamiltonians.TFIM(nqubits, h=1.0, trotter=True)\n local_dense = (local_ham * 2).dense\n np.testing.assert_allclose(local_dense.matrix, target_ham.matrix)","def getDustTemperature(grid=None, ppar=None):\n op = dustopac.radmc3dDustOpac()\n dinfo = op.readDustInfo()\n ngs = len(dinfo['gsize'])\n\n tdust = np.zeros([grid.nx, grid.ny, grid.nz, ngs], dtype=np.float64)\n tgas = getGasTemperature(grid=grid, ppar=ppar)\n for ig in range(ngs):\n tdust[:,:,:,ig] = tgas\n\n return tdust","def P2T(self):\n # Convert to RJ temperature\n #fac=planck.I2Ta(self.f*1e6,1).value\n fac = planck(self.f*1e6, 1)\n fac=fac/fac[0]\n self.spec=self.spec*np.tile(fac,(self.spec.shape[0],1))","def get_transmission(self,img, atmosphere, *, size, omega, radius, epsilon):\n #Get transmission map from the image\n division = np.float64(img) / np.float64(atmosphere)\n raw = (1 - omega * self.get_dark_channel(division, size=size)).astype(np.float32)\n return cv2.ximgproc.guidedFilter(img, raw, radius, epsilon)","def model(self, t):\n flux = np.zeros_like(t)\n dt = np.abs(self.timefrommidtransit(t))\n start, finish = self.traits['T23'] / 2.0, self.traits['T14'] / 2.0\n depth = self.traits['D']\n\n i = dt <= start\n flux[i] = depth\n i = (dt <= finish) * (dt > start)\n flux[i] = (finish - dt[i]) / (finish - start) * depth\n\n return flux","def transmission(ki,n,mi,mt):\n ki,n,mi,mt = map(np.asarray,(ki,n,mi,mt))\n kt = Fresnel._refract(ki,n,mi,mt)\n return (kt,)+Fresnel._transmission(ki,kt,n,mi,mt)","def test_trotter_hamiltonian_scalar_sub(nqubits=3):\n local_ham = hamiltonians.TFIM(nqubits, h=1.0, trotter=True)\n target_ham = 2 - hamiltonians.TFIM(nqubits, h=1.0, numpy=True)\n local_dense = (2 - local_ham).dense\n np.testing.assert_allclose(local_dense.matrix, target_ham.matrix)\n\n target_ham = hamiltonians.TFIM(nqubits, h=1.0, numpy=True) - 2\n local_ham = hamiltonians.TFIM(nqubits, h=1.0, trotter=True)\n local_dense = (local_ham - 2).dense\n np.testing.assert_allclose(local_dense.matrix, target_ham.matrix)","def ion2fluoTF(ion_img):\n # return ion_img.T # --> TF1 HepaJune dataset batches FASTER\n # return np.fliplr(ion_img) #--> TF2 HepaJune dataset batch\n return np.flipud(ion_img) # --> TF for HepaNov17","def GetModifiableTransform(self) -> \"itkTransformF22 *\":\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF2MF2TF22_GetModifiableTransform(self)","def get_matrix_rigidity_unitary(self):\r\n return self.flexural_rigidity/(self.length**3)*np.array([\r\n [12, 6*self.length, -12, 6*self.length],\r\n [6*self.length, 4*self.length**2, -6*self.length, 2*self.length**2],\r\n [-12, -6*self.length, 12, -6*self.length],\r\n [6*self.length, 2*self.length**2, -6*self.length, 4*self.length**2]\r\n ])","def solveFluNet(T,Ntime,a,b0,b1,g,k,w,y0,P,N,RHS=3):\n #I have added the variables P the transport matrix \n #and N the network size because they are needed\n #in the RHS.\n #I have added the variable RHS to be able to \n #choose which RHS method we want to use when running\n #solveFluNet\n \n #add input variables to RHS functions if needed\n def RHSnet(y,t,a,b0,b1,g,k,w):\n \"\"\"RHS used by odeint to solve Flu model\"\"\"\n S = y[:N]\n E = y[N:2*N]\n C = y[2*N:3*N]\n b = b0 + b1*(1+np.cos(2*np.pi*t))\n dy = np.zeros(3*N)\n dy[:N]= k*(1-S)-b*C*S+w*np.dot(P,S)-w*S\n dy[N:2*N]= b*C*S-(k+a)*E+w*np.dot(P,E)-w*E\n dy[2*N:3*N]= a*E-(g+k)*C+w*np.dot(P,C)-w*C\n return dy\n \n def RHSnetF(y,t,a,b0,b1,g,k,w):\n \"\"\"RHS used by odeint to solve Flu model\"\n Calculations carried out by fn.rhs\n \"\"\"\n dy = fn.rhs(P,y,t,a,b0,b1,g,k,w)\n return dy\n \n def RHSnetFomp(y,t,a,b0,b1,g,k,w):\n \"\"\"RHS used by odeint to solve Flu model\n Calculations carried out by fn.rhs_omp\n \"\"\"\n dy = fn.rhs_omp(P,y,t,a,b0,b1,g,k,w,2)\n return dy\n\n #Add code here and to RHS functions above to simulate network flu model\n t = np.linspace(0,T,Ntime)\n if (RHS==1):\n sol = odeint(RHSnet,y0,t,args=(a,b0,b1,g,k,w))\n if (RHS==2):\n sol = odeint(RHSnetF,y0,t,args=(a,b0,b1,g,k,w))\n if (RHS==3):\n sol = odeint(RHSnetFomp,y0,t,args=(a,b0,b1,g,k,w))\n S = sol[:,:N]\n E = sol[:,N:2*N]\n C = sol[:,2*N:3*N]\n return t,S,E,C","def flux():\n delta = 0.01 # film thickness, [dm]\n c = pre * 10 ** 2 / (R * tem) # total concentration calculated by ideal gas equation, in [mol/L]\n D12 = 0.001626528 / pre # HCl diffusion in Air, [dm2/s] @296K\n D13 = 3e-7 # HCl gas diffusion in water, [dm2/s] @296K\n D23 = 1.5e-7 # CH4 gas diffusion in water, [dm2/s] @296K\n N1 = ((x1_bar * x2d * D23) / (x2_bar * delta * D13) - x1_bar / delta) / \\\n (x2_bar / (D12 * c) + x3_bar / (D13 * c) + D23 * x1_bar / (D12 * D13 * c))\n # print 'Flux of HCl into water', abs(N1), [mol/(dm2*sec)]\n return N1","def transform_rdms(self,unitary, twordm = True):\n dim = self.header['norbs']\n t4index = None\n if twordm:\n t4index = [np.zeros((dim,dim, dim, dim)) for i in range(3)]\n\n for i in range(3):\n temp = np.zeros((dim,dim, dim, dim))\n temp2 = np.zeros((dim,dim, dim, dim))\n temp3 = np.zeros((dim,dim, dim, dim))\n for p in range(0,dim):\n for mu in range(0,dim):\n temp[p,:,:,:] += unitary[mu,p]*self.trdm[i][mu,:,:,:]\n for q in range(0,dim):\n for nu in range(0,dim):\n temp2[p,q,:,:] += unitary[nu,q]*temp[p,nu,:,:]\n for r in range(0,dim):\n for lam in range(0,dim):\n temp3[p,q,r,:] += unitary[lam,r]*temp2[p,q,lam,:]\n for s in range(0,dim):\n for sig in range(0,dim):\n t4index[i][p,q,r,s] += unitary[sig,s]*temp3[p,q,r,sig]\n \n t2index = [np.dot(self.ordm[0], unitary), np.dot(self.ordm[1], unitary) ]\n t2index = [ np.dot(unitary.T , t2index[0]) , np.dot(unitary.T , t2index[1]) ]\n\n return t2index , t4index","def GetModifiableTransform(self) -> \"itkTransformD22 *\":\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF2MF2TD22_GetModifiableTransform(self)","def transfer_matrix(reliability, size):\n\n return ((1.0 - reliability) * np.eye(size, k=0, dtype=float) +\n reliability * np.eye(size, k=1, dtype=float))","def mtf_unitransformer_all_layers_tiny():\n hparams = mtf_unitransformer_tiny()\n hparams.moe_num_experts = 4\n hparams.moe_expert_x = 4\n hparams.moe_expert_y = 4\n hparams.moe_hidden_size = 512\n hparams.layers = [\"self_att\", \"local_self_att\", \"moe_1d\", \"moe_2d\", \"drd\"]\n return hparams","def op_fresnel_transmission(m, theta):\n tau_p = pypolar.fresnel.T_par(m, theta)\n tau_s = pypolar.fresnel.T_per(m, theta)\n a = tau_s + tau_p\n b = tau_s - tau_p\n c = 2 * np.sqrt(tau_s * tau_p)\n mat = np.array([[a, b, 0, 0],\n [b, a, 0, 0],\n [0, 0, c, 0],\n [0, 0, 0, c]])\n return 0.5 * mat","def forward(self, input):\n assert len(input.size()) == 4\n self.input_height = input.size()[-2]\n self.input_width = input.size()[-1]\n self.get_matrix()\n return DWTFunction_2D_tiny.apply(input, self.matrix_low_0, self.matrix_low_1, self.matrix_high_0, self.matrix_high_1)","def TNFR1_to_SecondaryComplex_Alternate():\n \n Parameter('TNFa_0' , 000) # 6000 corresponds to 100ng/ml TNFa\n Parameter('TNFR1_0' , 4800) # 4800 receptors per cell\n Parameter('TRADD_0' , 9000) # molecules per cell (arbitrarily assigned) 9000\n Parameter('RIP1_0' , 12044) # molecules per cell (arbitrarily assigned) 12044\n Parameter('CompI_0' , 0) # complexes per cell\n Parameter('NFkB_0' , 0) # molecules per cell\n alias_model_components()\n \n Initial(TNFa(blig=None), TNFa_0) # TNFa Ligand\n Initial(TNFR1(blig=None, bDD=None, state='norm'), TNFR1_0) # TNFR1\n Initial(TRADD(bDD1=None, bDD2=None, state='inactive'), TRADD_0) # TRADD\n Initial(CompI(bDD=None, state='unmod'), CompI_0) # Complex I\n Initial(RIP1(bDD=None, bRHIM = None, bPARP = None, state = 'unmod'), RIP1_0) # RIP1\n Initial(NFkB(bf=None), NFkB_0)\n \n # =========================================\n # TNFR1 ligation, formation of Complex I and release of RIP1 and TRADD rules\n # -----------------------------------------\n # TNFa+ TNFR1 <-> TNFa:TNFR1\n # TNFa:TNFR1 + TRADD <-> TNFa:TNFR1:TRADD >> CompI\n # CompI + RIP1 <-> CompI:RIP1 >> [active]CompI:RIP1-Ub\n # CompI + RIP1-Ub <-> CompI:RIP1-Ub\n \n # [active]CompI:RIP1-Ub >> NFkB # This reaction will consume the receptor.\n # [active]CompI:RIP1-Ub >> [active]CompI:RIP1\n # [active]CompI:RIP1 >> [active]CompI # A20 mediated degradation of RIP1\n # [active]CompI:RIP1 >> [active]CompI + RIP1\n # [active]CompI >> [active]TRADD + [norm]TNFR1 #receptor recycle typically distroys the ligand.\n \n # RIP1 >> RIP1-Ub #These reactions were added because Doug Green reported that FADD and RIP1 bind\n # RIP1-Ub >> RIP1 #independently of receptor, and FADD:RIP1 formation leads to Caspase 8 activation.\n #These reaction decrease the amount of RIP1 by spontaneously ubiquitinating it.\n \n # ------------------------------------------\n \n # -------------Complex I assembly----------------\n bind(TNFa(blig=None), 'blig', TNFR1(blig=None, bDD=None, state='norm'), 'blig', [2e-7, 1e-4])\n bind(TNFR1(blig = ANY, bDD = None, state = 'norm'), 'bDD', TRADD(bDD1=None, bDD2=None, state='inactive'), 'bDD1', [1e-6, 0.2])\n preCompI = TNFa(blig=ANY)%TNFR1(blig=ANY, bDD=ANY, state = 'norm')%TRADD(bDD1 = ANY, bDD2=None, state = 'inactive')\n Rule('CompI_formation', preCompI >> CompI(bDD=None, state = 'unmod'), Parameter('k2', 1))\n \n # --------------Complex I - RIP1 Modification-----------------\n # Complex I recruits RIP1\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='unmod'), 'bDD',[1e-6, 1e-3])\n #bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[1e-6, 1e-3])\n \n # Complex I undergos modifications (e.g. Ubiquitination) and elicits NFkB signaling\n Rule('CompI_Ub', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'unmod')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), Parameter('k3', 1))\n #Rule('CompI_Ub2', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), Parameter('k4', 1))\n Rule('NFkB_signaling', CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub') + NFkB(bf=None), Parameter('k5', 1))\n \n # De-ubiquitination and degradation or release of RIP1 from complex I\n Rule('CompI_deUb', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub')>>CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None,state='deub'), Parameter('k6',1e-3))\n \n Rule('RIP1_deg', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub') >> CompI(bDD=None, state='mod'), Parameter('k7',1))\n \n bind(CompI(bDD=None, state='mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state = 'deub'), 'bDD', [1e-10,1])\n \n # Receptor recycle\n Rule('TNFR1_recycle', CompI(bDD=None, state='mod') >> TRADD(bDD1=None, bDD2 = None, state='active') + TNFR1(blig = None, bDD = None, state = 'norm'), Parameter('k8',1e-3))\n \n # --------------RIP1 Ubiquitination---------------------------\n Rule('RIP1_Ub', RIP1(bDD=None, bRHIM = None, state='unmod')>> RIP1(bDD=None, bRHIM = None, state='ub'), Parameter('k9', 1e-7))","def test_transpile_differentiable(self):\n dev = qml.device(\"default.qubit\", wires=3)\n\n def circuit(parameters):\n qml.RX(parameters[0], wires=0)\n qml.RY(parameters[1], wires=1)\n qml.CNOT(wires=[0, 2])\n qml.PhaseShift(parameters[2], wires=0)\n return qml.expval(qml.PauliZ(0))\n\n transpiled_circ = transpile(coupling_map=[(0, 1), (1, 2)])(circuit)\n transpiled_qnode = qml.QNode(transpiled_circ, dev, interface=\"autograd\")\n params = np.array([0.5, 0.1, 0.2], requires_grad=True)\n qml.gradients.param_shift(transpiled_qnode)(params)","def material_matrix(self):\n out = Tmatrix()\n out.translate(Vector([.5, .5, .5]))\n out.scale(Vector([self.radius, self.radius, self.radius]) *\n (.5 / (self.radius + self.thickness)))\n return out","def system_1dof(w, t):\n x1, y1 = w\n # Create f = (x1',y1')\n f = [y1,\n (-k*x1 - k3*x1**3)/M]\n return f","def t2u( self , t ):\n \n # Input of closed-loop global sys is ref of the controller\n u = self.controller.t2r(t)\n \n return u","def test_trotter_hamiltonian_scalar_mul(nqubits=3):\n local_ham = hamiltonians.TFIM(nqubits, h=1.0, dense=False)\n target_ham = 2 * hamiltonians.TFIM(nqubits, h=1.0)\n local_dense = (2 * local_ham).dense\n K.assert_allclose(local_dense.matrix, target_ham.matrix)\n\n local_ham = hamiltonians.TFIM(nqubits, h=1.0, dense=False)\n local_dense = (local_ham * 2).dense\n K.assert_allclose(local_dense.matrix, target_ham.matrix)","def stoichiometry(self, fluid):\n air = self.air_alias.val\n fuel = self.fuel_alias.val\n flue_gas = self.fuel_alias.val + '_fg'\n\n ###################################################################\n # calculate fuel and air mass flow\n m_fuel = 0\n for i in self.inl:\n m_fuel += i.m.val_SI * i.fluid.val[fuel]\n\n m_air = 0\n for i in self.inl:\n m_air += i.m.val_SI * i.fluid.val[air]\n\n m_air_min = self.air_min * m_fuel\n\n ###################################################################\n # calculate lambda if not specified\n if not self.lamb.is_set:\n self.lamb.val = m_air / (self.air_min * m_fuel)\n\n ###################################################################\n # calculate excess fuel if lambda is smaller than 1\n m_fuel_exc = 0\n if self.lamb.val < 1:\n m_fuel_exc = m_fuel - m_air / (self.lamb.val * self.air_min)\n\n ###################################################################\n # equation for air\n if fluid == air:\n if self.lamb.val >= 1:\n dm = -m_air_min\n else:\n dm = -m_air\n\n ###################################################################\n # equation for fuel\n elif fluid == fuel:\n dm = -(m_fuel - m_fuel_exc)\n\n ###################################################################\n # equation for flue gas\n elif fluid == flue_gas:\n dm = m_air_min + m_fuel\n\n ###################################################################\n # equation for other components\n else:\n dm = 0\n\n res = dm\n for i in self.inl:\n res += i.fluid.val[fluid] * i.m.val_SI\n for o in self.outl:\n res -= o.fluid.val[fluid] * o.m.val_SI\n return res","def mixing_matrix_2nu(sth):\n cth = sqrt(1.0-sth*sth)\n\n U00 = cth\n U01 = sth\n U10 = -sth\n U11 = cth\n\n return [[U00,U01],[U10,U11]]","def getScalarFlux(self):\n totScalarFlux = []\n for cell in self.cells:\n totScalarFlux.append(cell.getTotScalarFlux())\n totScalarFlux = np.array(totScalarFlux)\n #return totScalarFlux / np.sum(totScalarFlux) # norm flux to 1.\n return totScalarFlux","def mounting_matrix(self):\n # fmt: off\n count = 0\n for x in range(self.ntheta):\n self.M[count][count] = 1\n self.f[count][0] = self.p_in\n count = count + self.nz - 1\n self.M[count][count] = 1\n self.f[count][0] = self.p_out\n count = count + 1\n count = 0\n for x in range(self.nz - 2):\n self.M[self.ntotal - self.nz + 1 + count][1 + count] = 1\n self.M[self.ntotal - self.nz + 1 + count][self.ntotal - self.nz + 1 + count] = -1\n count = count + 1\n count = 1\n j = 0\n for i in range(1, self.nz - 1):\n a = (1 / self.dtheta ** 2) * (self.c1[i][self.ntheta - 1])\n self.M[count][self.ntotal - 2 * self.nz + count] = a\n b = (1 / self.dz ** 2) * (self.c2[i - 1, j])\n self.M[count][count - 1] = b\n c = -((1 / self.dtheta ** 2) * ((self.c1[i][j]) + self.c1[i][self.ntheta - 1])\n + (1 / self.dz ** 2) * (self.c2[i][j] + self.c2[i - 1][j]))\n self.M[count, count] = c\n d = (1 / self.dz ** 2) * (self.c2[i][j])\n self.M[count][count + 1] = d\n e = (1 / self.dtheta ** 2) * (self.c1[i][j])\n self.M[count][count + self.nz] = e\n count = count + 1\n count = self.nz + 1\n for j in range(1, self.ntheta - 1):\n for i in range(1, self.nz - 1):\n a = (1 / self.dtheta ** 2) * (self.c1[i, j - 1])\n self.M[count][count - self.nz] = a\n b = (1 / self.dz ** 2) * (self.c2[i - 1][j])\n self.M[count][count - 1] = b\n c = -((1 / self.dtheta ** 2) * ((self.c1[i][j]) + self.c1[i][j - 1])\n + (1 / self.dz ** 2) * (self.c2[i][j] + self.c2[i - 1][j]))\n self.M[count, count] = c\n d = (1 / self.dz ** 2) * (self.c2[i][j])\n self.M[count][count + 1] = d\n e = (1 / self.dtheta ** 2) * (self.c1[i][j])\n self.M[count][count + self.nz] = e\n count = count + 1\n count = count + 2\n count = 1\n for j in range(self.ntheta - 1):\n for i in range(1, self.nz - 1):\n if j == 0:\n self.f[count][0] = (self.c0w[i][j] - self.c0w[i][self.ntheta - 1]) / self.dtheta\n else:\n self.f[count][0] = (self.c0w[i, j] - self.c0w[i, j - 1]) / self.dtheta\n count = count + 1\n count = count + 2\n # fmt: on","def magnetic_tension(self, method='spectral'):\n import numpy as np\n gradB, B = self.magnetic_gradient_tensor(method=method, return_B=True)\n F = np.zeros_like(B)\n for i in range(3):\n for j in range(3):\n F[j] += B[i] * gradB[i,j]\n return F","def ofdm_demodulate(sys_parameters, waveform_info, tx_wave):\n # Get dimensionality information derived from the system parameters\n waveform_info.set_info(sys_parameters)\n # Cache the main dims\n nsc = waveform_info.nsubcarriers\n nfft = waveform_info.nfft\n cp_lengths = waveform_info.cyclic_prefix_lengths\n symbols_per_slot = waveform_info.symbols_per_slot\n # Use numpy.array to express the rxWaveform\n rxwave = np.array(tx_wave)\n rxant = np.shape(rxwave)[1]\n rx_grid = np.zeros((nsc, symbols_per_slot, rxant), dtype=complex)\n # Calculate position of the first active subcarrier in the FFT output,\n # according to the FFT size and the number of active subcarriers\n first_activesc = int((nfft - nsc) / 2)\n # Demodulate all symbols within the input data\n cpres = cp_lengths[0] - cp_lengths[1]\n # The same as the MATLAB operation : rxwave[0:cpres, :] = []\n rxwave = np.delete(rxwave, range(cpres), 0)\n rxwave = np.reshape(rxwave, (-1, symbols_per_slot, rxant), order=\"F\")\n # The same as the MATLAB operation : rxwave[0:cp_lengths[1], :, :] = []\n rxwave = np.delete(rxwave, range(cp_lengths[1]), 0)\n for symbol in range(symbols_per_slot):\n for rr in range(rxant):\n in_list = rxwave[:, symbol, rr]\n # rxwave is the numpy.array, just div the value\n fft_output = spy.fftpack.fftshift(spy.fft.fft(in_list)) / math.sqrt(nfft)\n rx_grid[:, symbol, rr] = fft_output[first_activesc : (first_activesc + nsc)]\n return rx_grid","def F_trans(self):\n rho_H1 = self.edp_par['rho_H1'].value\n Z_H1 = self.edp_par['Z_H1'].value\n sigma_H1 = self.edp_par['sigma_H1'].value\n rho_M = self.edp_par['rho_M'].value\n sigma_M = self.edp_par['sigma_M'].value\n psi = self.edp_par['psi'].value \n common_scale = self.edp_par['common_scale'].value\n \n # Calculate the intermediate variables\n alpha = self.qz*cos(psi) - self.qx*sin(psi)\n Z_CH2 = Z_H1 - sigma_H1\n Z_W = Z_H1 + sigma_H1\n DeltaZ_H = Z_W - Z_CH2\n \n # Calculate the Gaussian part \n FG = -rho_M*sigma_M * exp(-0.5*(alpha*sigma_M)**2)\n FG += 2*rho_H1*sigma_H1 * cos(alpha*Z_H1) * exp(-0.5*(alpha*sigma_H1)**2)\n FG *= np.sqrt(2*pi)\n \n # Calculate the strip part\n FS = -2 * sin(alpha*Z_CH2) / alpha\n \n # Calculate the bridging part\n FB = 1 / (alpha + pi/DeltaZ_H)\n FB += 1 / (alpha - pi/DeltaZ_H)\n FB *= sin(alpha*Z_W) + sin(alpha*Z_CH2)\n FB *= 0.5\n FB -= (sin(alpha*Z_W)-sin(alpha*Z_CH2)) / alpha\n \n return common_scale * (FG + FS + FB)","def getTrMatricesController(self):\n\t\treturn self.trMatricesController","def ttd_u_func(self):\n T_i1 = T_mix_ph(self.inl[0].to_flow(), T0=self.inl[0].T.val_SI)\n T_o2 = T_mix_ph(self.outl[1].to_flow(), T0=self.outl[1].T.val_SI)\n return self.ttd_u.val - T_i1 + T_o2","def T(self):\n self = +self\n ret = Matr()\n for hcolp in range(len(self.header)):\n ret.append(Matr())\n for row in range(len(self)):\n ret[hcolp].append(self[row,hcolp])\n return ret","def setup_t_matrix(dq_W_E_vec, dq_B_H_vec):\n n_quaternions = len(dq_W_E_vec)\n t_matrix = np.zeros([6 * n_quaternions, 8])\n for i in range(n_quaternions):\n t_matrix[i * 6:i * 6 + 6, :] = setup_s_matrix(dq_W_E_vec[i], dq_B_H_vec[i])\n\n rank_t_matrix = np.linalg.matrix_rank(t_matrix, tol=5e-2)\n U, s, V = np.linalg.svd(t_matrix)\n # print(\"t_matrix: \\n{}\".format(t_matrix))\n # print(\"Rank(t_matrix): {}\".format(rank_t_matrix))\n # assert rank_t_matrix == 6, (\"T should have rank 6 otherwise we can not find \"\n # \"a rigid transform.\", rank_t_matrix, s)\n return t_matrix.copy()","def flux_hack(self):\r\n return self.planes[1].galaxies[0].light_profiles[0].flux","def Tt(self, M):\r\n # Section 1: if a 1D array, convert to a 2D array = matrix\r\n if not isinstance(M[0], list):\r\n M = [M]\r\n \r\n # Section 2: Get dimensions\r\n rows = len(M)\r\n cols = len(M[0])\r\n \r\n # Section 3: MT is zeros matrix with transposed dimensions\r\n MT = self.zeros_matrix(cols, rows)\r\n \r\n # Section 4: Copy values from M to it's transpose MT\r\n for i in range(rows):\r\n for j in range(cols):\r\n MT[j][i] = M[i][j]\r\n \r\n return MT","def _unsqueeze_ft(tensor):\n return tensor.unsqueeze(0).unsqueeze(-1)","def test_trotter_hamiltonian_scalar_sub(nqubits=3):\n local_ham = hamiltonians.TFIM(nqubits, h=1.0, dense=False)\n target_ham = 2 - hamiltonians.TFIM(nqubits, h=1.0)\n local_dense = (2 - local_ham).dense\n K.assert_allclose(local_dense.matrix, target_ham.matrix)\n\n target_ham = hamiltonians.TFIM(nqubits, h=1.0) - 2\n local_ham = hamiltonians.TFIM(nqubits, h=1.0, dense=False)\n local_dense = (local_ham - 2).dense\n K.assert_allclose(local_dense.matrix, target_ham.matrix)","def DFT2(image):\n full_dft2 = DFT(DFT(image.transpose()).transpose())\n return full_dft2.astype(np.complex128)","def restom(fsnt, flnt):\n var = fsnt - flnt\n var.long_name = \"TOM(top of model) Radiative flux\"\n return var","def _mat3(self):\n if self.frame.orientation == HillFrame.DEFAULT_ORIENTATION:\n return np.identity(3)\n else:\n return self.QSW2TNW","def NMF(X,r):\n nmf_mdl = nmf.NMF(X,num_bases=r)\n nmf_mdl.initialization()\n nmf_mdl.factorize()\n return nmf_mdl.W,nmf_mdl.H,np.dot(nmf_mdl.W,nmf_mdl.H)","def GetTransform(self, *args) -> \"itkTransformD22 *\":\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF2MF2TD22_GetTransform(self, *args)","def computeTransitionMatrix(self, mu = False):\n\n available_strategies = self.getAvailableStrategies()\n t_matrix = np.matrix([[0. for strategy in available_strategies] for strategy in available_strategies])\n\n for i, resident in enumerate(available_strategies):\n for j, invader in enumerate(available_strategies):\n if (i != j):\n fixation_proba = self.rho(resident, invader)\n if(mu):\n fixation_proba *= self.getExplorationRate()\n t_matrix[i, j] = 1./(len(available_strategies) - 1) * fixation_proba\n\n # calculate diagonal elements\n for i in range(len(available_strategies)):\n t_matrix[i, i] = 1 - t_matrix[i].sum(axis = 1)\n\n return t_matrix","def __call__(self, t, u):\n \n # Rename to skip the self.\n f_rate = self.f; w_hat = self.w_hat;\n Ux = self.Ux; nx = self.nx;\n\n _u = u.reshape((nx,nx)) # To Matrix\n\n # FFT of firing rate at u\n f_u = f_rate(_u)\n f_hat = fft2(f_u) # 2D fft of matrix\n\n p_prod = np.real( ifft2(f_hat*w_hat) ) # Pointwise product of matrices\n shift = ((2*Ux/nx)**2)*ifftshift(p_prod) # Shift result\n F = - _u + shift\n return F.flatten()","def mat_vec_product(self, psi, t):\n\tx = zeros(self.vib_basis_size * len(self.my_tasks), dtype = complex)\n\n\t#Matrix vector product.\n\tfor i, j in enumerate(self.my_tasks):\n\t slice_x = slice(i * self.vib_basis_size, (i + 1) * self.vib_basis_size)\n\t slice_psi = slice(j * self.vib_basis_size, (j + 1) * self.vib_basis_size)\n\t \n\t x[slice_x] = dot(self.h_0[:,:,i], psi[slice_psi])\n\t\n\ty = dot(self.h_1, psi)\n\n\t#Weigh with field strength, and add components.\n\tpsi_final = x + self.time_function(t) * y\n\t\n\treturn psi_final","def matrix(self):\n # group the observables based on what wires they act on\n U_list = []\n for _, g in itertools.groupby(self.obs, lambda x: x.wires):\n # extract the matrices of each diagonalizing gate\n mats = [i.matrix for i in g]\n\n if len(mats) > 1:\n # multiply all unitaries together before appending\n mats = [multi_dot(mats)]\n\n # append diagonalizing unitary for specific wire to U_list\n U_list.append(mats[0])\n\n # Return the Hermitian matrix representing the observable\n # over the defined wires.\n return functools.reduce(np.kron, U_list)"],"string":"[\n \"def fluid_func(self):\\n residual = []\\n for fluid, x in self.inl[0].fluid.val.items():\\n res = x * self.inl[0].m.val_SI\\n for o in self.outl:\\n res -= o.fluid.val[fluid] * o.m.val_SI\\n residual += [res]\\n return residual\",\n \"def fluid_func(self):\\n residual = []\\n for i in range(self.num_i):\\n for fluid, x in self.inl[0].fluid.val.items():\\n residual += [x - self.outl[0].fluid.val[fluid]]\\n return residual\",\n \"def __tensor_flatten__(self):\\n return self._local_tensor, self._spec\",\n \"def getTransportMatrix(self):\\n\\t\\treturn self.trMtrx\",\n \"def heat_flux_out(T_inf, T_old, hc_air, emmi):\\n\\n #nz = T_old.shape[0]\\n ny = T_old.shape[0]\\n nx = T_old.shape[1]\\n\\n Q_out = np.zeros((ny, nx))\\n h_eff = np.zeros((ny, nx))\\n T_eff = np.zeros((ny, nx))\\n for i in range(nx):\\n for j in range(ny):\\n T_eff[j, i] = ((T_old[j, i]**3) + (T_inf * T_old[j, i]**2)\\n + (T_old[j, i] * T_inf**2) + T_inf**3)\\n\\n h_eff[j, i] = hc_air + (emmi*STEF_BOL_C*T_eff[j, i])\\n\\n Q_out[j, i] = h_eff[j, i] * (T_old[j, i] - T_inf)\\n\\n return Q_out\",\n \"def T(self) -> BaseMatrix:\",\n \"def T(self) -> BaseMatrix:\",\n \"def calc_ti(self):\\n m = 0\\n for i in self.inl:\\n m += i.m.val_SI * i.fluid.val[self.fuel_alias.val]\\n\\n for o in self.outl:\\n m -= o.m.val_SI * o.fluid.val[self.fuel_alias.val]\\n\\n return m * self.lhv\",\n \"def fluid_deriv(self):\\n deriv = np.zeros((self.fluid_constraints['num_eq'],\\n 2 * self.num_i + self.num_vars,\\n self.num_nw_vars))\\n for i in range(self.num_i):\\n for j in range(self.num_nw_fluids):\\n deriv[i * self.num_nw_fluids + j, i, j + 3] = 1\\n deriv[i * self.num_nw_fluids + j, self.num_i + i, j + 3] = -1\\n return deriv\",\n \"def T(self):\\n # TODO - your code here\\n matrix_transpose = [];\\n \\n for j in range(self.w):\\n matrix_transpose.append(self.get_column(j));\\n \\n return Matrix(matrix_transpose);\",\n \"def u_t(self):\\n\\t\\tdim = self.dim \\n\\t\\ttim_all = self.tim_all\\n\\t\\t#ctrl = self.ctrl\\n\\t\\tH0 = self.H0\\n\\t\\tHctrl = self.Hctrl\\n\\n\\t\\tu_all = np.zeros((tim_all+1,dim,dim),dtype = complex)\\n\\t\\tu_all[0,:,:] = np.eye(dim)\\n\\n\\t\\tfor tim in xrange(tim_all):\\n\\t\\t\\tH = H0 + Hctrl[tim]#np.matrix( ctrl[i,tim] * np.array(Hctrl[i]))\\n\\t\\t\\tu_all[tim+1,:,:] = np.dot(self.u_dt(H,tim), u_all[tim,:,:])\\n\\n\\n\\t\\treturn u_all\",\n \"def getHeatFlux(self, T):\\n\\t\\tQ = self.heat_transfer_coefficient * (self.T_wall - T)\\n\\t\\treturn Q\",\n \"def T(self):\\n return F.Transpose.apply(self)\",\n \"def transferMatrix(self, i1=0, i2=-1, plane=\\\"x\\\"):\\n B2 = self.normMat(i2, plane=plane)\\n B1 = self.normMat(i1, plane=plane)\\n psi = 2 * np.pi * (self[\\\"mu\\\" + plane][i2] - self[\\\"mu\\\" + plane][i1])\\n R = np.array([[np.cos(psi), np.sin(psi)], [-np.sin(psi), np.cos(psi)]])\\n return np.dot(np.dot(B2, R), np.linang.inv(B1))\",\n \"def Flux(self, flux, r_lim, z_lim):\\n if flux == 'mass':\\n set_integrand = lambda x: x\\n\\n elif flux == 'momentum':\\n set_integrand = lambda x: x**2\\n\\n elif flux == 'buoyancy':\\n b = self.read_vars(['b'])['b']\\n set_integrand = lambda x: x*b\\n\\n npx = self.params['npx']\\n Lx = self.params['Lx']\\n Ly = self.params['Ly']\\n Lz = self.params['Lz']\\n nz = self.params['nz']\\n\\n dx = Lx/npx\\n t = self.read_vars(['t'])['t']\\n n_time = t.shape[0]\\n\\n r_max = r_lim # as in forced_plume_nudging.py\\n z_max = z_lim\\n new_nz = int(nz*z_lim)\\n\\n flux = np.zeros(n_time)\\n\\n fields = self.read_vars(['w', 'x', 'y', 'z'])\\n w = velocity_interpolation(fields['w'], axis=1)\\n\\n XX, YY = np.meshgrid(fields['x']/Lx - 0.5,\\n fields['y']/Ly - 0.5)\\n\\n r = np.sqrt(XX**2 + YY**2)\\n mask_1 = ma.masked_outside(r, 0, r_max)\\n #mask_2 = ma.masked_outside(ZZ, 0, z_max)\\n\\n # defining integrand\\n integrand = set_integrand(w)\\n\\n for t in range(n_time):\\n aux = np.zeros(new_nz)\\n for z_i in range(new_nz):\\n field_new = ma.masked_array(integrand[t, z_i], mask_1.mask)\\n aux[z_i] = field_new.sum()\\n\\n flux[t] = aux.sum()\\n\\n return flux\",\n \"def full_matrix(self):\\n # print(self.b,np.shape(self.b))\\n # print(self.b_u[:, np.newaxis])\\n # print(self.b_i[np.newaxis:, ],\\\"TTTT\\\")\\n # print(self.P.dot(self.Q.T))\\n if (self.type=='bias'):\\n return self.b + self.b_u[:, np.newaxis] + self.b_i[np.newaxis:, ] + self.P.dot(self.Q.T)\\n elif (self.type=='nonbias'):\\n return self.P.dot(self.Q.T)\",\n \"def mtf_unitransformer_base():\\n hparams = mtf_transformer2_base()\\n hparams.add_hparam(\\\"autoregressive\\\", True)\\n # HYPERPARAMETERS FOR THE SINGLE LAYER STACK\\n hparams.add_hparam(\\\"layers\\\", [\\\"self_att\\\", \\\"drd\\\"] * 6)\\n # number of heads in multihead attention\\n hparams.add_hparam(\\\"num_heads\\\", 8)\\n # default of 0 for standard transformer behavior\\n # 1 means a single set of keys and values that are read by all query heads\\n hparams.add_hparam(\\\"num_memory_heads\\\", 0)\\n # share attention keys and values\\n hparams.add_hparam(\\\"shared_kv\\\", False)\\n # if nonzero then use local attention\\n hparams.add_hparam(\\\"local_attention_radius\\\", 128)\\n return hparams\",\n \"def mtr_tr_dense_local(sz):\\n hparams = mtr_tr_dense(sz)\\n hparams.decoder_layers = [\\\"local_self_att\\\", \\\"enc_att\\\", \\\"drd\\\"] * 6\\n hparams.local_attention_radius = 32\\n return hparams\",\n \"def get_mfp(self, T):\\n\\n self.air.T = T\\n self.air.set_TempPres_dependents()\\n\\n self.mfp = (\\n (np.sqrt(2.) * np.pi * self.air.d ** 2. * self.air.n) ** -1.\\n )\\n\\n return self.mfp\",\n \"def build_transfer_mx(self, t_params=None, apply_abs=True):\\n if t_params is None: t_params = self.t_params\\n tmx = _np.sum([t_params[ind] * self.t_basis[ind] for ind in range(self.dim)], axis=0) + _np.eye(self.n)\\n return _np.abs(tmx) if apply_abs else tmx\",\n \"def FitFundamentalMatrix(mss):\\n\\n\\tbatch_size = mss.shape[0]\\n\\tnum_correspondences = mss.shape[1]\\t\\n\\n\\tmss_src, T_src = utils.normalise2dpts(mss[:, :, :2])\\n\\tmss_target, T_target = utils.normalise2dpts(mss[:, :, 2:])\\n\\n\\tones = torch.tensor([1]).double().cuda().view(1, 1, 1).repeat(batch_size, num_correspondences, 1)\\n\\tmss_src = torch.cat([mss_src, ones], dim = 2)\\n\\tmss_target = torch.cat([mss_target, ones], dim = 2)\\n\\n\\trow = torch.cat([\\n\\t\\tmss_src * mss_target[:, :, 0].view(batch_size, num_correspondences, 1), \\n\\t\\tmss_src * mss_target[:, :, 1].view(batch_size, num_correspondences, -1),\\n\\t\\tmss_src \\n\\t], dim = 2)\\n\\n\\n\\touter_product = row.unsqueeze(3) * row.unsqueeze(2)\\n\\tmat = outer_product.sum(dim = 1)\\n\\n\\n\\tU = []\\n\\tS = []\\n\\tVT = []\\n\\n\\tfor i in range(batch_size):\\n\\n\\t\\t_, V = torch.symeig(mat[i])\\n\\t\\tu, s, v = torch.svd(V[:, 0].view(3, 3))\\n\\t\\tvt = v.permute(1, 0)\\n\\t\\ts[2] = 0\\n\\n\\t\\tU.append(u.unsqueeze(0))\\n\\t\\tS.append(torch.diag(s).unsqueeze(0))\\n\\t\\tVT.append(vt.unsqueeze(0))\\n\\n\\tU = torch.cat(U, dim = 0)\\n\\tS = torch.cat(S, dim = 0)\\n\\tVT = torch.cat(VT, dim = 0)\\n\\n\\tF = torch.bmm(torch.bmm(U, S), VT)\\n\\tF = torch.bmm(T_src, torch.bmm(F.permute(0, 2, 1), T_target.permute(0, 2, 1)))\\n\\tF = F / F[:, 2, 2].view(batch_size, 1, 1)\\n\\n\\tutils.nan_check(F)\\n\\n\\treturn F\",\n \"def miccai2018_net_t1t2(vol_size, enc_nf, dec_nf, int_steps=7, use_miccai_int=False, indexing='ij', bidir=False, vel_resize=1/2): \\n ndims = len(vol_size)\\n assert ndims in [1, 2, 3], \\\"ndims should be one of 1, 2, or 3. found: %d\\\" % ndims\\n\\n # get unet\\n unet_model_channel1 = unet_core(vol_size, enc_nf, dec_nf, full_size=False)\\n [srcT1, tgtT1] = unet_model_channel1.inputs\\n x_out_T1 = unet_model_channel1.outputs[-1]\\n unet_model_channel2 = unet_core(vol_size, enc_nf, dec_nf, full_size=False)\\n [srcT2, tgtT2] = unet_model_channel2.inputs\\n x_out_T2 = unet_model_channel2.outputs[-1]\\n\\n # velocity mean and logsigma layers\\n Conv = getattr(KL, 'Conv%dD' % ndims)\\n flow_mean_T1 = Conv(ndims, kernel_size=3, padding='same',\\n kernel_initializer=RandomNormal(mean=0.0, stddev=1e-5), name='flow_T1')(x_out_T1)\\n # we're going to initialize the velocity variance very low, to start stable.\\n flow_log_sigma_T1 = Conv(ndims, kernel_size=3, padding='same',\\n kernel_initializer=RandomNormal(mean=0.0, stddev=1e-10),\\n bias_initializer=keras.initializers.Constant(value=-10),\\n name='log_sigma_T1')(x_out_T1)\\n flow_params_T1 = concatenate([flow_mean_T1, flow_log_sigma_T1])\\n flow_T1 = Sample(name=\\\"z_sample_T1\\\")([flow_mean_T1, flow_log_sigma_T1])\\n \\n # integrate if diffeomorphic (i.e. treating 'flow' above as stationary velocity field)\\n if use_miccai_int:\\n # for the miccai2018 submission, the squaring layer\\n # scaling was essentially built in by the network\\n # was manually composed of a Transform and and Add Layer.\\n v = flow_T1\\n for _ in range(int_steps):\\n v1 = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([v, v])\\n v = keras.layers.add([v, v1])\\n flow_T1 = v\\n\\n else:\\n # new implementation in neuron is cleaner.\\n z_sample = flow_T1\\n flow_T1 = nrn_layers.VecInt(method='ss', name='flow-int_T1', int_steps=int_steps)(z_sample)\\n if bidir:\\n rev_z_sample = Negate()(z_sample)\\n neg_flow_T1 = nrn_layers.VecInt(method='ss', name='neg_flow-int_T1', int_steps=int_steps)(rev_z_sample)\\n # get up to final resolution\\n flow_T1 = trf_resize(flow_T1, vel_resize, name='diffflow_T1')\\n if bidir:\\n neg_flow_T1 = trf_resize(neg_flow_T1, vel_resize, name='neg_diffflow_T1')\\n # transform\\n y_T1 = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([srcT1, flow_T1])\\n if bidir:\\n y_tgt_T1 = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([tgtT1, neg_flow_T1])\\n \\n flow_mean_T2 = Conv(ndims, kernel_size=3, padding='same',\\n kernel_initializer=RandomNormal(mean=0.0, stddev=1e-5), name='flow_T2')(x_out_T2)\\n # we're going to initialize the velocity variance very low, to start stable.\\n flow_log_sigma_T2 = Conv(ndims, kernel_size=3, padding='same',\\n kernel_initializer=RandomNormal(mean=0.0, stddev=1e-10),\\n bias_initializer=keras.initializers.Constant(value=-10),\\n name='log_sigma_T2')(x_out_T2)\\n flow_params_T2 = concatenate([flow_mean_T2, flow_log_sigma_T2])\\n flow_T2 = Sample(name=\\\"z_sample_T2\\\")([flow_mean_T2, flow_log_sigma_T2])\\n # integrate if diffeomorphic (i.e. treating 'flow' above as stationary velocity field)\\n if use_miccai_int:\\n # for the miccai2018 submission, the squaring layer\\n # scaling was essentially built in by the network\\n # was manually composed of a Transform and and Add Layer.\\n v = flow_T2\\n for _ in range(int_steps):\\n v1 = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([v, v])\\n v = keras.layers.add([v, v1])\\n flow_T2 = v\\n\\n else:\\n # new implementation in neuron is cleaner.\\n z_sample = flow_T2\\n flow_T2 = nrn_layers.VecInt(method='ss', name='flow-int_T2', int_steps=int_steps)(z_sample)\\n if bidir:\\n rev_z_sample = Negate()(z_sample)\\n neg_flow_T2 = nrn_layers.VecInt(method='ss', name='neg_flow-int_T2', int_steps=int_steps)(rev_z_sample)\\n # get up to final resolution\\n flow_T2 = trf_resize(flow_T2, vel_resize, name='diffflow_T2')\\n if bidir:\\n neg_flow_T2 = trf_resize(neg_flow_T2, vel_resize, name='neg_diffflow_T2')\\n # transform\\n y_T2 = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([srcT2, flow_T2])\\n if bidir:\\n y_tgt_T2 = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([tgtT2, neg_flow_T2])\\n\\n # velocity sample\\n flow_params = MergeInputs3D()([flow_params_T1, flow_params_T2])\\n ndims = len(flow_params.get_shape()) - 2\\n flow_mean = flow_params[..., 0:ndims]\\n flow_log_sigma = flow_params[..., ndims:]\\n flow = Sample(name=\\\"z_sample\\\")([flow_mean, flow_log_sigma])\\n\\n # integrate if diffeomorphic (i.e. treating 'flow' above as stationary velocity field)\\n if use_miccai_int:\\n # for the miccai2018 submission, the squaring layer\\n # scaling was essentially built in by the network\\n # was manually composed of a Transform and and Add Layer.\\n v = flow\\n for _ in range(int_steps):\\n v1 = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([v, v])\\n v = keras.layers.add([v, v1])\\n flow = v\\n\\n else:\\n # new implementation in neuron is cleaner.\\n z_sample = flow\\n flow = nrn_layers.VecInt(method='ss', name='flow-int', int_steps=int_steps)(z_sample)\\n if bidir:\\n rev_z_sample = Negate()(z_sample)\\n neg_flow = nrn_layers.VecInt(method='ss', name='neg_flow-int', int_steps=int_steps)(rev_z_sample)\\n\\n # get up to final resolution\\n flow = trf_resize(flow, vel_resize, name='diffflow')\\n\\n if bidir:\\n neg_flow = trf_resize(neg_flow, vel_resize, name='neg_diffflow')\\n\\n # transform\\n y_T1_byflow = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([srcT1, flow])\\n y_T2_byflow = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([srcT2, flow])\\n if bidir:\\n y_tgt_T1_bynegflow = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([tgtT1, neg_flow])\\n y_tgt_T2_bynegflow = nrn_layers.SpatialTransformer(interp_method='linear', indexing=indexing)([tgtT2, neg_flow])\\n\\n # prepare outputs and losses\\n outputs = [y_T1_byflow,y_T2_byflow, flow_params, y_T1, y_T2]\\n if bidir:\\n outputs = [y_T1_byflow,y_T1_byflow,y_tgt_T1_bynegflow, y_tgt_T2_bynegflow, flow_params,y_T1, y_tgt_T1,y_T2, y_tgt_T2]\\n # build the model\\n return Model(inputs=[srcT1, tgtT1, srcT2, tgtT2], outputs=outputs)\",\n \"def assemble_matrices(self):\\n \\n #Pointer reassignment for convenience\\n N = self.ngrids\\n\\n #Begin with a linked-list data structure for the transmissibilities,\\n #and one-dimenstional arrays for the diagonal of B and the flux vector\\n T = lil_matrix((N, N), dtype=np.double)\\n B = np.zeros(N, dtype=np.double)\\n Q = np.zeros(N, dtype=np.double)\\n\\n #Read in boundary condition types and values\\n bcs = self.input_data['boundary conditions']\\n bc_type_1 = bcs['left']['type'].lower()\\n bc_type_2 = bcs['right']['type'].lower()\\n bc_value_1 = bcs['left']['value']\\n bc_value_2 = bcs['right']['value']\\n \\n #Loop over all grid cells\\n for i in range(N):\\n\\n #Apply left BC\\n if i == 0:\\n T[i, i+1] = -self.compute_transmissibility(i, i + 1)\\n\\n if bc_type_1 == 'neumann':\\n T[i, i] = T[i,i] - T[i, i+1]\\n elif bc_type_1 == 'dirichlet':\\n #Computes the transmissibility of the ith block\\n T0 = self.compute_transmissibility(i, i)\\n T[i, i] = T[i,i] - T[i, i+1] + 2.0 * T0\\n Q[i] = 2.0 * T0 * bc_value_1\\n else:\\n pass #TODO: Add error checking here if no bc is specified\\n\\n #Apply right BC\\n elif i == (N - 1):\\n T[i, i-1] = -self.compute_transmissibility(i, i - 1)\\n\\n if bc_type_2 == 'neumann':\\n T[i, i] = T[i,i] - T[i, i-1]\\n elif bc_type_2 == 'dirichlet':\\n #Computes the transmissibility of the ith block\\n T0 = self.compute_transmissibility(i, i)\\n T[i, i] = T[i, i] - T[i, i-1] + 2.0 * T0\\n Q[i] = 2.0 * T0 * bc_value_2\\n else:\\n pass #TODO:Add error checking here if no bc is specified\\n\\n #If there is no boundary condition compute interblock transmissibilties\\n else:\\n T[i, i-1] = -self.compute_transmissibility(i, i-1)\\n T[i, i+1] = -self.compute_transmissibility(i, i+1)\\n T[i, i] = (self.compute_transmissibility(i, i-1) +\\n self.compute_transmissibility(i, i+1))\\n\\n #Compute accumulations\\n B[i] = self.compute_accumulation(i)\\n\\n #If constant-rate wells are present, add them to the flux vector\\n if self.rate_well_grids is not None:\\n Q[self.rate_well_grids] += self.rate_well_values\\n\\n \\n #Return sparse data-structures\\n return (T.tocsr(), \\n csr_matrix((B, (np.arange(N), np.arange(N))), shape=(N,N)), \\n Q)\",\n \"def T(self):\\n try:\\n return self.__T\\n except AttributeError:\\n raise AttributeError(\\\"Haven't run stitching, so we don't have the T matrix\\\")\",\n \"def flux(self, u):\\n flu = np.zeros((3,2), dtype=np.float64)\\n flu[0,0] = u[1]\\n flu[1,0] = u[0] * (u[1]/u[0])**2 + 0.5 * 9.81*u[0]**2\\n flu[2,0] = u[1] * u[2]/u[0] #FIXME attenzione che c'è il punto controllare se sono scalari o vettori'\\n flu[0,1] = u[2]\\n flu[1,1] = u[2] * u[1]/u[0]\\n flu[2,1] = u[0] * (u[2]/u[0])**2 + 0.5 * 9.81*u[0]**2\\n return flu\",\n \"def TNFR1_to_SecondaryComplex():\\n \\n Parameter('TNFa_0' , 5000) # 3000 corresponds to 50ng/ml TNFa\\n Parameter('TNFR1_0' , 200) # 200 receptors per cell\\n Parameter('TRADD_0' , 1000) # molecules per cell (arbitrarily assigned)1000\\n Parameter('CompI_0' , 0) # complexes per cell\\n Parameter('RIP1_0' , 20000) # molecules per cell 20000\\n Parameter('NFkB_0' , 0) # molecules per cell\\n \\n Initial(TNFa(blig=None), TNFa_0) # TNFa Ligand\\n Initial(TNFR1(blig=None, bDD=None, state='norm'), TNFR1_0) # TNFR1\\n Initial(TRADD(bDD1=None, bDD2=None, state='inactive'), TRADD_0) # TRADD\\n Initial(CompI(bDD=None, state='unmod'), CompI_0) # Complex I\\n Initial(RIP1(bDD=None, bRHIM = None, state = 'ub'), RIP1_0) # RIP1\\n Initial(NFkB(bf=None), NFkB_0)\\n\\n # =========================================\\n # TNFR1 ligation, formation of Complex I and release of RIP1 and TRADD rules\\n # -----------------------------------------\\n # TNFa+ TNFR1 <-> TNFa:TNFR1\\n # TNFa:TNFR1 + TRADD <-> TNFa:TNFR1:TRADD >> CompI\\n # CompI + RIP1 <-> CompI:RIP1 >> [active]CompI:RIP1-Ub\\n # CompI + RIP1-Ub <-> CompI:RIP1-Ub \\n \\n # [active]CompI:RIP1-Ub >> NFkB # This reaction will consume the receptor.\\n # [active]CompI:RIP1-Ub >> [active]CompI:RIP1\\n # [active]CompI:RIP1 >> [active]CompI # A20 mediated degradation of RIP1\\n # [active]CompI:RIP1 >> [active]CompI + RIP1\\n # [active]CompI >> [active]TRADD + [norm]TNFR1 #receptor recycle typically distroys the ligand.\\n\\n # RIP1 >> RIP1-Ub #These reactions were added because Doug Green reported that FADD and RIP1 bind\\n # RIP1-Ub >> RIP1 #independently of receptor, and FADD:RIP1 formation leads to Caspase 8 activation.\\n #These reaction decrease the amount of RIP1 by spontaneously ubiquitinating it. \\n\\n # ------------------------------------------\\n \\n # -------------Complex I assembly----------------\\n bind(TNFa(blig=None), 'blig', TNFR1(blig=None, bDD=None, state='norm'), 'blig', [KF, KR])\\n bind(TNFR1(blig = ANY, bDD = None, state = 'norm'), 'bDD', TRADD(bDD1=None, bDD2=None, state='inactive'), 'bDD1', [KF, KR])\\n preCompI = TNFa(blig=ANY)%TNFR1(blig=ANY, bDD=ANY, state = 'norm')%TRADD(bDD1 = ANY, bDD2=None, state = 'inactive')\\n Rule('CompI_formation', preCompI >> CompI(bDD=None, state = 'unmod'), KC)\\n \\n # --------------Complex I - RIP1 Modification-----------------\\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='unmod'), 'bDD',[KF, KR])\\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[KF, KR]) \\n \\n Rule('CompI_Ub', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'unmod')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), KC)\\n Rule('CompI_Ub2', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), KC)\\n Rule('CompI_deUb', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub')>>CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None,state='unmod'),KC)\\n bind(CompI(bDD=None, state='mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state = 'unmod'), 'bDD', [Parameter('k2', 0), KR])\\n #Rule('RIP1_rel', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='unmod') >> CompI(bDD=None, state='mod') + RIP1(bDD=None, bRHIM = None, state = 'unmod'), KC3)\\n #bind(CompI(bDD=None, state = 'mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[KF, KR])\\n #Rule('RIP1_deg', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='unmod') >> CompI(bDD=None, state='mod'),KC3)\\n Rule('TNFR1_recycle', CompI(bDD=None, state='mod') >> TRADD(bDD1=None, bDD2 = None, state='active') + TNFR1(blig = None, bDD = None, state = 'norm'), KC)\\n Rule('NFkB_expression', CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub') + NFkB(bf=None), KE)\\n # --------------RIP1 Ubiquitination---------------------------\\n Rule('RIP1_Ub', RIP1(bDD=None, bRHIM = None, state='unmod')>> RIP1(bDD=None, bRHIM = None, state='ub'), KC2)\\n # Rule('RIP1_deUb', RIP1(bDD=None, bRHIM = None, state='ub')>> RIP1(bDD=None, bRHIM = None, state='unmod'), KR)\",\n \"def TNFR1_to_SecondaryComplex():\\n \\n Parameter('TNFa_0' , 6000) # 6000 corresponds to 100ng/ml TNFa\\n Parameter('TNFR1_0' , 4800) # 4800 receptors per cell\\n Parameter('TRADD_0' , 9000) # molecules per cell (arbitrarily assigned) 9000\\n Parameter('RIP1_0' , 12044) # molecules per cell (arbitrarily assigned) 12044\\n Parameter('CompI_0' , 0) # complexes per cell\\n Parameter('NFkB_0' , 0) # molecules per cell\\n alias_model_components()\\n \\n Initial(TNFa(blig=None), TNFa_0) # TNFa Ligand\\n Initial(TNFR1(blig=None, bDD=None, state='norm'), TNFR1_0) # TNFR1\\n Initial(TRADD(bDD1=None, bDD2=None, state='inactive'), TRADD_0) # TRADD\\n Initial(CompI(bDD=None, state='unmod'), CompI_0) # Complex I\\n Initial(RIP1(bDD=None, bRHIM = None, bPARP = None, state = 'ub'), RIP1_0) # RIP1\\n Initial(NFkB(bf=None), NFkB_0)\\n \\n # =========================================\\n # TNFR1 ligation, formation of Complex I and release of RIP1 and TRADD rules\\n # -----------------------------------------\\n # TNFa+ TNFR1 <-> TNFa:TNFR1\\n # TNFa:TNFR1 + TRADD <-> TNFa:TNFR1:TRADD >> CompI\\n # CompI + RIP1 <-> CompI:RIP1 >> [active]CompI:RIP1-Ub\\n # CompI + RIP1-Ub <-> CompI:RIP1-Ub\\n \\n # [active]CompI:RIP1-Ub >> NFkB # This reaction will consume the receptor.\\n # [active]CompI:RIP1-Ub >> [active]CompI:RIP1\\n # [active]CompI:RIP1 >> [active]CompI # A20 mediated degradation of RIP1\\n # [active]CompI:RIP1 >> [active]CompI + RIP1\\n # [active]CompI >> [active]TRADD + [norm]TNFR1 #receptor recycle typically distroys the ligand.\\n \\n # RIP1 >> RIP1-Ub #These reactions were added because Doug Green reported that FADD and RIP1 bind\\n # RIP1-Ub >> RIP1 #independently of receptor, and FADD:RIP1 formation leads to Caspase 8 activation.\\n #These reaction decrease the amount of RIP1 by spontaneously ubiquitinating it.\\n \\n # ------------------------------------------\\n \\n # -------------Complex I assembly----------------\\n bind(TNFa(blig=None), 'blig', TNFR1(blig=None, bDD=None, state='norm'), 'blig', [2e-7, 1e-4])\\n bind(TNFR1(blig = ANY, bDD = None, state = 'norm'), 'bDD', TRADD(bDD1=None, bDD2=None, state='inactive'), 'bDD1', [1e-6, 0.2])\\n preCompI = TNFa(blig=ANY)%TNFR1(blig=ANY, bDD=ANY, state = 'norm')%TRADD(bDD1 = ANY, bDD2=None, state = 'inactive')\\n Rule('CompI_formation', preCompI >> CompI(bDD=None, state = 'unmod'), Parameter('k2', 1))\\n \\n # --------------Complex I - RIP1 Modification-----------------\\n # Complex I recruits RIP1\\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='unmod'), 'bDD',[1e-6, 1e-3])\\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[1e-6, 1e-3])\\n \\n # Complex I undergos modifications (e.g. Ubiquitination) and elicits NFkB signaling\\n Rule('CompI_Ub', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'unmod')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), Parameter('k3', 1))\\n Rule('CompI_Ub2', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), Parameter('k4', 1))\\n Rule('NFkB_signaling', CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub') + NFkB(bf=None), Parameter('k5', 1e-3))\\n\\n # De-ubiquitination and degradation or release of RIP1 from complex I\\n Rule('CompI_deUb', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub')>>CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None,state='unmod'), Parameter('k6',1))\\n Rule('RIP1_deg', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub') >> CompI(bDD=None, state='mod'), Parameter('k7',1))\\n \\n bind(CompI(bDD=None, state='mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state = 'unmod'), 'bDD', [1e-10,1])\\n \\n # Receptor recycle\\n Rule('TNFR1_recycle', CompI(bDD=None, state='mod') >> TRADD(bDD1=None, bDD2 = None, state='active') + TNFR1(blig = None, bDD = None, state = 'norm'), Parameter('k8',1))\\n \\n # --------------RIP1 Ubiquitination---------------------------\\n Rule('RIP1_Ub', RIP1(bDD=None, bRHIM = None, state='unmod')>> RIP1(bDD=None, bRHIM = None, state='ub'), Parameter('k9', 1e-7))\",\n \"def T(self):\\n # TODO - your code here\\n transpose = []\\n for col in range(self.w):\\n new_row = []\\n for row in range(self.h):\\n new_row.append(self.g[row][col])\\n transpose.append(new_row)\\n return Matrix(transpose)\\n # TODO - your code here\",\n \"def get_u_tile(cls, s, s2):\\n a_weight = F.softmax(s, dim=2) # [B, t1, t2]\\n a_weight.data.masked_fill_(a_weight.data != a_weight.data, 0) # remove nan from softmax on -inf\\n u_tile = torch.bmm(a_weight, s2) # [B, t1, t2] * [B, t2, D] -> [B, t1, D]\\n return u_tile\",\n \"def get_transmission(I, A, darkch, omega, w):\\n return 1 - omega * get_dark_channel(I / A, w)\",\n \"def _stack(matrix, fluid1, fluid2=None):\\n # Cast input\\n m = np.array(matrix, ndmin=1)\\n f1 = np.array(fluid1, ndmin=1)\\n\\n # If array is identical, reduce to one value\\n if np.all(m[:-1]-m[1:] == 0):\\n m = np.array([m[0]])\\n if np.all(f1[:-1]-f1[1:] == 0):\\n f1 = np.array([f1[0]])\\n\\n # Return depending if `fluid2` or not\\n if fluid2:\\n f2 = np.array(fluid2, ndmin=1)\\n if np.all(f2[:-1]-f2[1:] == 0):\\n f2 = np.array([f2[0]])\\n eperm = np.column_stack((np.tile(m, f1.size*f2.size),\\n f1.repeat(m.size*f2.size),\\n np.tile(f2.repeat(m.size), f1.size)))\\n return eperm\\n else:\\n return np.column_stack((np.tile(m, f1.size), f1.repeat(m.size)))\",\n \"def get_unitary(self, params: Sequence[float] = []) -> UnitaryMatrix:\\n self.check_parameters(params)\\n if hasattr(self, 'utry'):\\n return self.utry\\n\\n return self.gate.get_unitary(params)\",\n \"def Controlled2(U):\\n '''Generalized controlled unitary tensor construction\\n Parameters:\\n -----------\\n U: input tensor which is assumed to be a square Matrix\\n\\n Returns:\\n --------\\n Controlled unitary\\n\\n '''\\n shp = U.shape\\n new_ten = scipy.linalg.block_diag(np.eye(*shp), U)\\n return new_ten.reshape(2, shp[0], 2, shp[1], 2, shp[2])\",\n \"def Static_T(Temp_m,M):\\n return Temp_m/(1+(gamma-1)/2*M**2)\",\n \"def getTransposeMatrix(self) -> CMatrix4:\\n ...\",\n \"def getMatrixRepresentation(self):\\n \\n S = self.spinSystem\\n dim = S.dimension\\n matRep = np.zeros([dim, dim], dtype = complex)\\n\\n for i, b1 in enumerate(S.basis.Bras):\\n for j, b2 in enumerate(S.basis.Kets):\\n ket = self.__mul__(b2)\\n\\n matRep[i,j] += b1*ket\\n\\n return matRep\",\n \"def T(self, q = np.zeros(2) , dq = np.zeros(2) , ddq = np.zeros(2) , uD = 0 , t = 0 ): \\n \\n R = self.R[uD]\\n \\n e = self.F( q , dq , ddq , t ) # actuator efforts computed for manipulator side only\\n \\n Tl = self.Tlosses( q , dq , ddq ) # see alex logbook : virtual effort related to motor losses (inertial and viscous rotor forces)\\n \\n T = np.dot( np.linalg.inv(R) , e ) + np.dot( R , Tl ) \\n \\n return T\",\n \"def T(self, q = np.zeros(2) , dq = np.zeros(2) , ddq = np.zeros(2) , uD = 0 , t = 0 ): \\n \\n R = self.R[uD]\\n \\n e = self.F( q , dq , ddq , t ) # actuator efforts computed for manipulator side only\\n \\n Tl = self.Tlosses( q , dq , ddq ) # see alex logbook : virtual effort related to motor losses (inertial and viscous rotor forces)\\n \\n T = np.dot( np.linalg.inv(R) , e ) + np.dot( R , Tl ) \\n \\n return T\",\n \"def Flux_levels(self, flux, r_lim=0.45):\\n if flux == 'mass':\\n set_integrand = lambda x: x\\n\\n elif flux == 'momentum':\\n set_integrand = lambda x: x**2\\n\\n elif flux == 'buoyancy':\\n b = self.read_vars(['b'])['b']\\n set_integrand = lambda x: x*b\\n\\n npx = self.params['npx']\\n Lx = self.params['Lx']\\n Ly = self.params['Ly']\\n Lz = self.params['Lz']\\n nz = self.params['nz']\\n dx = self.params['dx']\\n dy = self.params['dy']\\n\\n t = self.read_vars(['t'])['t']\\n n_time = t.shape[0]\\n\\n r_max = r_lim # as in forced_plume_nudging.py\\n z_max = 0.95\\n\\n\\n flux = np.zeros((n_time, nz))\\n\\n fields = self.read_vars(['w', 'x', 'y', 'z'])\\n w = velocity_interpolation(fields['w'], axis=1)\\n\\n XX, YY = np.meshgrid(fields['x']/Lx - 0.5,\\n fields['y']/Ly - 0.5)\\n\\n r = np.sqrt(XX**2 + YY**2)\\n mask_1 = ma.masked_outside(r, 0, r_max)\\n #mask_2 = ma.masked_outside(ZZ, 0, z_max)\\n\\n # defining integrand\\n integrand = set_integrand(w)\\n\\n for t in range(n_time):\\n for z_i in range(nz):\\n field_new = ma.masked_array(integrand[t, z_i], mask_1.mask)\\n flux[t, z_i] = field_new.sum()\\n\\n return flux\",\n \"def _fluctuation_matrix(reference_frame, trajectories_path, atom_subset, topology, chunk, first_frame):\\n residual_sum_squares = np.zeros((len(atom_subset)))\\n \\n ## now can compute the difference between the trajectory and its reference\\n ## ri(t) - riref Using the mdtraj trajectory attribute xyz to extract\\n ## the cartesian coordinates of trajectory and reference in a numpy array\\n ## chunk.xyz.shape = (frames, atom, coordinate dimensions)\\n \\n \\n number_of_frames=0 \\n trajectory_time=[]\\n for chunk_i in md.iterload(trajectories_path, chunk = chunk, top=topology, atom_indices = atom_subset):\\n trajectory_time.append(chunk_i.time)\\n for atom in range(len(atom_subset)):\\n diff = np.subtract(chunk_i.xyz[:, atom, :] * 10, reference_frame[atom])\\n residual_sum_squares[atom] = residual_sum_squares[atom] + ((diff ** 2).sum(axis = 1).sum(axis=0))\\n number_of_frames += chunk_i.xyz.shape[0]\\n ## the result is a matrix with all fluctuations squared\\n ## shape(number of frames * atom numbers, 3)\\n ## from 0 to number of frames we have information of first atom\\n ## then from number of frames to number of frames * 2 second atoms\\n ## and so forth\\n \\n return residual_sum_squares, number_of_frames, trajectory_time\",\n \"def get_remat(self) -> ndarray:\\n return self.data.weight[:, None]*self.revar.mapping.mat\",\n \"def basis(T, dimensions, t):\\n # Undo change of basis from realizer, and then transform into window\\n B = canonical_basis(dimensions, t)\\n return B.dot(T)\",\n \"def extract_utri( m, context = FloatContext ):\\n rows, cols = shape_mat(m)\\n return [ [context.zero]*i + row[i:]\\n for i, row in enumerate(m) ]\",\n \"def _apply_unitary(self, state, mat, wires):\\n # translate to wire labels used by device\\n device_wires = self.map_wires(wires)\\n\\n dim = 2 ** len(device_wires)\\n mat_batch_size = self._get_batch_size(mat, (dim, dim), dim**2)\\n state_batch_size = self._get_batch_size(state, (2,) * self.num_wires, 2**self.num_wires)\\n\\n shape = [2] * (len(device_wires) * 2)\\n state_axes = device_wires\\n # If the matrix is broadcasted, it is reshaped to have leading axis of size mat_batch_size\\n if mat_batch_size:\\n shape.insert(0, mat_batch_size)\\n if state_batch_size:\\n raise NotImplementedError(\\n \\\"Applying a broadcasted unitary to an already broadcasted state via \\\"\\n \\\"_apply_unitary is not supported. Broadcasting sizes are \\\"\\n f\\\"({mat_batch_size}, {state_batch_size}).\\\"\\n )\\n # If the state is broadcasted, the affected state axes need to be shifted by 1.\\n if state_batch_size:\\n state_axes = [ax + 1 for ax in state_axes]\\n mat = self._cast(self._reshape(mat, shape), dtype=self.C_DTYPE)\\n axes = (np.arange(-len(device_wires), 0), state_axes)\\n tdot = self._tensordot(mat, state, axes=axes)\\n\\n # tensordot causes the axes given in `wires` to end up in the first positions\\n # of the resulting tensor. This corresponds to a (partial) transpose of\\n # the correct output state\\n # We'll need to invert this permutation to put the indices in the correct place\\n unused_idxs = [idx for idx in range(self.num_wires) if idx not in device_wires]\\n perm = list(device_wires) + unused_idxs\\n # If the matrix is broadcasted, all but the first dimension are shifted by 1\\n if mat_batch_size:\\n perm = [idx + 1 for idx in perm]\\n perm.insert(0, 0)\\n if state_batch_size:\\n # As the state broadcasting dimension always is the first in the state, it always\\n # ends up in position `len(device_wires)` after the tensordot. The -1 causes it\\n # being permuted to the leading dimension after transposition\\n perm.insert(len(device_wires), -1)\\n\\n inv_perm = np.argsort(perm) # argsort gives inverse permutation\\n return self._transpose(tdot, inv_perm)\",\n \"def tmatrix(self, source, drain):\\n if self.gf_r is None:\\n self.gf()\\n\\n G_sd = self.device.connections[drain].dot(self.gf_r).dot(self.device.connections[source].conj().T)\\n\\n gamma_source = self.calculators[source].gamma()\\n gamma_drain = self.calculators[drain].gamma()\\n\\n vals, vecs = linalg.eig(gamma_source)\\n vald, vecd = linalg.eig(gamma_drain)\\n\\n return numpy.diag((-self.calculators[drain].v_r.real)**.5).\\\\\\n dot(self.calculators[drain].states_ri).dot(G_sd).\\\\\\n dot(self.calculators[source].states_li.conj().T).\\\\\\n dot(numpy.diag(self.calculators[source].v_l.real**.5))\",\n \"def get_mmt():\\r\\n # M^T\\r\\n MT = np.array([[-1, 0, 0, 0, 0, 0, 0, 0, 0],\\r\\n [1, -1, 0, 0, 0, 0, 0, 0, 0],\\r\\n [0, 1, -1, 0, 0, 0, 0, 0, 0],\\r\\n [0, 0, 1, -1, 0, 0, 0, 0, 0],\\r\\n [0, 0, 0, 1, -1, 0, 0, 0, 0],\\r\\n [0, 0, 0, 0, 1, -1, 0, 0, 0],\\r\\n [0, 0, 0, 0, 0, 1, -1, 0, 0],\\r\\n [0, 0, 0, 0, 0, 0, 1, -1, 0],\\r\\n [0, 0, 0, 0, 0, 0, 0, 1, -1],\\r\\n [0, 0, 0, 0, 0, 0, 0, 0, 1]])\\r\\n\\r\\n M = np.transpose(MT)\\r\\n return M, MT\",\n \"def canonical_basis(dimensions, t):\\n t = np.atleast_1d(t)\\n B = np.asarray([readout(dimensions, r) for r in t])\\n return B\",\n \"def reac_beam2DU_global(coord, I, Emod , U):\\r\\n vec = coord[1, :] - coord[0, :]\\r\\n L = np.linalg.norm(vec)\\r\\n nx = vec[0]/L\\r\\n ny = vec[1]/L\\r\\n \\r\\n Q = np.array([\\r\\n [-ny, nx, 0, 0, 0, 0],\\r\\n [0, 0, 1.0, 0, 0, 0],\\r\\n [0, 0, 0, -ny, nx, 0],\\r\\n [0, 0, 0, 0, 0, 1.0]])\\r\\n\\r\\n kl = (I*Emod/(L*L*L)) * np.array([\\r\\n [12.0, 6, -12.0, 6*L],\\r\\n [6, 4*L*L, -6*L, 2*L*L],\\r\\n [-12.0, -6*L, 12.0, -6*L],\\r\\n [6*L, 2*L*L, -6*L, 4*L*L]])\\r\\n kG = np.dot(np.dot(Q.T, kl), Q)\\r\\n fl = np.dot(kG , U)\\r\\n return fl\",\n \"def mtf_bitransformer_tiny():\\n hparams = mtf_bitransformer_base()\\n hparams.batch_size = 2\\n hparams.mesh_shape = \\\"\\\"\\n hparams.d_model = 128\\n hparams.encoder_layers = [\\\"self_att\\\", \\\"drd\\\"] * 2\\n hparams.decoder_layers = [\\\"self_att\\\", \\\"enc_att\\\", \\\"drd\\\"] * 2\\n hparams.num_heads = 4\\n hparams.d_ff = 512\\n return hparams\",\n \"def optimizeFluidArray(self):\\n print(\\\"Run the function for optimization.\\\")\\n self.fluidNodes = np.empty(self.voidSpace, dtype = np.int64)\\n ySize = self.ny; xSize = self.nx\\n print(\\\"Start to fill effective fluid nodes.\\\")\\n tmpIndicesDomain = -np.ones(self.isDomain.shape, dtype = np.int64)\\n tmpIndicesFN = 0\\n for i in sp.arange(ySize):\\n for j in sp.arange(xSize):\\n if (self.isDomain[i, j] == 1):\\n# if (self.effectiveDomain[i, j] == 255.):\\n tmpIndices = i * xSize + j\\n self.fluidNodes[tmpIndicesFN] = tmpIndices\\n tmpIndicesDomain[i, j] = tmpIndicesFN\\n tmpIndicesFN += 1\\n self.neighboringNodes = np.zeros(self.fluidNodes.size * 8, dtype = np.int64)\\n if self.interactionType == \\\"'EFS'\\\":\\n if self.explicitScheme == 8:\\n self.neighboringNodesISO8 = np.zeros(self.fluidNodes.size * 24, \\\\\\n dtype = np.int64)\\n elif self.explicitScheme == 10:\\n self.neighboringNodesISO10 = np.zeros(self.fluidNodes.size * 36, \\\\\\n dtype = np.int64)\\n totalNodes = self.fluidNodes.size\\n #use cuda to generate the array for neighboring nodes\\n print(\\\"Start to fill neighboring nodes\\\")\\n deviceFluidNodes = cuda.to_device(self.fluidNodes)\\n devicetmpIndicesDomain = cuda.to_device(tmpIndicesDomain)\\n# deviceIsDomain = cuda.to_device(self.isDomain)\\n deviceNeighboringNodes = cuda.to_device(self.neighboringNodes)\\n blockNumX = int(self.xDimension / self.threadNum) \\n blockNumY = math.ceil(self.fluidNodes.size / self.xDimension)\\n threadPerBlock1D = (self.threadNum, 1)\\n grid = (blockNumX, blockNumY)\\n\\n fillNeighboringNodes[grid, threadPerBlock1D](totalNodes, self.nx, self.ny, \\\\\\n self.xDimension, deviceFluidNodes, devicetmpIndicesDomain, \\\\\\n deviceNeighboringNodes)\\n self.neighboringNodes = deviceNeighboringNodes.copy_to_host()\\n if self.interactionType == \\\"'EFS'\\\":\\n if self.explicitScheme == 8:\\n deviceNeighboringNodesISO8 = cuda.to_device(self.neighboringNodesISO8)\\n fillNeighboringNodesISO8[grid, threadPerBlock1D](totalNodes, self.nx, self.ny, \\\\\\n self.xDimension, deviceFluidNodes, devicetmpIndicesDomain, \\\\\\n deviceNeighboringNodesISO8)\\n self.neighboringNodesISO8 = deviceNeighboringNodesISO8.copy_to_host()\\n elif self.explicitScheme == 10:\\n deviceNeighboringNodesISO10 = cuda.to_device(self.neighboringNodesISO10)\\n fillNeighboringNodesISO10[grid, threadPerBlock1D](totalNodes, self.nx, self.ny, \\\\\\n self.xDimension, deviceFluidNodes, devicetmpIndicesDomain, \\\\\\n deviceNeighboringNodesISO10)\\n self.neighboringNodesISO10 = deviceNeighboringNodesISO10.copy_to_host()\\n \\n print(\\\"Redefine the fluid nodes.\\\")\\n# cuda.current_context().trashing.clear()\\n self.optFluidPDF = np.empty([self.typesFluids, self.fluidNodes.size, 9])\\n self.optFluidRho = np.empty([self.typesFluids, self.fluidNodes.size])\\n self.optMacroVelocity = np.zeros(self.fluidNodes.size)\\n self.optMacroVelocityX = np.zeros(self.fluidNodes.size, dtype = np.float64)\\n self.optMacroVelocityY = np.zeros(self.fluidNodes.size, dtype = np.float64)\\n self.optForceX = np.zeros([self.typesFluids, self.fluidNodes.size], \\\\\\n dtype = np.float64)\\n self.optForceY = np.zeros([self.typesFluids, self.fluidNodes.size], \\\\\\n dtype = np.float64)\\n tmpDomain = np.array([i == 1 for i in self.isDomain.reshape(ySize * xSize)])\\n for i in sp.arange(self.typesFluids):\\n self.optFluidRho[i] = self.fluidsDensity.reshape(self.typesFluids, \\\\\\n ySize * xSize)[i, tmpDomain]\\n self.optFluidPDF[i] = self.fluidPDF.reshape(self.typesFluids, ySize * \\\\\\n xSize, 9)[i, tmpDomain]\",\n \"def __createSpecTempT(self):\\n\\t\\tspecTempT = np.copy(self.specTemplates)\\n\\t\\tspecTempT = np.transpose(specTempT)\\n\\t\\tspecTempT = specTempT * self.covInv\\n\\t\\t\\t\\t\\n\\t\\treturn specTempT\",\n \"def get_trans_net():\\n return nn.Sequential(nn.Linear(2, 64), nn.LeakyReLU(), nn.Linear(64, 64), nn.LeakyReLU(), nn.Linear(64, 2))\",\n \"def test_trotter_hamiltonian_scalar_mul(nqubits=3):\\n local_ham = hamiltonians.TFIM(nqubits, h=1.0, trotter=True)\\n target_ham = 2 * hamiltonians.TFIM(nqubits, h=1.0, numpy=True)\\n local_dense = (2 * local_ham).dense\\n np.testing.assert_allclose(local_dense.matrix, target_ham.matrix)\\n\\n local_ham = hamiltonians.TFIM(nqubits, h=1.0, trotter=True)\\n local_dense = (local_ham * 2).dense\\n np.testing.assert_allclose(local_dense.matrix, target_ham.matrix)\",\n \"def getDustTemperature(grid=None, ppar=None):\\n op = dustopac.radmc3dDustOpac()\\n dinfo = op.readDustInfo()\\n ngs = len(dinfo['gsize'])\\n\\n tdust = np.zeros([grid.nx, grid.ny, grid.nz, ngs], dtype=np.float64)\\n tgas = getGasTemperature(grid=grid, ppar=ppar)\\n for ig in range(ngs):\\n tdust[:,:,:,ig] = tgas\\n\\n return tdust\",\n \"def P2T(self):\\n # Convert to RJ temperature\\n #fac=planck.I2Ta(self.f*1e6,1).value\\n fac = planck(self.f*1e6, 1)\\n fac=fac/fac[0]\\n self.spec=self.spec*np.tile(fac,(self.spec.shape[0],1))\",\n \"def get_transmission(self,img, atmosphere, *, size, omega, radius, epsilon):\\n #Get transmission map from the image\\n division = np.float64(img) / np.float64(atmosphere)\\n raw = (1 - omega * self.get_dark_channel(division, size=size)).astype(np.float32)\\n return cv2.ximgproc.guidedFilter(img, raw, radius, epsilon)\",\n \"def model(self, t):\\n flux = np.zeros_like(t)\\n dt = np.abs(self.timefrommidtransit(t))\\n start, finish = self.traits['T23'] / 2.0, self.traits['T14'] / 2.0\\n depth = self.traits['D']\\n\\n i = dt <= start\\n flux[i] = depth\\n i = (dt <= finish) * (dt > start)\\n flux[i] = (finish - dt[i]) / (finish - start) * depth\\n\\n return flux\",\n \"def transmission(ki,n,mi,mt):\\n ki,n,mi,mt = map(np.asarray,(ki,n,mi,mt))\\n kt = Fresnel._refract(ki,n,mi,mt)\\n return (kt,)+Fresnel._transmission(ki,kt,n,mi,mt)\",\n \"def test_trotter_hamiltonian_scalar_sub(nqubits=3):\\n local_ham = hamiltonians.TFIM(nqubits, h=1.0, trotter=True)\\n target_ham = 2 - hamiltonians.TFIM(nqubits, h=1.0, numpy=True)\\n local_dense = (2 - local_ham).dense\\n np.testing.assert_allclose(local_dense.matrix, target_ham.matrix)\\n\\n target_ham = hamiltonians.TFIM(nqubits, h=1.0, numpy=True) - 2\\n local_ham = hamiltonians.TFIM(nqubits, h=1.0, trotter=True)\\n local_dense = (local_ham - 2).dense\\n np.testing.assert_allclose(local_dense.matrix, target_ham.matrix)\",\n \"def ion2fluoTF(ion_img):\\n # return ion_img.T # --> TF1 HepaJune dataset batches FASTER\\n # return np.fliplr(ion_img) #--> TF2 HepaJune dataset batch\\n return np.flipud(ion_img) # --> TF for HepaNov17\",\n \"def GetModifiableTransform(self) -> \\\"itkTransformF22 *\\\":\\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF2MF2TF22_GetModifiableTransform(self)\",\n \"def get_matrix_rigidity_unitary(self):\\r\\n return self.flexural_rigidity/(self.length**3)*np.array([\\r\\n [12, 6*self.length, -12, 6*self.length],\\r\\n [6*self.length, 4*self.length**2, -6*self.length, 2*self.length**2],\\r\\n [-12, -6*self.length, 12, -6*self.length],\\r\\n [6*self.length, 2*self.length**2, -6*self.length, 4*self.length**2]\\r\\n ])\",\n \"def solveFluNet(T,Ntime,a,b0,b1,g,k,w,y0,P,N,RHS=3):\\n #I have added the variables P the transport matrix \\n #and N the network size because they are needed\\n #in the RHS.\\n #I have added the variable RHS to be able to \\n #choose which RHS method we want to use when running\\n #solveFluNet\\n \\n #add input variables to RHS functions if needed\\n def RHSnet(y,t,a,b0,b1,g,k,w):\\n \\\"\\\"\\\"RHS used by odeint to solve Flu model\\\"\\\"\\\"\\n S = y[:N]\\n E = y[N:2*N]\\n C = y[2*N:3*N]\\n b = b0 + b1*(1+np.cos(2*np.pi*t))\\n dy = np.zeros(3*N)\\n dy[:N]= k*(1-S)-b*C*S+w*np.dot(P,S)-w*S\\n dy[N:2*N]= b*C*S-(k+a)*E+w*np.dot(P,E)-w*E\\n dy[2*N:3*N]= a*E-(g+k)*C+w*np.dot(P,C)-w*C\\n return dy\\n \\n def RHSnetF(y,t,a,b0,b1,g,k,w):\\n \\\"\\\"\\\"RHS used by odeint to solve Flu model\\\"\\n Calculations carried out by fn.rhs\\n \\\"\\\"\\\"\\n dy = fn.rhs(P,y,t,a,b0,b1,g,k,w)\\n return dy\\n \\n def RHSnetFomp(y,t,a,b0,b1,g,k,w):\\n \\\"\\\"\\\"RHS used by odeint to solve Flu model\\n Calculations carried out by fn.rhs_omp\\n \\\"\\\"\\\"\\n dy = fn.rhs_omp(P,y,t,a,b0,b1,g,k,w,2)\\n return dy\\n\\n #Add code here and to RHS functions above to simulate network flu model\\n t = np.linspace(0,T,Ntime)\\n if (RHS==1):\\n sol = odeint(RHSnet,y0,t,args=(a,b0,b1,g,k,w))\\n if (RHS==2):\\n sol = odeint(RHSnetF,y0,t,args=(a,b0,b1,g,k,w))\\n if (RHS==3):\\n sol = odeint(RHSnetFomp,y0,t,args=(a,b0,b1,g,k,w))\\n S = sol[:,:N]\\n E = sol[:,N:2*N]\\n C = sol[:,2*N:3*N]\\n return t,S,E,C\",\n \"def flux():\\n delta = 0.01 # film thickness, [dm]\\n c = pre * 10 ** 2 / (R * tem) # total concentration calculated by ideal gas equation, in [mol/L]\\n D12 = 0.001626528 / pre # HCl diffusion in Air, [dm2/s] @296K\\n D13 = 3e-7 # HCl gas diffusion in water, [dm2/s] @296K\\n D23 = 1.5e-7 # CH4 gas diffusion in water, [dm2/s] @296K\\n N1 = ((x1_bar * x2d * D23) / (x2_bar * delta * D13) - x1_bar / delta) / \\\\\\n (x2_bar / (D12 * c) + x3_bar / (D13 * c) + D23 * x1_bar / (D12 * D13 * c))\\n # print 'Flux of HCl into water', abs(N1), [mol/(dm2*sec)]\\n return N1\",\n \"def transform_rdms(self,unitary, twordm = True):\\n dim = self.header['norbs']\\n t4index = None\\n if twordm:\\n t4index = [np.zeros((dim,dim, dim, dim)) for i in range(3)]\\n\\n for i in range(3):\\n temp = np.zeros((dim,dim, dim, dim))\\n temp2 = np.zeros((dim,dim, dim, dim))\\n temp3 = np.zeros((dim,dim, dim, dim))\\n for p in range(0,dim):\\n for mu in range(0,dim):\\n temp[p,:,:,:] += unitary[mu,p]*self.trdm[i][mu,:,:,:]\\n for q in range(0,dim):\\n for nu in range(0,dim):\\n temp2[p,q,:,:] += unitary[nu,q]*temp[p,nu,:,:]\\n for r in range(0,dim):\\n for lam in range(0,dim):\\n temp3[p,q,r,:] += unitary[lam,r]*temp2[p,q,lam,:]\\n for s in range(0,dim):\\n for sig in range(0,dim):\\n t4index[i][p,q,r,s] += unitary[sig,s]*temp3[p,q,r,sig]\\n \\n t2index = [np.dot(self.ordm[0], unitary), np.dot(self.ordm[1], unitary) ]\\n t2index = [ np.dot(unitary.T , t2index[0]) , np.dot(unitary.T , t2index[1]) ]\\n\\n return t2index , t4index\",\n \"def GetModifiableTransform(self) -> \\\"itkTransformD22 *\\\":\\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF2MF2TD22_GetModifiableTransform(self)\",\n \"def transfer_matrix(reliability, size):\\n\\n return ((1.0 - reliability) * np.eye(size, k=0, dtype=float) +\\n reliability * np.eye(size, k=1, dtype=float))\",\n \"def mtf_unitransformer_all_layers_tiny():\\n hparams = mtf_unitransformer_tiny()\\n hparams.moe_num_experts = 4\\n hparams.moe_expert_x = 4\\n hparams.moe_expert_y = 4\\n hparams.moe_hidden_size = 512\\n hparams.layers = [\\\"self_att\\\", \\\"local_self_att\\\", \\\"moe_1d\\\", \\\"moe_2d\\\", \\\"drd\\\"]\\n return hparams\",\n \"def op_fresnel_transmission(m, theta):\\n tau_p = pypolar.fresnel.T_par(m, theta)\\n tau_s = pypolar.fresnel.T_per(m, theta)\\n a = tau_s + tau_p\\n b = tau_s - tau_p\\n c = 2 * np.sqrt(tau_s * tau_p)\\n mat = np.array([[a, b, 0, 0],\\n [b, a, 0, 0],\\n [0, 0, c, 0],\\n [0, 0, 0, c]])\\n return 0.5 * mat\",\n \"def forward(self, input):\\n assert len(input.size()) == 4\\n self.input_height = input.size()[-2]\\n self.input_width = input.size()[-1]\\n self.get_matrix()\\n return DWTFunction_2D_tiny.apply(input, self.matrix_low_0, self.matrix_low_1, self.matrix_high_0, self.matrix_high_1)\",\n \"def TNFR1_to_SecondaryComplex_Alternate():\\n \\n Parameter('TNFa_0' , 000) # 6000 corresponds to 100ng/ml TNFa\\n Parameter('TNFR1_0' , 4800) # 4800 receptors per cell\\n Parameter('TRADD_0' , 9000) # molecules per cell (arbitrarily assigned) 9000\\n Parameter('RIP1_0' , 12044) # molecules per cell (arbitrarily assigned) 12044\\n Parameter('CompI_0' , 0) # complexes per cell\\n Parameter('NFkB_0' , 0) # molecules per cell\\n alias_model_components()\\n \\n Initial(TNFa(blig=None), TNFa_0) # TNFa Ligand\\n Initial(TNFR1(blig=None, bDD=None, state='norm'), TNFR1_0) # TNFR1\\n Initial(TRADD(bDD1=None, bDD2=None, state='inactive'), TRADD_0) # TRADD\\n Initial(CompI(bDD=None, state='unmod'), CompI_0) # Complex I\\n Initial(RIP1(bDD=None, bRHIM = None, bPARP = None, state = 'unmod'), RIP1_0) # RIP1\\n Initial(NFkB(bf=None), NFkB_0)\\n \\n # =========================================\\n # TNFR1 ligation, formation of Complex I and release of RIP1 and TRADD rules\\n # -----------------------------------------\\n # TNFa+ TNFR1 <-> TNFa:TNFR1\\n # TNFa:TNFR1 + TRADD <-> TNFa:TNFR1:TRADD >> CompI\\n # CompI + RIP1 <-> CompI:RIP1 >> [active]CompI:RIP1-Ub\\n # CompI + RIP1-Ub <-> CompI:RIP1-Ub\\n \\n # [active]CompI:RIP1-Ub >> NFkB # This reaction will consume the receptor.\\n # [active]CompI:RIP1-Ub >> [active]CompI:RIP1\\n # [active]CompI:RIP1 >> [active]CompI # A20 mediated degradation of RIP1\\n # [active]CompI:RIP1 >> [active]CompI + RIP1\\n # [active]CompI >> [active]TRADD + [norm]TNFR1 #receptor recycle typically distroys the ligand.\\n \\n # RIP1 >> RIP1-Ub #These reactions were added because Doug Green reported that FADD and RIP1 bind\\n # RIP1-Ub >> RIP1 #independently of receptor, and FADD:RIP1 formation leads to Caspase 8 activation.\\n #These reaction decrease the amount of RIP1 by spontaneously ubiquitinating it.\\n \\n # ------------------------------------------\\n \\n # -------------Complex I assembly----------------\\n bind(TNFa(blig=None), 'blig', TNFR1(blig=None, bDD=None, state='norm'), 'blig', [2e-7, 1e-4])\\n bind(TNFR1(blig = ANY, bDD = None, state = 'norm'), 'bDD', TRADD(bDD1=None, bDD2=None, state='inactive'), 'bDD1', [1e-6, 0.2])\\n preCompI = TNFa(blig=ANY)%TNFR1(blig=ANY, bDD=ANY, state = 'norm')%TRADD(bDD1 = ANY, bDD2=None, state = 'inactive')\\n Rule('CompI_formation', preCompI >> CompI(bDD=None, state = 'unmod'), Parameter('k2', 1))\\n \\n # --------------Complex I - RIP1 Modification-----------------\\n # Complex I recruits RIP1\\n bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='unmod'), 'bDD',[1e-6, 1e-3])\\n #bind(CompI(bDD=None, state = 'unmod'), 'bDD', RIP1(bDD=None, bRHIM = None, state='ub'), 'bDD',[1e-6, 1e-3])\\n \\n # Complex I undergos modifications (e.g. Ubiquitination) and elicits NFkB signaling\\n Rule('CompI_Ub', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'unmod')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), Parameter('k3', 1))\\n #Rule('CompI_Ub2', CompI(bDD=ANY, state = 'unmod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub'), Parameter('k4', 1))\\n Rule('NFkB_signaling', CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub')>> CompI(bDD=ANY, state = 'mod')%RIP1(bDD=ANY,bRHIM=None, state = 'ub') + NFkB(bf=None), Parameter('k5', 1))\\n \\n # De-ubiquitination and degradation or release of RIP1 from complex I\\n Rule('CompI_deUb', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub')>>CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None,state='deub'), Parameter('k6',1e-3))\\n \\n Rule('RIP1_deg', CompI(bDD=ANY, state='mod')%RIP1(bDD=ANY, bRHIM=None, state='ub') >> CompI(bDD=None, state='mod'), Parameter('k7',1))\\n \\n bind(CompI(bDD=None, state='mod'), 'bDD', RIP1(bDD=None, bRHIM = None, state = 'deub'), 'bDD', [1e-10,1])\\n \\n # Receptor recycle\\n Rule('TNFR1_recycle', CompI(bDD=None, state='mod') >> TRADD(bDD1=None, bDD2 = None, state='active') + TNFR1(blig = None, bDD = None, state = 'norm'), Parameter('k8',1e-3))\\n \\n # --------------RIP1 Ubiquitination---------------------------\\n Rule('RIP1_Ub', RIP1(bDD=None, bRHIM = None, state='unmod')>> RIP1(bDD=None, bRHIM = None, state='ub'), Parameter('k9', 1e-7))\",\n \"def test_transpile_differentiable(self):\\n dev = qml.device(\\\"default.qubit\\\", wires=3)\\n\\n def circuit(parameters):\\n qml.RX(parameters[0], wires=0)\\n qml.RY(parameters[1], wires=1)\\n qml.CNOT(wires=[0, 2])\\n qml.PhaseShift(parameters[2], wires=0)\\n return qml.expval(qml.PauliZ(0))\\n\\n transpiled_circ = transpile(coupling_map=[(0, 1), (1, 2)])(circuit)\\n transpiled_qnode = qml.QNode(transpiled_circ, dev, interface=\\\"autograd\\\")\\n params = np.array([0.5, 0.1, 0.2], requires_grad=True)\\n qml.gradients.param_shift(transpiled_qnode)(params)\",\n \"def material_matrix(self):\\n out = Tmatrix()\\n out.translate(Vector([.5, .5, .5]))\\n out.scale(Vector([self.radius, self.radius, self.radius]) *\\n (.5 / (self.radius + self.thickness)))\\n return out\",\n \"def system_1dof(w, t):\\n x1, y1 = w\\n # Create f = (x1',y1')\\n f = [y1,\\n (-k*x1 - k3*x1**3)/M]\\n return f\",\n \"def t2u( self , t ):\\n \\n # Input of closed-loop global sys is ref of the controller\\n u = self.controller.t2r(t)\\n \\n return u\",\n \"def test_trotter_hamiltonian_scalar_mul(nqubits=3):\\n local_ham = hamiltonians.TFIM(nqubits, h=1.0, dense=False)\\n target_ham = 2 * hamiltonians.TFIM(nqubits, h=1.0)\\n local_dense = (2 * local_ham).dense\\n K.assert_allclose(local_dense.matrix, target_ham.matrix)\\n\\n local_ham = hamiltonians.TFIM(nqubits, h=1.0, dense=False)\\n local_dense = (local_ham * 2).dense\\n K.assert_allclose(local_dense.matrix, target_ham.matrix)\",\n \"def stoichiometry(self, fluid):\\n air = self.air_alias.val\\n fuel = self.fuel_alias.val\\n flue_gas = self.fuel_alias.val + '_fg'\\n\\n ###################################################################\\n # calculate fuel and air mass flow\\n m_fuel = 0\\n for i in self.inl:\\n m_fuel += i.m.val_SI * i.fluid.val[fuel]\\n\\n m_air = 0\\n for i in self.inl:\\n m_air += i.m.val_SI * i.fluid.val[air]\\n\\n m_air_min = self.air_min * m_fuel\\n\\n ###################################################################\\n # calculate lambda if not specified\\n if not self.lamb.is_set:\\n self.lamb.val = m_air / (self.air_min * m_fuel)\\n\\n ###################################################################\\n # calculate excess fuel if lambda is smaller than 1\\n m_fuel_exc = 0\\n if self.lamb.val < 1:\\n m_fuel_exc = m_fuel - m_air / (self.lamb.val * self.air_min)\\n\\n ###################################################################\\n # equation for air\\n if fluid == air:\\n if self.lamb.val >= 1:\\n dm = -m_air_min\\n else:\\n dm = -m_air\\n\\n ###################################################################\\n # equation for fuel\\n elif fluid == fuel:\\n dm = -(m_fuel - m_fuel_exc)\\n\\n ###################################################################\\n # equation for flue gas\\n elif fluid == flue_gas:\\n dm = m_air_min + m_fuel\\n\\n ###################################################################\\n # equation for other components\\n else:\\n dm = 0\\n\\n res = dm\\n for i in self.inl:\\n res += i.fluid.val[fluid] * i.m.val_SI\\n for o in self.outl:\\n res -= o.fluid.val[fluid] * o.m.val_SI\\n return res\",\n \"def mixing_matrix_2nu(sth):\\n cth = sqrt(1.0-sth*sth)\\n\\n U00 = cth\\n U01 = sth\\n U10 = -sth\\n U11 = cth\\n\\n return [[U00,U01],[U10,U11]]\",\n \"def getScalarFlux(self):\\n totScalarFlux = []\\n for cell in self.cells:\\n totScalarFlux.append(cell.getTotScalarFlux())\\n totScalarFlux = np.array(totScalarFlux)\\n #return totScalarFlux / np.sum(totScalarFlux) # norm flux to 1.\\n return totScalarFlux\",\n \"def mounting_matrix(self):\\n # fmt: off\\n count = 0\\n for x in range(self.ntheta):\\n self.M[count][count] = 1\\n self.f[count][0] = self.p_in\\n count = count + self.nz - 1\\n self.M[count][count] = 1\\n self.f[count][0] = self.p_out\\n count = count + 1\\n count = 0\\n for x in range(self.nz - 2):\\n self.M[self.ntotal - self.nz + 1 + count][1 + count] = 1\\n self.M[self.ntotal - self.nz + 1 + count][self.ntotal - self.nz + 1 + count] = -1\\n count = count + 1\\n count = 1\\n j = 0\\n for i in range(1, self.nz - 1):\\n a = (1 / self.dtheta ** 2) * (self.c1[i][self.ntheta - 1])\\n self.M[count][self.ntotal - 2 * self.nz + count] = a\\n b = (1 / self.dz ** 2) * (self.c2[i - 1, j])\\n self.M[count][count - 1] = b\\n c = -((1 / self.dtheta ** 2) * ((self.c1[i][j]) + self.c1[i][self.ntheta - 1])\\n + (1 / self.dz ** 2) * (self.c2[i][j] + self.c2[i - 1][j]))\\n self.M[count, count] = c\\n d = (1 / self.dz ** 2) * (self.c2[i][j])\\n self.M[count][count + 1] = d\\n e = (1 / self.dtheta ** 2) * (self.c1[i][j])\\n self.M[count][count + self.nz] = e\\n count = count + 1\\n count = self.nz + 1\\n for j in range(1, self.ntheta - 1):\\n for i in range(1, self.nz - 1):\\n a = (1 / self.dtheta ** 2) * (self.c1[i, j - 1])\\n self.M[count][count - self.nz] = a\\n b = (1 / self.dz ** 2) * (self.c2[i - 1][j])\\n self.M[count][count - 1] = b\\n c = -((1 / self.dtheta ** 2) * ((self.c1[i][j]) + self.c1[i][j - 1])\\n + (1 / self.dz ** 2) * (self.c2[i][j] + self.c2[i - 1][j]))\\n self.M[count, count] = c\\n d = (1 / self.dz ** 2) * (self.c2[i][j])\\n self.M[count][count + 1] = d\\n e = (1 / self.dtheta ** 2) * (self.c1[i][j])\\n self.M[count][count + self.nz] = e\\n count = count + 1\\n count = count + 2\\n count = 1\\n for j in range(self.ntheta - 1):\\n for i in range(1, self.nz - 1):\\n if j == 0:\\n self.f[count][0] = (self.c0w[i][j] - self.c0w[i][self.ntheta - 1]) / self.dtheta\\n else:\\n self.f[count][0] = (self.c0w[i, j] - self.c0w[i, j - 1]) / self.dtheta\\n count = count + 1\\n count = count + 2\\n # fmt: on\",\n \"def magnetic_tension(self, method='spectral'):\\n import numpy as np\\n gradB, B = self.magnetic_gradient_tensor(method=method, return_B=True)\\n F = np.zeros_like(B)\\n for i in range(3):\\n for j in range(3):\\n F[j] += B[i] * gradB[i,j]\\n return F\",\n \"def ofdm_demodulate(sys_parameters, waveform_info, tx_wave):\\n # Get dimensionality information derived from the system parameters\\n waveform_info.set_info(sys_parameters)\\n # Cache the main dims\\n nsc = waveform_info.nsubcarriers\\n nfft = waveform_info.nfft\\n cp_lengths = waveform_info.cyclic_prefix_lengths\\n symbols_per_slot = waveform_info.symbols_per_slot\\n # Use numpy.array to express the rxWaveform\\n rxwave = np.array(tx_wave)\\n rxant = np.shape(rxwave)[1]\\n rx_grid = np.zeros((nsc, symbols_per_slot, rxant), dtype=complex)\\n # Calculate position of the first active subcarrier in the FFT output,\\n # according to the FFT size and the number of active subcarriers\\n first_activesc = int((nfft - nsc) / 2)\\n # Demodulate all symbols within the input data\\n cpres = cp_lengths[0] - cp_lengths[1]\\n # The same as the MATLAB operation : rxwave[0:cpres, :] = []\\n rxwave = np.delete(rxwave, range(cpres), 0)\\n rxwave = np.reshape(rxwave, (-1, symbols_per_slot, rxant), order=\\\"F\\\")\\n # The same as the MATLAB operation : rxwave[0:cp_lengths[1], :, :] = []\\n rxwave = np.delete(rxwave, range(cp_lengths[1]), 0)\\n for symbol in range(symbols_per_slot):\\n for rr in range(rxant):\\n in_list = rxwave[:, symbol, rr]\\n # rxwave is the numpy.array, just div the value\\n fft_output = spy.fftpack.fftshift(spy.fft.fft(in_list)) / math.sqrt(nfft)\\n rx_grid[:, symbol, rr] = fft_output[first_activesc : (first_activesc + nsc)]\\n return rx_grid\",\n \"def F_trans(self):\\n rho_H1 = self.edp_par['rho_H1'].value\\n Z_H1 = self.edp_par['Z_H1'].value\\n sigma_H1 = self.edp_par['sigma_H1'].value\\n rho_M = self.edp_par['rho_M'].value\\n sigma_M = self.edp_par['sigma_M'].value\\n psi = self.edp_par['psi'].value \\n common_scale = self.edp_par['common_scale'].value\\n \\n # Calculate the intermediate variables\\n alpha = self.qz*cos(psi) - self.qx*sin(psi)\\n Z_CH2 = Z_H1 - sigma_H1\\n Z_W = Z_H1 + sigma_H1\\n DeltaZ_H = Z_W - Z_CH2\\n \\n # Calculate the Gaussian part \\n FG = -rho_M*sigma_M * exp(-0.5*(alpha*sigma_M)**2)\\n FG += 2*rho_H1*sigma_H1 * cos(alpha*Z_H1) * exp(-0.5*(alpha*sigma_H1)**2)\\n FG *= np.sqrt(2*pi)\\n \\n # Calculate the strip part\\n FS = -2 * sin(alpha*Z_CH2) / alpha\\n \\n # Calculate the bridging part\\n FB = 1 / (alpha + pi/DeltaZ_H)\\n FB += 1 / (alpha - pi/DeltaZ_H)\\n FB *= sin(alpha*Z_W) + sin(alpha*Z_CH2)\\n FB *= 0.5\\n FB -= (sin(alpha*Z_W)-sin(alpha*Z_CH2)) / alpha\\n \\n return common_scale * (FG + FS + FB)\",\n \"def getTrMatricesController(self):\\n\\t\\treturn self.trMatricesController\",\n \"def ttd_u_func(self):\\n T_i1 = T_mix_ph(self.inl[0].to_flow(), T0=self.inl[0].T.val_SI)\\n T_o2 = T_mix_ph(self.outl[1].to_flow(), T0=self.outl[1].T.val_SI)\\n return self.ttd_u.val - T_i1 + T_o2\",\n \"def T(self):\\n self = +self\\n ret = Matr()\\n for hcolp in range(len(self.header)):\\n ret.append(Matr())\\n for row in range(len(self)):\\n ret[hcolp].append(self[row,hcolp])\\n return ret\",\n \"def setup_t_matrix(dq_W_E_vec, dq_B_H_vec):\\n n_quaternions = len(dq_W_E_vec)\\n t_matrix = np.zeros([6 * n_quaternions, 8])\\n for i in range(n_quaternions):\\n t_matrix[i * 6:i * 6 + 6, :] = setup_s_matrix(dq_W_E_vec[i], dq_B_H_vec[i])\\n\\n rank_t_matrix = np.linalg.matrix_rank(t_matrix, tol=5e-2)\\n U, s, V = np.linalg.svd(t_matrix)\\n # print(\\\"t_matrix: \\\\n{}\\\".format(t_matrix))\\n # print(\\\"Rank(t_matrix): {}\\\".format(rank_t_matrix))\\n # assert rank_t_matrix == 6, (\\\"T should have rank 6 otherwise we can not find \\\"\\n # \\\"a rigid transform.\\\", rank_t_matrix, s)\\n return t_matrix.copy()\",\n \"def flux_hack(self):\\r\\n return self.planes[1].galaxies[0].light_profiles[0].flux\",\n \"def Tt(self, M):\\r\\n # Section 1: if a 1D array, convert to a 2D array = matrix\\r\\n if not isinstance(M[0], list):\\r\\n M = [M]\\r\\n \\r\\n # Section 2: Get dimensions\\r\\n rows = len(M)\\r\\n cols = len(M[0])\\r\\n \\r\\n # Section 3: MT is zeros matrix with transposed dimensions\\r\\n MT = self.zeros_matrix(cols, rows)\\r\\n \\r\\n # Section 4: Copy values from M to it's transpose MT\\r\\n for i in range(rows):\\r\\n for j in range(cols):\\r\\n MT[j][i] = M[i][j]\\r\\n \\r\\n return MT\",\n \"def _unsqueeze_ft(tensor):\\n return tensor.unsqueeze(0).unsqueeze(-1)\",\n \"def test_trotter_hamiltonian_scalar_sub(nqubits=3):\\n local_ham = hamiltonians.TFIM(nqubits, h=1.0, dense=False)\\n target_ham = 2 - hamiltonians.TFIM(nqubits, h=1.0)\\n local_dense = (2 - local_ham).dense\\n K.assert_allclose(local_dense.matrix, target_ham.matrix)\\n\\n target_ham = hamiltonians.TFIM(nqubits, h=1.0) - 2\\n local_ham = hamiltonians.TFIM(nqubits, h=1.0, dense=False)\\n local_dense = (local_ham - 2).dense\\n K.assert_allclose(local_dense.matrix, target_ham.matrix)\",\n \"def DFT2(image):\\n full_dft2 = DFT(DFT(image.transpose()).transpose())\\n return full_dft2.astype(np.complex128)\",\n \"def restom(fsnt, flnt):\\n var = fsnt - flnt\\n var.long_name = \\\"TOM(top of model) Radiative flux\\\"\\n return var\",\n \"def _mat3(self):\\n if self.frame.orientation == HillFrame.DEFAULT_ORIENTATION:\\n return np.identity(3)\\n else:\\n return self.QSW2TNW\",\n \"def NMF(X,r):\\n nmf_mdl = nmf.NMF(X,num_bases=r)\\n nmf_mdl.initialization()\\n nmf_mdl.factorize()\\n return nmf_mdl.W,nmf_mdl.H,np.dot(nmf_mdl.W,nmf_mdl.H)\",\n \"def GetTransform(self, *args) -> \\\"itkTransformD22 *\\\":\\n return _itkTransformMeshFilterPython.itkTransformMeshFilterMF2MF2TD22_GetTransform(self, *args)\",\n \"def computeTransitionMatrix(self, mu = False):\\n\\n available_strategies = self.getAvailableStrategies()\\n t_matrix = np.matrix([[0. for strategy in available_strategies] for strategy in available_strategies])\\n\\n for i, resident in enumerate(available_strategies):\\n for j, invader in enumerate(available_strategies):\\n if (i != j):\\n fixation_proba = self.rho(resident, invader)\\n if(mu):\\n fixation_proba *= self.getExplorationRate()\\n t_matrix[i, j] = 1./(len(available_strategies) - 1) * fixation_proba\\n\\n # calculate diagonal elements\\n for i in range(len(available_strategies)):\\n t_matrix[i, i] = 1 - t_matrix[i].sum(axis = 1)\\n\\n return t_matrix\",\n \"def __call__(self, t, u):\\n \\n # Rename to skip the self.\\n f_rate = self.f; w_hat = self.w_hat;\\n Ux = self.Ux; nx = self.nx;\\n\\n _u = u.reshape((nx,nx)) # To Matrix\\n\\n # FFT of firing rate at u\\n f_u = f_rate(_u)\\n f_hat = fft2(f_u) # 2D fft of matrix\\n\\n p_prod = np.real( ifft2(f_hat*w_hat) ) # Pointwise product of matrices\\n shift = ((2*Ux/nx)**2)*ifftshift(p_prod) # Shift result\\n F = - _u + shift\\n return F.flatten()\",\n \"def mat_vec_product(self, psi, t):\\n\\tx = zeros(self.vib_basis_size * len(self.my_tasks), dtype = complex)\\n\\n\\t#Matrix vector product.\\n\\tfor i, j in enumerate(self.my_tasks):\\n\\t slice_x = slice(i * self.vib_basis_size, (i + 1) * self.vib_basis_size)\\n\\t slice_psi = slice(j * self.vib_basis_size, (j + 1) * self.vib_basis_size)\\n\\t \\n\\t x[slice_x] = dot(self.h_0[:,:,i], psi[slice_psi])\\n\\t\\n\\ty = dot(self.h_1, psi)\\n\\n\\t#Weigh with field strength, and add components.\\n\\tpsi_final = x + self.time_function(t) * y\\n\\t\\n\\treturn psi_final\",\n \"def matrix(self):\\n # group the observables based on what wires they act on\\n U_list = []\\n for _, g in itertools.groupby(self.obs, lambda x: x.wires):\\n # extract the matrices of each diagonalizing gate\\n mats = [i.matrix for i in g]\\n\\n if len(mats) > 1:\\n # multiply all unitaries together before appending\\n mats = [multi_dot(mats)]\\n\\n # append diagonalizing unitary for specific wire to U_list\\n U_list.append(mats[0])\\n\\n # Return the Hermitian matrix representing the observable\\n # over the defined wires.\\n return functools.reduce(np.kron, U_list)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5768485","0.56176883","0.5443617","0.5435858","0.5388646","0.53567904","0.53567904","0.53390956","0.52819616","0.52702206","0.52634484","0.5213695","0.5176987","0.51402587","0.50595313","0.50586605","0.5050682","0.5046748","0.5044931","0.49993876","0.49939686","0.49690545","0.49624658","0.49510902","0.49433377","0.4930863","0.49196053","0.49120638","0.49060327","0.4896213","0.48959813","0.4893079","0.48840934","0.48834547","0.48789632","0.48766991","0.48717266","0.48717266","0.4863618","0.48599446","0.48592153","0.4856911","0.48519152","0.48501647","0.48440582","0.4834536","0.4827891","0.4809206","0.48000163","0.47929537","0.47803447","0.47772387","0.47728994","0.47606435","0.47543725","0.47440267","0.47420892","0.47396326","0.47392967","0.47384897","0.47308284","0.47305048","0.47234342","0.47228205","0.47222376","0.4719765","0.471584","0.47154832","0.47131377","0.47125337","0.47123992","0.47109163","0.47088924","0.4699743","0.46993038","0.4697494","0.46940583","0.4691583","0.46818328","0.4679686","0.4679369","0.46764395","0.46735275","0.46691906","0.46663895","0.4665348","0.46652117","0.46616453","0.4654346","0.46539068","0.46477082","0.46407104","0.4637544","0.46362576","0.46337327","0.46329418","0.46321785","0.46299884","0.4625311","0.46242252"],"string":"[\n \"0.5768485\",\n \"0.56176883\",\n \"0.5443617\",\n \"0.5435858\",\n \"0.5388646\",\n \"0.53567904\",\n \"0.53567904\",\n \"0.53390956\",\n \"0.52819616\",\n \"0.52702206\",\n \"0.52634484\",\n \"0.5213695\",\n \"0.5176987\",\n \"0.51402587\",\n \"0.50595313\",\n \"0.50586605\",\n \"0.5050682\",\n \"0.5046748\",\n \"0.5044931\",\n \"0.49993876\",\n \"0.49939686\",\n \"0.49690545\",\n \"0.49624658\",\n \"0.49510902\",\n \"0.49433377\",\n \"0.4930863\",\n \"0.49196053\",\n \"0.49120638\",\n \"0.49060327\",\n \"0.4896213\",\n \"0.48959813\",\n \"0.4893079\",\n \"0.48840934\",\n \"0.48834547\",\n \"0.48789632\",\n \"0.48766991\",\n \"0.48717266\",\n \"0.48717266\",\n \"0.4863618\",\n \"0.48599446\",\n \"0.48592153\",\n \"0.4856911\",\n \"0.48519152\",\n \"0.48501647\",\n \"0.48440582\",\n \"0.4834536\",\n \"0.4827891\",\n \"0.4809206\",\n \"0.48000163\",\n \"0.47929537\",\n \"0.47803447\",\n \"0.47772387\",\n \"0.47728994\",\n \"0.47606435\",\n \"0.47543725\",\n \"0.47440267\",\n \"0.47420892\",\n \"0.47396326\",\n \"0.47392967\",\n \"0.47384897\",\n \"0.47308284\",\n \"0.47305048\",\n \"0.47234342\",\n \"0.47228205\",\n \"0.47222376\",\n \"0.4719765\",\n \"0.471584\",\n \"0.47154832\",\n \"0.47131377\",\n \"0.47125337\",\n \"0.47123992\",\n \"0.47109163\",\n \"0.47088924\",\n \"0.4699743\",\n \"0.46993038\",\n \"0.4697494\",\n \"0.46940583\",\n \"0.4691583\",\n \"0.46818328\",\n \"0.4679686\",\n \"0.4679369\",\n \"0.46764395\",\n \"0.46735275\",\n \"0.46691906\",\n \"0.46663895\",\n \"0.4665348\",\n \"0.46652117\",\n \"0.46616453\",\n \"0.4654346\",\n \"0.46539068\",\n \"0.46477082\",\n \"0.46407104\",\n \"0.4637544\",\n \"0.46362576\",\n \"0.46337327\",\n \"0.46329418\",\n \"0.46321785\",\n \"0.46299884\",\n \"0.4625311\",\n \"0.46242252\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6433278"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":809,"numItemsPerPage":100,"numTotalItems":95772,"offset":80900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjE5NzI4NCwianRpIjoiYTVjNzdmZTUtODM3YS00ZWNiLTliZWMtZWQ0ZGRiN2NkMDg1Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYyMDA4ODQsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.-XkcP1fTtHzlVDGIWU7cTcv6I86Hhyy_CpCDg2MV8qMkzzCYnQ8lnWALsO2QYdH8ipsTDyUkWBvtP-rY3jHcBQ","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 |
|---|---|---|---|---|---|---|
Function at the heart of RCTorch, train a network on multiple rounds of crossvalidated train/test info, then return the average error. This method also deals with dispatching mutliple series to the objective function if there are multiple, and aggregates the returned scores by averaging. | def execute_objective(arguments):
#later call define_tr_val from within this function for speedup.
#score, pred_ = self.define_tr_val() #just get the train and test...
cv_samples, parallel_arguments, parameters, windowsOS, id_ = arguments
device = parallel_arguments["device"]
declaration_args ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def error(clf, X, y, ntrials=100, test_size=0.2) :\n\n train_error = 0\n test_error = 0\n ### ========== TODO : START ========== ###\n # compute cross-validation error over ntrials\n # hint: use train_test_split (be careful of the parameters)\n for i in range(0,ntrials, 1):\n #get the valu... | [
"0.68135214",
"0.6388464",
"0.6343493",
"0.6326529",
"0.6313902",
"0.627731",
"0.61531216",
"0.61406094",
"0.61087924",
"0.61046493",
"0.60904646",
"0.6060501",
"0.6038475",
"0.6031496",
"0.60128665",
"0.59967685",
"0.5974265",
"0.5957948",
"0.5951136",
"0.5942197",
"0.593980... | 0.0 | -1 |
Makes sure all bounds feeded into GPyOpt are scaled to the domain [0, 1], to aid interpretation of convergence plots. Scalings are saved in instance parameters. | def normalize_bounds(self, bounds):
scaled_bounds = []
scalings = []
intercepts = []
non_fixed_params = []
print(self.device)
for name, domain in self.bounds.items():
# Get any fixed parmeters
if type(domain) == int or ty... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def myscale(g, factor=1.0):\n g.setdata(factor * g.getdata())\n # if !g.frozen eq 0 then show",
"def scale(self):\n return self._gev_bijector.scale",
"def setup(self):\n if self.minimizer == \"shgo\":\n self._maxiter = 100\n else:\n self._maxiter = 1000\n if ... | [
"0.6217774",
"0.6106262",
"0.6076442",
"0.5966637",
"0.5942933",
"0.58166665",
"0.58008057",
"0.5660049",
"0.5658421",
"0.5655743",
"0.56344235",
"0.560839",
"0.5578738",
"0.55561835",
"0.5530794",
"0.5524495",
"0.55209935",
"0.5518806",
"0.5510932",
"0.55013424",
"0.54777133... | 0.62791705 | 0 |
Denormalize arguments to feed into model. | def denormalize_bounds(self, normalized_arguments):
denormalized_bounds = (normalized_arguments * self.bound_scalings) + self.bound_intercepts
return denormalized_bounds | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize_args(self, args):\n return args",
"def normalize_args(self, args):\n return self.metagraph.normalize_args(args)",
"def normalize_args(self, args):\n if self._graph.flags.get('ignore_values', False):\n return tuple(_broaden(a, None) for a in args)\n else:\n ... | [
"0.6972853",
"0.6739494",
"0.66210634",
"0.6308798",
"0.6176821",
"0.6088814",
"0.6049809",
"0.5997373",
"0.58216965",
"0.5803196",
"0.57827723",
"0.57243264",
"0.5687452",
"0.56658936",
"0.56447923",
"0.5638549",
"0.5606782",
"0.55959255",
"0.5544403",
"0.5543355",
"0.551334... | 0.0 | -1 |
Constructs arguments for ESN input from input array. Does so by denormalizing and adding arguments not involved in optimization, like the random seed. | def construct_arguments(self, x):
# Denormalize free parameters
denormalized_values = self.denormalize_bounds(x)
arguments = dict(zip(self.free_parameters, denormalized_values.flatten()))
self.log_vars = ['connectivity', 'llambda', 'llambda2', 'enet_strength',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, total_args):\n\t\tself.alpha = 0.0\n\t\tself.salida = 0.0\n\t\tself.bias = pseudoaleatorio(-1.0, 1.0)\n\t\tself.pesos = []\n\t\tfor i in range(total_args):\n\t\t\tself.pesos.append(pseudoaleatorio(-1.0, 1.0))",
"def __init__(self,nback=1,ntokens_pm=2,ntokens_og=3,stimdim=2,seed=99):\n np.ra... | [
"0.5619324",
"0.5593154",
"0.5440737",
"0.53112406",
"0.52345806",
"0.5231647",
"0.5197095",
"0.51924103",
"0.5169906",
"0.5167056",
"0.516215",
"0.51010704",
"0.5099438",
"0.50905585",
"0.5081436",
"0.50773704",
"0.50709444",
"0.5070725",
"0.506674",
"0.5065923",
"0.50571764... | 0.55122995 | 2 |
Validates inputted data against errors in shape and common mistakes. | def validate_data(self, y, x=None, verbose=True):
# Check dimensions
if not self.ODE_order:
if not y.ndim == 2:
raise ValueError("y-array is not 2 dimensional, if ODE and you didn't provide y then x is one dim")
if verbose and y.shape[0] < y.shape[1]:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_input(self):\n self._validate_limits_cols_prefixed()\n self._validate_fillna_cols_prefixed()\n self._validate_ratio_input()",
"def check_dims(self, data):\n if np.ndim(data) != 2:\n raise ValueError('Input data must be a two dimensional numpy array. '\n ... | [
"0.72307163",
"0.72123903",
"0.7099669",
"0.70848185",
"0.7062611",
"0.7045674",
"0.70427585",
"0.703525",
"0.7020206",
"0.69853604",
"0.695262",
"0.6923969",
"0.691496",
"0.69091976",
"0.69005466",
"0.68764365",
"0.6875079",
"0.6870377",
"0.68641317",
"0.68603855",
"0.683775... | 0.6397586 | 54 |
Returns selected error metric on validation set. | def objective_function(self, parameters, train_y, validate_y, train_x=None, validate_x=None, random_seed=None):
arguments = self.construct_arguments(self.range_bounds)
# Build network
esn = self.model(**arguments, activation_f = self.activation_function,
plot = False, model_typ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def yerr(self, i):\n return self.errors[1][i]",
"def compute_fit_error(self, metric='MSE'):\n\n I = self.I.flatten()\n E = self.E.flatten()\n\n valid_matrics = {\n 'EVAR': explained_variance_score(I, E),\n 'MAE': mean_absolute_error(I, E),\n 'MSE': mea... | [
"0.60175335",
"0.5955407",
"0.59338146",
"0.5866605",
"0.5799263",
"0.57727945",
"0.5667554",
"0.56660944",
"0.56454545",
"0.56128025",
"0.5590303",
"0.55492985",
"0.552297",
"0.54930365",
"0.5492552",
"0.5483789",
"0.5453669",
"0.54061",
"0.54022264",
"0.53941363",
"0.537540... | 0.0 | -1 |
Splits training sets (X, y) into train and validate sets, in order to later compute multiple samples of the objective function. | def define_tr_val(self, inputs):
####
#print("Hayden edit: parameters: " + str(parameters))
#print("Hayden edit: fixed parameters: " + str(self.fixed_parameters))
#print("Hayden edit: free parameters: " + str(self.free_parameters))
####
start_index, random_seed =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_train_valid_set(self):\n\n if not self.eq_train:\n X_train_high_level, X_valid_high_level, X_train_low_level, X_valid_low_level, train_w, valid_w, y_train, y_valid = train_test_split(self.X_train_high_level, self.X_train_low_level, self.train_weights, self.y_train,\n ... | [
"0.7453219",
"0.739912",
"0.7375244",
"0.73498577",
"0.71658945",
"0.7158523",
"0.71305346",
"0.70896065",
"0.7073784",
"0.7066556",
"0.7054637",
"0.7036253",
"0.6996273",
"0.6977518",
"0.6965935",
"0.69633704",
"0.6948049",
"0.69358677",
"0.6935264",
"0.69336563",
"0.6918491... | 0.0 | -1 |
This function builds a list of dictionairies with unique keys. | def build_unq_dict_lst(self, lst1, lst2, key1 = "start_index", key2 = "random_seed"):
dict_lst = []
for i in range(len(lst1)):
for j in range(len(lst2)):
dictt = {}
dictt[key1] = lst1[i]
dictt[key2] = lst2[j]
dict_lst.append(d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _unique(iterable):\n return list(dict.fromkeys(iterable))",
"def unique(list_: List) -> List:\n return list(collections.OrderedDict.fromkeys(list_))",
"def _uniq( list ) : \r\n \r\n d = {} \r\n for e in list : \r\n d[e] = 1 \r\n \r\n ... | [
"0.7014602",
"0.69492906",
"0.6941098",
"0.6885813",
"0.6830574",
"0.68287224",
"0.67020875",
"0.6599733",
"0.6556042",
"0.6383938",
"0.63837504",
"0.6295457",
"0.61819345",
"0.61736625",
"0.61508775",
"0.61295223",
"0.60576284",
"0.6056202",
"0.6035064",
"0.6012629",
"0.6012... | 0.5868322 | 31 |
Splits training set into train and validate sets, and computes multiple samples of the objective function. This method also deals with dispatching multiple series to the objective function if there are multiple, and aggregates the returned scores by averaging. | def objective_sampler(self):
# Get data
#self.parameters = parameters
training_y = self.y
training_x = self.x
# Set viable sample range
if not self.ODE_order:
#assert False
viable_start = self.esn_burn_in
# Get number of serie... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_eval(model, train_set):\n num_train_batch = len(train_set)\n train_loss = np.zeros((num_train_batch, 1), dtype=float)\n train_acc = np.zeros((num_train_batch, 1), dtype=float)\n shuffle(train_set)\n for ibatch, batch in enumerate(train_set):\n result = model.train_on_batch({'input':... | [
"0.6511949",
"0.64103603",
"0.6384507",
"0.63781327",
"0.6243873",
"0.62344897",
"0.62201923",
"0.6219357",
"0.6212692",
"0.61456156",
"0.61324656",
"0.61121434",
"0.6080425",
"0.60588187",
"0.6051341",
"0.6048353",
"0.6033012",
"0.59930754",
"0.5992074",
"0.5990621",
"0.5988... | 0.0 | -1 |
If you are running rctorch in a jupyter notebook then this function displays live plots so that you can watch training if self.interactive = True. | def train_plot_update(self, pred_, validate_y, steps_displayed, elastic_losses = None, restart_triggered = False):
if self.interactive:
display.clear_output(wait=True)
pred_2plot = pred_.detach().to("cpu")
if not self.ODE_order:
validate_y_2plot ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show(self) -> None:\n # if not called from notebook environment, ref to show_browser function.\n if not is_notebook():\n print(\n \"The plot will not show in a notebook environment, \"\n \"please try 'show_browser' if you want to open it in browser\",\n ... | [
"0.7196754",
"0.7054279",
"0.7005126",
"0.6878387",
"0.6878387",
"0.6878387",
"0.67734253",
"0.6766458",
"0.67658323",
"0.66961825",
"0.668899",
"0.66447586",
"0.6629516",
"0.662015",
"0.6619253",
"0.6552591",
"0.65489894",
"0.65204173",
"0.6483645",
"0.6473154",
"0.64325166"... | 0.0 | -1 |
This version of the RC helper function | def eval_objective(self, parameters, plot_type = "error", *args):
# parameter_lst = []
# for i in range(parameters.shape[0]):
# parameter_lst.append(self.construct_arguments(parameters[i, :]))
parameter_lst = [self.construct_arguments(parameters[i, :]) for i in range(parameters.sha... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cx():",
"def _regr_basic():",
"def CL(self):",
"def test_rc(self):\n # no longer preserves case!\n self.assertEqual(self.RNA(\"UauCG-NR\").rc(), \"YN-CGAUA\")\n self.assertEqual(self.DNA(\"TatCG-NR\").rc(), \"YN-CGATA\")\n self.assertEqual(self.RNA(\"\").rc(), \"\")\n s... | [
"0.5890724",
"0.58554274",
"0.56417525",
"0.5511166",
"0.5441391",
"0.54353964",
"0.5365056",
"0.5320655",
"0.53201157",
"0.51603585",
"0.51603585",
"0.51603585",
"0.51603585",
"0.51603585",
"0.5128818",
"0.51230246",
"0.512259",
"0.5111368",
"0.50806105",
"0.50806105",
"0.50... | 0.0 | -1 |
Performs optimization (with crossvalidation). Uses Bayesian Optimization with Gaussian Process priors to optimize ESN hyperparameters. | def optimize(self, y = None, x=None, store_path=None, epochs = 25, learning_rate = 0.005, scoring_method = "mse", criterion = MSELoss(),
reparam_f = None, ODE_criterion = None, init_conditions = None, scale = True, force = None, backprop_f = None, backprop = False,
ode_coefs = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def perform_bayesian_optimization(self):\n bounds = {'hunits': (self.hunits_lower, self.hunits_upper),\n 'embedding_dim': (self.embedding_dim_lower, self.embedding_dim_upper)}\n optimizer = BayesianOptimization(f=self.lstm_score, pbounds=bounds, random_state=1)\n optimizer.max... | [
"0.66671604",
"0.64092016",
"0.61563504",
"0.61285573",
"0.6119044",
"0.60834605",
"0.595369",
"0.5945639",
"0.59206283",
"0.5905338",
"0.5868431",
"0.5819456",
"0.5809728",
"0.5799336",
"0.57908994",
"0.5787421",
"0.5764173",
"0.57335675",
"0.5727176",
"0.57238513",
"0.57206... | 0.0 | -1 |
bool int Position > Space Constructs an instance of Space. | def __init__(self, on_railroad, space_type, adjacent):
self.space_type = space_type
self.on_railroad = on_railroad
self.adjacent = adjacent | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_space(self):\n return self.pos == self.SPACE_POS",
"def create_space(self):\n schema = SpaceSchema()\n data = {'show': str(self.show_id), 'show_title': self.show_title, 'space': self.location_array}\n space_object = schema.load(data)\n return space_object",
"def test_exten... | [
"0.7008498",
"0.621807",
"0.59040236",
"0.5801304",
"0.56820416",
"0.5652077",
"0.5604434",
"0.5552117",
"0.5462722",
"0.54436535",
"0.54188234",
"0.5411768",
"0.5401182",
"0.53933203",
"0.53815204",
"0.53607225",
"0.5338166",
"0.5291468",
"0.5291468",
"0.5270642",
"0.5238398... | 0.49680564 | 55 |
> iter(Position) Returns a generator of positions that are adjacent to this space. | def __iter__(self):
return iter(self.adjacent) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iterate_adjacent(position):\n return iter(_board_graph[position])",
"def __iter__(self):\n for p in self.positions(): # use same order as positons()\n yield p.element() # but yield each element",
"def __iter__(self):\n for idx in range(0, self.Npoints):\n ... | [
"0.76649487",
"0.75231266",
"0.7464687",
"0.7459826",
"0.74092317",
"0.7372811",
"0.7335939",
"0.72174793",
"0.70786744",
"0.7071331",
"0.7003318",
"0.6992895",
"0.6963647",
"0.6930121",
"0.6862071",
"0.67932606",
"0.6783159",
"0.671852",
"0.66881925",
"0.66803485",
"0.654857... | 0.7284025 | 7 |
Position Position > bool Checks if the given 2 positions are adjacent to each other. | def is_adjacent(v1, v2):
return (v2 in _board_graph[v1]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_adjacent(self, other: ops.Qid) -> bool:\n return (isinstance(other, GridQubit) and\n abs(self.row - other.row) + abs(self.col - other.col) == 1)",
"def position_after(self, a, b):\n return self.position_at_least(a, b) and not self.position_equal(a, b)",
"def position_equal(self,... | [
"0.7033602",
"0.6725644",
"0.6643974",
"0.65933293",
"0.6528447",
"0.64954203",
"0.6453956",
"0.64282835",
"0.6353031",
"0.6318262",
"0.6318167",
"0.6300374",
"0.6295051",
"0.62813294",
"0.62813294",
"0.6238177",
"0.62184185",
"0.61997527",
"0.61897445",
"0.6187568",
"0.61638... | 0.6871998 | 1 |
Position > bool Checks if the give position is a camp | def is_camp(p):
return _board_graph[p].space_type == CAMP | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __bool__(self):\n return (self.value == POS)",
"def is_position_availible(self, position):\n return self.positions[position] == ' '",
"def check_position(self, position):\n x_axis, y_axis = position\n try:\n return bool(self.full_map[x_axis][y_axis] not in \"#\"\n ... | [
"0.64722383",
"0.64340055",
"0.64084136",
"0.63969594",
"0.6365744",
"0.6255603",
"0.61885136",
"0.6162032",
"0.6148545",
"0.6137229",
"0.6058347",
"0.6002783",
"0.5990171",
"0.59791565",
"0.59631646",
"0.591652",
"0.5893191",
"0.58920956",
"0.58592474",
"0.5839528",
"0.58370... | 0.6246878 | 6 |
Position > bool Checks if the given position is a headquarter | def is_headquarters(p):
return _board_graph[p].space_type == HEADQUARTERS | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_quarter_start(self) -> Index:\n return Index(self.to_series().dt.is_quarter_start)",
"def positionTerminale(position):\n if(position['graines']['NORD']>=25 or position['graines']['SUD']>=25): \n return True \n for a in range(1,position['taille']+1):\n if(coupAutorise(position... | [
"0.6647186",
"0.58659077",
"0.584978",
"0.57397217",
"0.5682148",
"0.5370651",
"0.5325137",
"0.53094614",
"0.5295059",
"0.5295059",
"0.52834874",
"0.5278531",
"0.52409405",
"0.5195752",
"0.51897436",
"0.5188449",
"0.51745075",
"0.5169134",
"0.51610446",
"0.5146895",
"0.514187... | 0.7563406 | 0 |
Position > iter(Position) Returns a generator of positions that are adjacent to the given position. | def iterate_adjacent(position):
return iter(_board_graph[position]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def adjacent(self):\r\n d = 0\r\n while d < 4:\r\n a = self.getAdjacent(d)\r\n if a is not None:\r\n yield a\r\n d += 1",
"def neighbor(self, position):\n if self.options['PeriOpt']:\n if position[0] == 0:\n yield (sel... | [
"0.7283339",
"0.69497603",
"0.69073117",
"0.6686512",
"0.6633959",
"0.653778",
"0.65283847",
"0.65235907",
"0.64112544",
"0.6366553",
"0.6237442",
"0.62248063",
"0.6151327",
"0.6106118",
"0.6073934",
"0.60611665",
"0.60321033",
"0.60217905",
"0.5955655",
"0.59550315",
"0.5945... | 0.7694504 | 0 |
> Generates all positions and their connection for the board. | def generate_board():
b = open(_BOARD_FILE, "r").readlines()
for line in b:
raw = line.strip().split(" ")
_board_graph[str_to_pos(raw[0])] = Space(
(raw[1] == "R"),
TYPE_MAP[raw[1]],
{str_to_pos(str_pos) for str_pos in raw[2:]}) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_board(self, size):\n # One entry for every node, if diamond all will be filled with pieces, if triange half of matrix including \n # diagonal from top left to bottom right will be filled\n self.board = [[False for i in range(size)] for j in range(size)] \n\n # One entry for every node pair (... | [
"0.6852624",
"0.6730391",
"0.6575972",
"0.6565264",
"0.6491741",
"0.64670163",
"0.6461841",
"0.63448685",
"0.6327465",
"0.62439626",
"0.6235739",
"0.61992",
"0.618114",
"0.6179558",
"0.6164701",
"0.6148134",
"0.6132428",
"0.6116731",
"0.6064113",
"0.60538304",
"0.6053184",
... | 0.61497575 | 15 |
Convert json response to entity. | def _convert_to_entity(entry_element):
entity = TableEntity()
properties = {}
edmtypes = {}
odata = {}
for name, value in entry_element.items():
if name.startswith("odata."):
odata[name[6:]] = value
elif name.endswith("@odata.type"):
edmtypes[name[:-11]] = v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_entities_handler(response):\n\n if response.status_code != HTTP_CODE_OK:\n raise HttpError('HTTP GET for Entity Set {0} failed with status code {1}'\n .format(self._name, response.status_code), response)\n\n content = response.json()\n\n return con... | [
"0.64894706",
"0.63945675",
"0.63127697",
"0.617892",
"0.60494703",
"0.60353273",
"0.5970655",
"0.59585863",
"0.58664626",
"0.58491504",
"0.58155817",
"0.5804504",
"0.5749443",
"0.5749443",
"0.5718962",
"0.5709732",
"0.5708076",
"0.57002693",
"0.5680176",
"0.5665328",
"0.5662... | 0.0 | -1 |
Extracts the etag from the response headers. | def _extract_etag(response):
if response and response.headers:
return response.headers.get("etag")
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def etag(self):\n return self.raw.get(\"etag\")",
"def getetag(self, path):\n etag = None\n instance = self.rdmc.app.monolith.path(path)\n if instance:\n etag = (\n instance.resp.getheader(\"etag\")\n if \"etag\" in instance.resp.getheaders()\n... | [
"0.7184431",
"0.6997888",
"0.6979557",
"0.6752053",
"0.6752053",
"0.6752053",
"0.6752053",
"0.6752053",
"0.6752053",
"0.6752053",
"0.67385346",
"0.66871834",
"0.66871834",
"0.66871834",
"0.66871834",
"0.66871834",
"0.66871834",
"0.66871834",
"0.66871834",
"0.66871834",
"0.668... | 0.83126473 | 0 |
Extract list entity continuation headers from token. | def _extract_continuation_token(continuation_token):
if not continuation_token:
return None, None
try:
return continuation_token.get("PartitionKey"), continuation_token.get("RowKey")
except AttributeError as exc:
raise ValueError("Invalid continuation token format.") from exc | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _retrieveContinuation(self, token):\n if token in self._continuations:\n _ignore_timestamp, things, kind = self._continuations[token]\n del self._continuations[token]\n else:\n things = None\n kind = None\n return things, kind",
"def parse_toke... | [
"0.5588204",
"0.53894943",
"0.52932835",
"0.5233644",
"0.519129",
"0.51626325",
"0.51218164",
"0.51026356",
"0.5056054",
"0.504202",
"0.50148374",
"0.5014546",
"0.49950254",
"0.49693838",
"0.49416015",
"0.49219742",
"0.48803505",
"0.48798403",
"0.48698643",
"0.4850413",
"0.48... | 0.60859376 | 0 |
Req 2 mapa de lps | def optionThree(catalog):
ans = controller.pointsInterconnection(catalog)
item_map = folium.Map(location=[25.557547, -24.568953], zoom_start=2)
for landinpoint in lt.iterator(ans[0]):
item = mp.get(catalog['landingpoints'], landinpoint)['value']['info']
print('Nombre:', item['id'], '\tLugar... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def intercambiar(mapa, mapa2):\n for e in mapa.bloqueadas:\n mapa2.bloqueadas.append(e)",
"def map():",
"def __getSimple(self):\n resp2={}\n for item in self.tesult: \n if item==self.RESPONSE:\n for item1 in self.response():\n ... | [
"0.5747746",
"0.5600041",
"0.5511264",
"0.54483414",
"0.5341221",
"0.5251067",
"0.52389675",
"0.52224195",
"0.5148562",
"0.50524735",
"0.50481427",
"0.50481427",
"0.5031429",
"0.50157976",
"0.4950536",
"0.49193513",
"0.49080384",
"0.48979896",
"0.48953548",
"0.48906115",
"0.4... | 0.5620923 | 1 |
Usa la libreria de folium para crear un mapa que muestra el camino entre las capitales de los dos paises | def printMapDijkstra(catalog, path):
# Datos de la primera capital al primer lp (Las captales van de rojo!)
firstElement = stack.pop(path)
vertexA = firstElement['vertexA'] # Primera Capital
vertexB = firstElement['vertexB'].split('-')[:1][0]
vertexA_info = mp.get(catalog['landingpoints'], vertexA)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_folium_map(self):",
"def _set_folium_map(self):\n m = Map(features=[self], width=self._width, height=self._height)\n self._folium_map = m.draw()",
"def create_map(films, pop_locations, year, loc_of_user):\n world_map = folium.Map()\n\n fg = folium.FeatureGroup(name=\"Film\")\n f... | [
"0.72090447",
"0.6518688",
"0.63825166",
"0.62834024",
"0.6216852",
"0.61821413",
"0.61816084",
"0.6174961",
"0.6174961",
"0.61664915",
"0.60756654",
"0.6016085",
"0.6007033",
"0.5979304",
"0.5963628",
"0.5938241",
"0.5932106",
"0.59305054",
"0.59143853",
"0.5903357",
"0.5888... | 0.0 | -1 |
Mean absolute error regression loss. | def mean_absolute_error(y_true, y_pred, *, sample_weight=..., multioutput=...):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean_absolute_error(self):\n print('Mean absolute error regression loss: ' + str(mean_absolute_error(self.model.dataset.get_y_test(),\n self.model.get_predicted())))",
"def mean_squared_error(self):\n print('Mean squ... | [
"0.82092834",
"0.75316024",
"0.73240125",
"0.715579",
"0.7151401",
"0.71104527",
"0.70501304",
"0.69472337",
"0.6935832",
"0.69307333",
"0.6914975",
"0.6842285",
"0.68380743",
"0.6825987",
"0.6815631",
"0.68115884",
"0.6807899",
"0.68038934",
"0.6796058",
"0.6781836",
"0.6764... | 0.71803063 | 3 |
Mean absolute percentage error regression loss. Note here that we do not represent the output as a percentage in range [0, 100]. Instead, we represent it in range [0, 1/eps]. Read more in the | def mean_absolute_percentage_error(y_true, y_pred, sample_weight=..., multioutput=...):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean_absolute_percentage_error(y_true, y_pred):\n output_errors = 100*np.average(np.abs(y_true - y_pred)/y_true)\n return np.average(output_errors)",
"def mean_absolute_percentage_error(y_true, y_pred):\n if len(y_true.shape) > 1 or len(y_pred.shape) > 1:\n raise TypeError('Arrays need to be ... | [
"0.7640588",
"0.75075644",
"0.7496276",
"0.7408573",
"0.7408573",
"0.72649664",
"0.723839",
"0.71749765",
"0.7093771",
"0.70465857",
"0.6919462",
"0.6886161",
"0.6827793",
"0.68212134",
"0.66761184",
"0.6675",
"0.6651786",
"0.6617233",
"0.65321493",
"0.65271723",
"0.6506483",... | 0.76742464 | 0 |
Mean squared error regression loss. | def mean_squared_error(y_true, y_pred, *, sample_weight=..., multioutput=..., squared=...):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean_squared_error(self):\n print('Mean squared error regression loss: ' + str(mean_squared_error(self.model.dataset.get_y_test(),\n self.model.get_predicted())))",
"def mean_squared_error(self, y_out, y):\n loss = np.... | [
"0.8255571",
"0.77297866",
"0.7600188",
"0.7562676",
"0.7498284",
"0.72682816",
"0.7266238",
"0.7260783",
"0.72425824",
"0.72425824",
"0.72248286",
"0.72134584",
"0.7193884",
"0.71936274",
"0.7186965",
"0.7167719",
"0.7165839",
"0.71417433",
"0.7107558",
"0.7069114",
"0.70598... | 0.70676416 | 20 |
Mean squared logarithmic error regression loss. | def mean_squared_log_error(y_true, y_pred, *, sample_weight=..., multioutput=...):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean_squared_logarithmic_error(y_true, y_pred):\n y_pred = tensor_conversion.convert_to_tensor_v2_with_dispatch(y_pred)\n y_true = math_ops.cast(y_true, y_pred.dtype)\n first_log = math_ops.log(backend.maximum(y_pred, backend.epsilon()) + 1.)\n second_log = math_ops.log(backend.maximum(y_true, backend.epsi... | [
"0.7162771",
"0.7122939",
"0.7013533",
"0.69584405",
"0.6901689",
"0.6872533",
"0.68515307",
"0.6828593",
"0.6821297",
"0.68030465",
"0.6796868",
"0.6756596",
"0.6753186",
"0.67320395",
"0.6705772",
"0.66960394",
"0.6684708",
"0.66746044",
"0.6660656",
"0.6647128",
"0.6643087... | 0.70238346 | 2 |
Median absolute error regression loss. Median absolute error output is nonnegative floating point. The best value | def median_absolute_error(y_true, y_pred, *, multioutput=..., sample_weight=...):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def median_absolute_error(self):\n print('Median absolute error regression loss: ' + str(median_absolute_error(self.model.dataset.get_y_test(),\n self.model.get_predicted())))",
"def abs_median_error(self) -> float:\n ... | [
"0.79329205",
"0.7356527",
"0.6854822",
"0.68116266",
"0.6647143",
"0.65790784",
"0.6537083",
"0.6533045",
"0.6438318",
"0.64356536",
"0.6396276",
"0.63813764",
"0.6341217",
"0.6334593",
"0.6299007",
"0.6280763",
"0.6274058",
"0.62736255",
"0.62697214",
"0.6242023",
"0.622260... | 0.76567715 | 1 |
Explained variance regression score function. Best possible score is 1.0, lower values are worse. | def explained_variance_score(y_true, y_pred, *, sample_weight=..., multioutput=...):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def explained_variance_score(self):\n print('Explained variance score: ' + str(explained_variance_score(self.model.dataset.get_y_test(),\n self.model.get_predicted())))",
"def variance_scorer(x, y):\n scores = [np.var(column) for ... | [
"0.7782597",
"0.6995945",
"0.69856685",
"0.6739042",
"0.67074156",
"0.67061454",
"0.6617293",
"0.6617293",
"0.6542628",
"0.6501592",
"0.649731",
"0.64949507",
"0.6450904",
"0.64444697",
"0.64215237",
"0.63731253",
"0.63682324",
"0.6336768",
"0.6336768",
"0.6336768",
"0.632655... | 0.67390394 | 4 |
R^2 (coefficient of determination) regression score function. Best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). A constant model that always predicts the expected value of y, disregarding the input features, would get a R^2 score of 0.0. | def r2_score(y_true, y_pred, *, sample_weight=..., multioutput=...):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def r2_score(self):\n print('R^2 (coefficient of determination) regression score function: ' +\n str(r2_score(self.model.dataset.get_y_test(), self.model.get_predicted())))",
"def r2_score_fitted(y_true, y_pred):\n lr = LinearRegression(fit_intercept=True)\n y_true = np.array(y_true).re... | [
"0.8335419",
"0.79704547",
"0.77934617",
"0.76882344",
"0.7580721",
"0.74633163",
"0.71447515",
"0.70602864",
"0.7025899",
"0.6944365",
"0.6924056",
"0.6916455",
"0.6890862",
"0.6889857",
"0.68797195",
"0.6865232",
"0.68274724",
"0.68088925",
"0.67936134",
"0.6687272",
"0.666... | 0.6984878 | 9 |
max_error metric calculates the maximum residual error. | def max_error(y_true, y_pred):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max_error(self):\n print('Maximum residual error: ' + str(max_error(self.model.dataset.get_y_test(), self.model.get_predicted())))",
"def max_error(self) -> float:\n return float(np.max(np.abs(self._flattened_errors())))",
"def max_abs_error(self) -> float:\n return np.max(np.abs([self... | [
"0.82129323",
"0.77675945",
"0.71214306",
"0.6661287",
"0.65684533",
"0.65526795",
"0.64712137",
"0.62896025",
"0.62316483",
"0.6153844",
"0.61269325",
"0.59729195",
"0.5958617",
"0.5942597",
"0.5913103",
"0.5869475",
"0.58643377",
"0.58599776",
"0.5849801",
"0.5825196",
"0.5... | 0.7023922 | 3 |
Mean Tweedie deviance regression loss. | def mean_tweedie_deviance(y_true, y_pred, *, sample_weight=..., power=...):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean_poisson_deviance(self):\n print('Mean Poisson deviance regression loss: ' + str(mean_poisson_deviance(self.model.dataset.get_y_test(),\n self.model.get_predicted())))",
"def mean_gamma_deviance(self):\n prin... | [
"0.72087216",
"0.7020211",
"0.6806615",
"0.6786812",
"0.6548388",
"0.64714855",
"0.6461012",
"0.6402578",
"0.6331095",
"0.6298561",
"0.6288422",
"0.62376523",
"0.6191947",
"0.6170224",
"0.61566055",
"0.6118376",
"0.61077774",
"0.61062914",
"0.60998076",
"0.6097593",
"0.609759... | 0.807882 | 0 |
Mean Poisson deviance regression loss. Poisson deviance is equivalent to the Tweedie deviance with the power parameter `power=1`. | def mean_poisson_deviance(y_true, y_pred, *, sample_weight=...):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean_poisson_deviance(self):\n print('Mean Poisson deviance regression loss: ' + str(mean_poisson_deviance(self.model.dataset.get_y_test(),\n self.model.get_predicted())))",
"def mean_tweedie_deviance(y_true, y_pred, *,... | [
"0.84597147",
"0.66956586",
"0.66028935",
"0.6221233",
"0.5982527",
"0.59586567",
"0.5881107",
"0.56975716",
"0.5629051",
"0.56143314",
"0.5528999",
"0.5501544",
"0.5478511",
"0.5445082",
"0.54310447",
"0.54274666",
"0.5426783",
"0.5422665",
"0.5404065",
"0.540162",
"0.540162... | 0.7705277 | 1 |
Mean Gamma deviance regression loss. Gamma deviance is equivalent to the Tweedie deviance with the power parameter `power=2`. It is invariant to scaling of the target variable, and measures relative errors. | def mean_gamma_deviance(y_true, y_pred, *, sample_weight=...):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean_gamma_deviance(self):\n print('Mean Gamma deviance regression loss: ' + str(mean_gamma_deviance(self.model.dataset.get_y_test(),\n self.model.get_predicted())))",
"def mean_poisson_deviance(self):\n print('Mean ... | [
"0.83312625",
"0.6755352",
"0.6428788",
"0.6200454",
"0.5909379",
"0.5906981",
"0.58842605",
"0.5782911",
"0.57710636",
"0.56851995",
"0.5670326",
"0.56645346",
"0.5622362",
"0.56072474",
"0.5598907",
"0.55700964",
"0.55504924",
"0.5529231",
"0.5525843",
"0.55211276",
"0.5512... | 0.75102615 | 1 |
Return an embed that contains the exception. | def _get_error_embed(self, title: str, body: str) -> Embed:
return Embed(
title=title,
colour=Colours.soft_red,
description=body
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_error_embed(self, title: str, body: str) -> Embed:\n return Embed(\n title=title,\n colour=0xFF0000,\n description=body,\n )",
"def error_embed(self, message: str):\n embed = discord.Embed(color=discord.Color.red())\n embed.title = \"\"\n ... | [
"0.70701724",
"0.7026596",
"0.65724456",
"0.62856364",
"0.60045296",
"0.5970829",
"0.59310895",
"0.5897974",
"0.5858693",
"0.58173764",
"0.58153445",
"0.5798883",
"0.5796214",
"0.5735364",
"0.57222617",
"0.57210505",
"0.56536776",
"0.55875224",
"0.5586819",
"0.5551298",
"0.55... | 0.7072802 | 0 |
Provide generic command error handling. Error handling is deferred to any local error handler, if present. This is done by checking for the presence of a `handled` attribute on the error. Error handling emits a single error message in the invoking context `ctx` and a log message, | async def on_command_error(self, ctx: Context, e: errors.CommandError) -> None:
command = ctx.command
if hasattr(e, "handled"):
log.trace(f"Command {command} had its error already handled locally; ignoring.")
return
debug_message = (
f"Command {command} invo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def on_command_error(self, ctx, error):\n\n # This prevents any commands with local handlers being handled here in on_command_error.\n if hasattr(ctx.command, 'on_error'):\n return\n\n ignored = (commands.CommandNotFound, commands.UserInputError)\n\n # Allows us to chec... | [
"0.76441735",
"0.7575327",
"0.75575596",
"0.75218976",
"0.7139422",
"0.71180403",
"0.70349246",
"0.7033922",
"0.6987191",
"0.6763354",
"0.6703136",
"0.66731495",
"0.66147363",
"0.6507387",
"0.650727",
"0.6412765",
"0.6384094",
"0.63713896",
"0.6319018",
"0.620888",
"0.6202594... | 0.7748827 | 0 |
Return a prepared `help` command invocation coroutine. | async def send_command_help(self, ctx: Context) -> None:
if ctx.command:
self.bot.help_command.context = ctx
await ctx.send_help(ctx.command)
return
await ctx.send_help() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _help(self):\n self.onecmd('help')",
"async def help(ctx, command:str=None):\n if command == None:\n embed = assemble_embed(\n title=\"Looking for help?\",\n desc=(\"Hey there, I'm a resident bot of Scioly.org!\\n\\n\" +\n \"On Discord, you can send me comman... | [
"0.75976574",
"0.7578193",
"0.7457174",
"0.7355775",
"0.73405033",
"0.72280246",
"0.7172304",
"0.7154413",
"0.7137024",
"0.7116726",
"0.7116726",
"0.7111586",
"0.7106586",
"0.7106586",
"0.7106586",
"0.7106586",
"0.7091075",
"0.70806426",
"0.70587206",
"0.705207",
"0.70486647"... | 0.69552404 | 28 |
Attempt to invoke the silence or unsilence command if invoke with matches a pattern. | async def try_silence(self, ctx: Context) -> bool:
silence_command = self.bot.get_command("silence")
if not silence_command:
log.debug("Not attempting to parse message as `shh`/`unshh` as could not find `silence` command.")
return False
command = ctx.invoked_with.lower()... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _run(vendor, **kwargs):\n if os.path.isfile('stop'):\n return None\n # This only works well if the logger's formatter has been set correctly.\n logging.debug('Running %s({fmt_kwargs}) ...', vendor.__name__, extra={'fmt_kwargs': kwargs})\n return vendor(**kwargs).run()",
"def filter(self, s... | [
"0.49114773",
"0.48788896",
"0.48660362",
"0.48127654",
"0.48059168",
"0.48024642",
"0.4799675",
"0.4703732",
"0.46873048",
"0.46738335",
"0.46524504",
"0.46363908",
"0.46357155",
"0.46301818",
"0.46191686",
"0.460999",
"0.4579304",
"0.4568367",
"0.45615396",
"0.45612645",
"0... | 0.5630745 | 0 |
Attempt to display a tag by interpreting the command name as a tag name. The invocation of tags get respects its checks. Any CommandErrors raised will be handled by `on_command_error`, but the `invoked_from_error_handler` attribute will be added to the context to prevent infinite recursion in the case of a CommandNotFo... | async def try_get_tag(self, ctx: Context) -> None:
tags_cog = self.bot.get_cog("Tags")
if not tags_cog:
log.debug("Not attempting to parse message as a tag as could not find `Tags` cog.")
return
tags_get_command = tags_cog.get_command_ctx
maybe_tag_name = ctx.inv... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def get_tag_command(self, ctx):\n await self.get_tag(ctx)",
"def func(self):\n if not self.args:\n return self.display_tags()\n super(CmdArxTag, self).func()",
"def tag_cmd(context, json, name):\n store: Store = context.obj[\"store\"]\n LOG.info(\"Fetch tags\")\n ... | [
"0.6515155",
"0.6264933",
"0.6097251",
"0.59668833",
"0.5863284",
"0.5552771",
"0.55231833",
"0.55163765",
"0.5469529",
"0.53831303",
"0.5352281",
"0.5327914",
"0.5314861",
"0.529864",
"0.5292355",
"0.52810186",
"0.5239061",
"0.52387",
"0.52375",
"0.52153635",
"0.52134526",
... | 0.662568 | 0 |
Attempt to run eval or timeit command with triple backticks directly after command. | async def try_run_fixed_codeblock(self, ctx: Context) -> bool:
msg = copy.copy(ctx.message)
command, sep, end = msg.content.partition("```")
msg.content = command + " " + sep + end
new_ctx = await self.bot.get_context(msg)
if new_ctx.command is None:
return False
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def backtick(cmd, input=None, timeout=None):\n PIPE = subprocess.PIPE\n stdin = PIPE if input is not None else None\n return subprocess.check_output(cmd, stdin=stdin, stderr=PIPE,\n universal_newlines=True,\n timeout=timeout)",
"def exe... | [
"0.6119423",
"0.581478",
"0.56552666",
"0.5594058",
"0.55659336",
"0.5521741",
"0.5521741",
"0.55122864",
"0.54629916",
"0.54199374",
"0.53596467",
"0.5357504",
"0.5277461",
"0.52723086",
"0.52422655",
"0.5236987",
"0.5225021",
"0.5224723",
"0.5219171",
"0.520724",
"0.5110147... | 0.0 | -1 |
Sends user similar commands if any can be found. | async def send_command_suggestion(self, ctx: Context, command_name: str) -> None:
# No similar tag found, or tag on cooldown -
# searching for a similar command
raw_commands = []
for cmd in self.bot.walk_commands():
if not cmd.hidden:
raw_commands += (cmd.name... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _query_commands(self):\n # TODO: make this work\n self.player.respond(\"Hi there! Ask me to play artists or songs. \"\n \"I can also find songs that are similar to other \"\n \"artists.\")",
"def _send_custom_commands_after_welcome(self, con... | [
"0.6808523",
"0.65629894",
"0.64231116",
"0.632939",
"0.62583196",
"0.6256796",
"0.6255763",
"0.61863035",
"0.61725885",
"0.61473215",
"0.61381584",
"0.6126272",
"0.6038647",
"0.6038119",
"0.6028124",
"0.6009447",
"0.6007465",
"0.5997941",
"0.5966272",
"0.5958318",
"0.5903161... | 0.60866976 | 12 |
Send an error message in `ctx` for UserInputError, sometimes invoking the help command too. | async def handle_user_input_error(self, ctx: Context, e: errors.UserInputError) -> None:
if isinstance(e, errors.MissingRequiredArgument):
embed = self._get_error_embed("Missing required argument", e.param.name)
self.bot.stats.incr("errors.missing_required_argument")
elif isinsta... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def ticker_error(ctx, error):\n print(error)\n if isinstance(error, commands.UserInputError):\n await ctx.send(\"Invalid input.\")\n else:\n await ctx.send(\"Oops, something bad happened..\")",
"async def help_error(self, ctx, error):\n await self.log_error_and_apologize(ctx, ... | [
"0.712171",
"0.70414114",
"0.6898544",
"0.63807166",
"0.630528",
"0.62828434",
"0.6276545",
"0.62387955",
"0.62291414",
"0.6223708",
"0.6164131",
"0.60974765",
"0.60968906",
"0.6075964",
"0.60698235",
"0.6060255",
"0.6027322",
"0.6005236",
"0.5989822",
"0.5957479",
"0.5935911... | 0.79300207 | 0 |
Send an error message in `ctx` for certain types of CheckFailure. | async def handle_check_failure(ctx: Context, e: errors.CheckFailure) -> None:
bot_missing_errors = (
errors.BotMissingPermissions,
errors.BotMissingRole,
errors.BotMissingAnyRole
)
if isinstance(e, bot_missing_errors):
ctx.bot.stats.incr("errors.b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _failed(self, msg):\n self.log(msg)\n self.result.passed = False\n self.result.add_error(msg)\n self.log(u\"Failed\")",
"def error(ctx, flow):\n ctx.log(\"error\")",
"def error(update, context):\n logger.warning(f'caused error {context.error}')",
"def test_error_control(... | [
"0.60246116",
"0.5896615",
"0.58233225",
"0.58143854",
"0.5786445",
"0.56219566",
"0.5606722",
"0.5545335",
"0.5539042",
"0.5516704",
"0.550029",
"0.54476047",
"0.544695",
"0.5430611",
"0.5427206",
"0.5410872",
"0.541001",
"0.5401988",
"0.53921306",
"0.53902113",
"0.53895056"... | 0.71992475 | 0 |
Send an error message in `ctx` for ResponseCodeError and log it. | async def handle_api_error(ctx: Context, e: ResponseCodeError) -> None:
if e.status == 404:
log.debug(f"API responded with 404 for command {ctx.command}")
await ctx.send("There does not seem to be anything matching your query.")
ctx.bot.stats.incr("errors.api_error_404")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_error(self, status_code, **kwargs):\n exc_info = kwargs.get(\"exc_info\")\n message = \"\"\n if exc_info:\n message = self.extract_message(exc_info)\n if not message:\n message = responses.get(status_code, \"Unknown HTTP Error\")\n\n # this cannot b... | [
"0.71094215",
"0.69790447",
"0.68559957",
"0.6612752",
"0.6503821",
"0.65010816",
"0.64997864",
"0.6492574",
"0.64858484",
"0.648568",
"0.6457176",
"0.6434795",
"0.64113706",
"0.63517714",
"0.63488925",
"0.6336582",
"0.6322579",
"0.63142663",
"0.63038105",
"0.6278051",
"0.627... | 0.6887602 | 2 |
Send a generic error message in `ctx` and log the exception as an error with exc_info. | async def handle_unexpected_error(ctx: Context, e: errors.CommandError) -> None:
await ctx.send(
f"Sorry, an unexpected error occurred. Please let us know!\n\n"
f"```{e.__class__.__name__}: {e}```"
)
ctx.bot.stats.incr("errors.unexpected")
with push_scope() as s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exception(self, msg, *args, **kwargs):\n ex = sys.exc_info()[1]\n\n if hasattr(ex, '_monocle'):\n args = args + (format_tb(ex),)\n self.logger.error('%s\\n%%s' % msg, *args, **kwargs)\n else:\n super(Adapter, self).exception(msg, *args, **kwargs)",
"async... | [
"0.66102415",
"0.6521973",
"0.65208805",
"0.6511823",
"0.6496838",
"0.64238614",
"0.6343548",
"0.6298833",
"0.6289678",
"0.62591517",
"0.61192894",
"0.6117967",
"0.6110379",
"0.60824025",
"0.6081935",
"0.60816187",
"0.60814667",
"0.6074158",
"0.60646653",
"0.60445",
"0.603465... | 0.0 | -1 |
Load the ErrorHandler cog. | async def setup(bot: Bot) -> None:
await bot.add_cog(ErrorHandler(bot)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_error_handler(app):\n app.register_error_handler(Exception, global_handler)\n return app",
"def _set_error_handler(self):\n if self.on_error:\n error_step = self.context.root.path_to_step(self.on_error)\n self._on_error_handler = error_step.run",
"def get_error_handl... | [
"0.69155324",
"0.6595718",
"0.65654486",
"0.6458123",
"0.62834316",
"0.6152041",
"0.57470226",
"0.56880206",
"0.5637985",
"0.5609302",
"0.5580768",
"0.5541755",
"0.5477142",
"0.54422736",
"0.5419221",
"0.538743",
"0.53578484",
"0.53414106",
"0.5339533",
"0.5326992",
"0.524064... | 0.5387246 | 16 |
Generates a tipsy snapshot from the initial conditions object ICobj. Returns snapshot, param | def snapshot_gen(ICobj):
# Constants
G = SimArray(1.0,'G')
kB = SimArray(1.0,'k')
# ------------------------------------
# Load in things from ICobj
# ------------------------------------
# snapshot file name
snapshotName = ICobj.settings.filenames.snapshotName
# particle positi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def snapshot_gen(self):\n \n # Generate snapshot\n snapshot, snapshot_param = make_snapshot.snapshot_gen(self._parent)\n # Save to ICobj\n self._parent.snapshot = snapshot\n self._parent.snapshot_param = snapshot_param",
"def test_snapshot(self):\n converter = Ins... | [
"0.57171977",
"0.52551705",
"0.51138514",
"0.5079848",
"0.50731844",
"0.500941",
"0.49984103",
"0.498946",
"0.4946346",
"0.4926859",
"0.48875278",
"0.48804834",
"0.48735443",
"0.4870587",
"0.48191464",
"0.48191464",
"0.4816881",
"0.47846153",
"0.47815368",
"0.47701958",
"0.47... | 0.6311167 | 0 |
Return the possibly of a file being consumable by this plugin. | def verifyfile(self, path):
return (
super(InventoryModule, self).verify_file(path) and
path.endswith((self.NAME + ".yaml", self.NAME + ".yml"))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isBasedInHiddenFile(self):\n #type: () -> Optional[bool]\n return (\n None if self.realFileName is None #if before\n else self.realFileName != self.fileName\n )",
"def getInFile( self ):\n return self.file",
"def is_file(self):\n return self.type ==... | [
"0.5852709",
"0.57894",
"0.57791126",
"0.57624125",
"0.57588744",
"0.5749567",
"0.5709253",
"0.56813145",
"0.56744784",
"0.567032",
"0.5590263",
"0.558216",
"0.5562728",
"0.55623823",
"0.54860914",
"0.54860914",
"0.54860914",
"0.5484788",
"0.54812306",
"0.5476542",
"0.5463961... | 0.0 | -1 |
[settable, onlineonly] Total uservisible file (inode) count, i.e., maximum number of uservisible files (inodes) that this referenced file system can currently hold. If the referenced file system is restricted or offline, a value of 0 is returned. | def fs_files_total(self):
return self._fs_files_total | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fs_maxfiles_used(self):\n return self._fs_maxfiles_used",
"def n_total_files(self):\n return len(self.fileinfo)",
"def fs_files_used(self):\n return self._fs_files_used",
"def fs_files_private_used(self):\n return self._fs_files_private_used",
"def fileCount(self):\n ... | [
"0.7082203",
"0.70292205",
"0.67417777",
"0.66801584",
"0.66782624",
"0.6589247",
"0.6580722",
"0.6553939",
"0.6536609",
"0.6506965",
"0.650572",
"0.64885944",
"0.64882696",
"0.63858473",
"0.6353019",
"0.63459617",
"0.6315808",
"0.6264559",
"0.62503463",
"0.6221747",
"0.62143... | 0.69523025 | 2 |
[not settable, onlineonly] The number of uservisible files currently in use on the referenced file system. | def fs_maxfiles_used(self):
return self._fs_maxfiles_used | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fs_files_used(self):\n return self._fs_files_used",
"def fs_files_private_used(self):\n return self._fs_files_private_used",
"def fileCount(self):\n pass",
"def getFileCount(self) -> int:\n ...",
"def numberFiles(self):\n return self.n",
"def __number_of_files(self)... | [
"0.75745016",
"0.74626404",
"0.72624356",
"0.72596025",
"0.70048213",
"0.6969848",
"0.69370127",
"0.6878165",
"0.67919236",
"0.6769306",
"0.6725484",
"0.6696836",
"0.6693496",
"0.6692481",
"0.663346",
"0.6595896",
"0.6586411",
"0.6556981",
"0.65504795",
"0.6541895",
"0.652519... | 0.7229248 | 4 |
[not settable, onlineonly] Number of bytes still available in the referenced file system. If the referenced file system is restricted or offline, a value of 0 is returned. | def fs_size_available(self):
return self._fs_size_available | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def num_bytes(self):\n if self._num_bytes is None:\n status, info = self._resource._file.stat(\n timeout=(0 if self._timeout is None else self._timeout)\n )\n if not status.ok:\n raise OSError(\n \"\"\"XRootD error: {0}\nin fi... | [
"0.7215966",
"0.7215966",
"0.715566",
"0.70915985",
"0.7042157",
"0.7033947",
"0.69954884",
"0.68875164",
"0.68428534",
"0.6819091",
"0.6789879",
"0.678698",
"0.67142147",
"0.6713598",
"0.6698187",
"0.665003",
"0.66352886",
"0.6621122",
"0.6597673",
"0.65947264",
"0.6516065",... | 0.7171732 | 2 |
[not settable, onlineonly] The percentage of disk space saved by eliminating the duplicated blocks on the referenced file system. | def fs_sis_percent_saved(self):
return self._fs_sis_percent_saved | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def disk_usage(path):\n st = os.statvfs(path)\n free = (st.f_bavail * st.f_frsize)\n total = (st.f_blocks * st.f_frsize)\n used = (st.f_blocks - st.f_bfree) * st.f_frsize\n try:\n percent = ret = (float(used) / total) * 100\n except ZeroDivisionError:\n percent = 0\n # NB: t... | [
"0.67411596",
"0.6688065",
"0.65487635",
"0.65090346",
"0.6501265",
"0.6407541",
"0.63741",
"0.634771",
"0.62821704",
"0.6267542",
"0.62378645",
"0.6228783",
"0.62119985",
"0.6169301",
"0.60772586",
"0.60668004",
"0.60660887",
"0.604889",
"0.60474837",
"0.6035398",
"0.6018677... | 0.54536784 | 81 |
[not settable, onlineonly] The percentage of disk space currently in use based on uservisible file (inode) count on the referenced file system. | def fs_percent_inode_used_capacity(self):
return self._fs_percent_inode_used_capacity | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def disk_usage(path):\n st = os.statvfs(path)\n free = (st.f_bavail * st.f_frsize)\n total = (st.f_blocks * st.f_frsize)\n used = (st.f_blocks - st.f_bfree) * st.f_frsize\n try:\n percent = ret = (float(used) / total) * 100\n except ZeroDivisionError:\n percent = 0\n # NB: t... | [
"0.7925914",
"0.7788018",
"0.7767886",
"0.7538284",
"0.7479627",
"0.7402273",
"0.7383282",
"0.73624295",
"0.7339972",
"0.72335976",
"0.71510816",
"0.71314514",
"0.7105864",
"0.7075663",
"0.70739603",
"0.7053933",
"0.693317",
"0.68960637",
"0.68912286",
"0.6873249",
"0.6799669... | 0.75687283 | 3 |
[not settable, onlineonly] The amount of data in bytes that is shared by more than one instance on the referenced file system. | def fs_sis_shared_space(self):
return self._fs_sis_shared_space | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def BytesTransferred(self) -> int:",
"def getSize(self) -> long:\n ...",
"def fs_size_used(self):\n return self._fs_size_used",
"def fs_hybrid_cache_size_total(self):\n return self._fs_hybrid_cache_size_total",
"def size(self):\n size = 0\n size += self.data.size * sys.ge... | [
"0.68554944",
"0.64408404",
"0.6434519",
"0.6402334",
"0.6395444",
"0.6376144",
"0.6370729",
"0.63375413",
"0.6309336",
"0.6301092",
"0.6285541",
"0.62808436",
"0.6274288",
"0.62670445",
"0.62670445",
"0.625912",
"0.6246595",
"0.6227414",
"0.6222847",
"0.6217756",
"0.6205837"... | 0.0 | -1 |
[not settable, always] The largest value to which the fsmaxfilesavailable parameter can be increased by reconfiguration, | def fs_maxfiles_possible(self):
return self._fs_maxfiles_possible | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fs_maxfiles_available(self):\n return self._fs_maxfiles_available",
"def fs_maxfiles_used(self):\n return self._fs_maxfiles_used",
"def max_files(self):\n\n return 10 ** self.int_len(self.cnt_files())",
"def fs_size_available(self):\n return self._fs_size_available",
"def by... | [
"0.82712835",
"0.8090931",
"0.71663946",
"0.6656941",
"0.6646011",
"0.6620783",
"0.64894843",
"0.6332437",
"0.6332305",
"0.6286847",
"0.62757057",
"0.62750083",
"0.6236155",
"0.61510867",
"0.6074842",
"0.60359365",
"0.60282034",
"0.59874076",
"0.5982692",
"0.59755796",
"0.597... | 0.82997 | 0 |
[not settable, onlineonly] The total disk space in bytes that is saved by storing only one copy of the duplicated blocks on the referenced file system. | def fs_sis_saved_space(self):
return self._fs_sis_saved_space | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_space_used():\n fs.get_space_used()",
"def fs_size_used(self):\n return self._fs_size_used",
"def fs_size_total(self):\n return self._fs_size_total",
"def fs_total_reserved_space(self):\n return self._fs_total_reserved_space",
"def total_storage(self):\n return self._... | [
"0.7007065",
"0.69417715",
"0.691247",
"0.6821893",
"0.67845905",
"0.6768419",
"0.67492956",
"0.67020994",
"0.6646754",
"0.661664",
"0.654519",
"0.65355194",
"0.65176225",
"0.6508093",
"0.6500125",
"0.6465935",
"0.6442479",
"0.643597",
"0.64343685",
"0.6417594",
"0.6416107",
... | 0.0 | -1 |
[not settable, onlineonly] Number of inodes that can currently be stored on disk for uservisible files. This number will dynamically increase as more uservisible files are created. | def fs_inodefile_public_capacity(self):
return self._fs_inodefile_public_capacity | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fs_inodefile_private_capacity(self):\n return self._fs_inodefile_private_capacity",
"def numberFiles(self):\n return self.n",
"def fs_files_private_used(self):\n return self._fs_files_private_used",
"def fs_maxfiles_used(self):\n return self._fs_maxfiles_used",
"def n_total_... | [
"0.66479313",
"0.6554679",
"0.654066",
"0.64726263",
"0.6429585",
"0.6394004",
"0.63604003",
"0.6303086",
"0.62792194",
"0.6225605",
"0.6211433",
"0.61757964",
"0.60769045",
"0.6028026",
"0.59996945",
"0.59917325",
"0.5941016",
"0.5920603",
"0.5886062",
"0.5861142",
"0.586023... | 0.62509674 | 9 |
This field represents space used by the sum of all data and metadata of all volumes in the aggregate in bytes. | def fs_volume_footprints(self):
return self._fs_volume_footprints | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def total_storage(self):\n return self._total_storage",
"def fs_size_total(self):\n return self._fs_size_total",
"def _raw_itemsize(self):\n if _has_unicode_fields(self):\n total_itemsize = 0\n for field in self.dtype.fields.values():\n itemsize = field... | [
"0.69040895",
"0.66636777",
"0.66083217",
"0.6533461",
"0.62840825",
"0.6274708",
"0.62726444",
"0.6241903",
"0.62069184",
"0.61999524",
"0.61530226",
"0.61474305",
"0.612676",
"0.61061084",
"0.6102644",
"0.6095368",
"0.60950047",
"0.6085195",
"0.6085195",
"0.6085195",
"0.608... | 0.0 | -1 |
[not settable, onlineonly] Total size (in bytes) of the referenced file system . If the referenced file system is restricted or offline, a value 0 is returned. | def fs_size_total(self):
return self._fs_size_total | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fs_size_used(self):\n return self._fs_size_used",
"def get_space_used():\n files = jobtracker.query(\"SELECT * FROM files \" \\\n \"WHERE status IN ('added', 'downloaded', 'unverified')\")\n\n total_size = 0\n for file in files:\n total_size += int(file['siz... | [
"0.7535778",
"0.75355166",
"0.75019115",
"0.7463405",
"0.74039775",
"0.73530895",
"0.7339242",
"0.7317524",
"0.7317351",
"0.72994936",
"0.7290265",
"0.72876734",
"0.7249945",
"0.7235576",
"0.7222606",
"0.7210238",
"0.7192857",
"0.7184594",
"0.7180609",
"0.7180061",
"0.7178904... | 0.7842023 | 0 |
This field represents space used by filesystem metadata of the aggregate in bytes. | def fs_aggregate_metadata(self):
return self._fs_aggregate_metadata | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fs_size_used(self):\n return self._fs_size_used",
"def my_size(self):\n return u\"{} bytes\".format(self.size)",
"def storage_bytes(self) -> str:\n return pulumi.get(self, \"storage_bytes\")",
"def fs_size_total(self):\n return self._fs_size_total",
"def data_disk_size_gb(se... | [
"0.67690367",
"0.65594494",
"0.6533121",
"0.6527707",
"0.64676404",
"0.6418522",
"0.64120966",
"0.6402265",
"0.6383675",
"0.6379889",
"0.6374366",
"0.63350016",
"0.63348657",
"0.6319338",
"0.6319338",
"0.62872714",
"0.6284882",
"0.6283727",
"0.62647575",
"0.6244635",
"0.62438... | 0.0 | -1 |
[not settable, onlineonly] The total disk space in bytes that is reserved on the referenced file system. The reserved space is already counted in the used space, so this element can be used to see what portion of the used space represents space reserved for future use. | def fs_total_reserved_space(self):
return self._fs_total_reserved_space | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_space_used():\n fs.get_space_used()",
"def fs_percent_used_capacity(self):\n return self._fs_percent_used_capacity",
"def available_space(self):\n # From http://stackoverflow.com/a/787832/732596\n s = os.statvfs(self.path)\n return (s.f_bavail * s.f_frsize) / 1024**2",
... | [
"0.7872437",
"0.77098984",
"0.76996523",
"0.761195",
"0.74873185",
"0.7478342",
"0.74753845",
"0.7407428",
"0.74053967",
"0.7351825",
"0.73261625",
"0.7259881",
"0.71839964",
"0.715185",
"0.70758784",
"0.7032841",
"0.70319766",
"0.7028243",
"0.70219475",
"0.7009117",
"0.69965... | 0.82823014 | 0 |
[not settable, onlineonly] Number of system (not uservisible) files (inodes) used. If the referenced file system is restricted or offline, a value of 0 is returned. | def fs_files_private_used(self):
return self._fs_files_private_used | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fs_maxfiles_used(self):\n return self._fs_maxfiles_used",
"def fs_files_used(self):\n return self._fs_files_used",
"def numberFiles(self):\n return self.n",
"def fs_size_used(self):\n return self._fs_size_used",
"def fs_maxfiles_possible(self):\n return self._fs_maxfi... | [
"0.7176069",
"0.71455556",
"0.6795118",
"0.6650427",
"0.6613002",
"0.65911686",
"0.65844214",
"0.65790117",
"0.6578183",
"0.65556973",
"0.6517203",
"0.6508235",
"0.6503883",
"0.6498055",
"0.6467044",
"0.6464757",
"0.64563286",
"0.6447357",
"0.6411767",
"0.63070005",
"0.627850... | 0.7063733 | 2 |
[not settable, onlineonly] Number of bytes used in the referenced file system. If the referenced file system is restricted or offline, a value of 0 is returned. | def fs_size_used(self):
return self._fs_size_used | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def usedspace(self):\n self.log.info(\"freespace\")\n nbytes = 0\n keys = list(self.downloads.keys())\n keys.sort()\n for key in keys:\n download = self.downloads[key]\n nbytes += download['size']\n self.log.info(\"returning:\" + str(nbytes))\n ... | [
"0.7420827",
"0.72786707",
"0.72786707",
"0.7269325",
"0.71914876",
"0.71662307",
"0.7160162",
"0.7136105",
"0.7135419",
"0.70523435",
"0.7033959",
"0.7007181",
"0.6840923",
"0.68281364",
"0.6804137",
"0.67992747",
"0.6791028",
"0.67774755",
"0.6768768",
"0.6767286",
"0.67621... | 0.7629277 | 0 |
[not settable, onlineonly] Total cache size (in bytes) in a hybrid aggregate. If the referenced aggregate is restricted or offline, or if it is not a hybrid aggregate, a value of 0 is returned. | def fs_hybrid_cache_size_total(self):
return self._fs_hybrid_cache_size_total | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cache_size(self):\n return self.cachesize",
"def get_size(self):\n return len(self.cache)",
"def get_size(self) -> int:\n total_size = 0\n for entry in self.__entries:\n total_size += entry.get_size()\n return total_size",
"def cache_size(self):\n retu... | [
"0.6754768",
"0.671188",
"0.65282655",
"0.6520063",
"0.64089966",
"0.6407665",
"0.63737583",
"0.63638794",
"0.6302466",
"0.62790143",
"0.6275713",
"0.6260091",
"0.62569165",
"0.6254125",
"0.62438375",
"0.62292016",
"0.62211895",
"0.6212261",
"0.6185322",
"0.61822873",
"0.6172... | 0.79143655 | 0 |
[not settable, onlineonly] The percentage of disk space currently in use on the referenced file system. | def fs_percent_used_capacity(self):
return self._fs_percent_used_capacity | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def disk_usage(self):\n self.monitoring_object['disk_usage'] =\\\n psutil.disk_usage('/')",
"def disk_usage(path):\n st = os.statvfs(path)\n free = (st.f_bavail * st.f_frsize)\n total = (st.f_blocks * st.f_frsize)\n used = (st.f_blocks - st.f_bfree) * st.f_frsize\n try:\n ... | [
"0.7765354",
"0.77051103",
"0.7577086",
"0.750689",
"0.7416436",
"0.73467296",
"0.73366296",
"0.7290818",
"0.7214682",
"0.7189561",
"0.7112761",
"0.71106875",
"0.7087746",
"0.7049418",
"0.7022909",
"0.69850135",
"0.69742143",
"0.69612396",
"0.6953823",
"0.6924519",
"0.6905571... | 0.78090465 | 0 |
[not settable, onlineonly] Number of inodes that can currently be stored on disk for system (not uservisible) files. This number will dynamically increase as more system files are created. | def fs_inodefile_private_capacity(self):
return self._fs_inodefile_private_capacity | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def numberFiles(self):\n return self.n",
"def fs_maxfiles_used(self):\n return self._fs_maxfiles_used",
"def n_file(self):\n self.assert_is_dir_and_exists()\n n = 0\n for _ in self.select_file(recursive=True):\n n += 1\n return n",
"def _get_os_file_quota(... | [
"0.67676884",
"0.6694791",
"0.6650884",
"0.6619768",
"0.66188973",
"0.65584064",
"0.65211874",
"0.65172863",
"0.6454269",
"0.6412615",
"0.6394347",
"0.6388729",
"0.6340381",
"0.63259023",
"0.62917686",
"0.62876606",
"0.62548697",
"0.61729693",
"0.61536944",
"0.61416286",
"0.6... | 0.65342677 | 6 |
[not settable, onlineonly] Number of uservisible files (inodes) used in the referenced file system. If the referenced file system is restricted or offline, a value of 0 is returned. | def fs_files_used(self):
return self._fs_files_used | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fs_files_private_used(self):\n return self._fs_files_private_used",
"def fs_maxfiles_used(self):\n return self._fs_maxfiles_used",
"def n_total_files(self):\n return len(self.fileinfo)",
"def numberFiles(self):\n return self.n",
"def __number_of_files(self):\n self.__... | [
"0.7214981",
"0.7100775",
"0.6683742",
"0.6647139",
"0.6588653",
"0.6584798",
"0.65275645",
"0.6507867",
"0.6462393",
"0.6428048",
"0.6423025",
"0.6417021",
"0.6347864",
"0.63377476",
"0.6323211",
"0.6319013",
"0.63131106",
"0.62815505",
"0.6277341",
"0.6269649",
"0.62391883"... | 0.7142993 | 1 |
[not settable, always] The count of the maximum number of uservisible files currently allowable on the referenced file system. | def fs_maxfiles_available(self):
return self._fs_maxfiles_available | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fs_maxfiles_possible(self):\n return self._fs_maxfiles_possible",
"def max_files(self):\n\n return 10 ** self.int_len(self.cnt_files())",
"def fs_maxfiles_used(self):\n return self._fs_maxfiles_used",
"def getFileCount(self) -> int:\n ...",
"def n_total_files(self):\n ... | [
"0.77681595",
"0.7759587",
"0.7476491",
"0.71149945",
"0.70994216",
"0.7095124",
"0.70568395",
"0.694903",
"0.6930471",
"0.68859094",
"0.6753931",
"0.66169304",
"0.6603185",
"0.6579087",
"0.6525873",
"0.6507001",
"0.6477229",
"0.6474859",
"0.6425751",
"0.64191926",
"0.6407274... | 0.7348207 | 3 |
This field represents space used by the aggregate including the aggregate's Snapshot reserve in bytes. | def fs_used_including_snapshot_reserve(self):
return self._fs_used_including_snapshot_reserve | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fs_total_reserved_space(self):\n return self._fs_total_reserved_space",
"def capacity_used(self):\n raise NotImplementedError()",
"def bytes_used(self):\n return int(self.status[\"pgmap\"][\"bytes_used\"])",
"def fs_size_used(self):\n return self._fs_size_used",
"def get_spa... | [
"0.7311858",
"0.68309844",
"0.664259",
"0.6617146",
"0.66081816",
"0.66023266",
"0.66021866",
"0.6558189",
"0.6507855",
"0.6472979",
"0.6430022",
"0.64208555",
"0.6364673",
"0.63083977",
"0.6308299",
"0.6308299",
"0.6308299",
"0.6308299",
"0.6302829",
"0.63014317",
"0.6300755... | 0.6747708 | 2 |
Convert a pytorch geometric dataset to gckn dataset | def convert_dataset(dataset, n_tags=None):
if dataset is None:
return dataset
graph_list = []
for i, g in enumerate(dataset):
new_g = S2VGraph(g, g.y)
new_g.neighbors = get_adj_list(g)
if n_tags is not None:
new_g.node_features = F.one_hot(g.x.view(-1).long(), n_t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gc_data(dataset, dirname, train_ratio=0.8):\n \n # Define path where dataset should be saved\n data_path = \"data/{}.pth\".format(dataset)\n\n # If already created, do not recreate\n if os.path.exists(data_path):\n data = torch.load(data_path)\n else:\n if dataset == 'syn6':\n ... | [
"0.654751",
"0.5732393",
"0.57198703",
"0.5673252",
"0.56613374",
"0.5646728",
"0.5629825",
"0.5607446",
"0.55946285",
"0.5585697",
"0.55554587",
"0.54788715",
"0.54736745",
"0.5464334",
"0.54574233",
"0.5436929",
"0.54280037",
"0.54170096",
"0.5412945",
"0.53947353",
"0.5380... | 0.5220303 | 34 |
take pytorch geometric dataest as input | def apply_to(self, train_dset, test_dset=None, batch_size=64, n_tags=None):
saved_pos_enc = self.load()
if saved_pos_enc is not None:
dset_len = len(train_dset) if test_dset is None else len(train_dset) + len(test_dset)
if len(saved_pos_enc) != dset_len:
raise Val... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def geglu(x: Tensor) ->Tensor:\n assert x.shape[-1] % 2 == 0\n a, b = x.chunk(2, dim=-1)\n return a * F.gelu(b)",
"def gelu(x):\n cdf = 0.5 * (1.0 + torch.tanh(\n (np.sqrt(2 / np.pi) * (x + 0.044715 * np.power(x, 3)))))\n return x * cdf",
"def gelu(x):\n cdf = 0.5 * (1.0 + torch.tanh(\n (... | [
"0.62357146",
"0.61351407",
"0.6089715",
"0.5987402",
"0.5977883",
"0.5976598",
"0.5976598",
"0.5976598",
"0.5976598",
"0.5976598",
"0.5976598",
"0.5976598",
"0.5976598",
"0.597421",
"0.59034044",
"0.5888436",
"0.58755225",
"0.58755225",
"0.5870501",
"0.57885617",
"0.578758",... | 0.0 | -1 |
Downmix to 2 channels if multichannel audio | def downmixWAV(self, wavf: str) -> None:
# HACK: https://github.com/jiaaro/pydub/issues/129
# FIXME: a reliable method to get number of wav channels
multichannel = True
try:
w = wave.open(wavf, 'rb')
if w.getnchannels() < 3:
multichannel = False
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _augment_channelswap(audio):\n if audio.shape[0] == 2 and torch.FloatTensor(1).uniform_() < 0.5:\n return torch.flip(audio, [0])\n\n return audio",
"def split_into_channels(audio):\n\tif AUDIO_CHANNELS == 1:\n\t\treturn [audio]\n\tif AUDIO_CHANNELS == 2:\n\t\treturn [audioop.tomono(audio, AUDIO_... | [
"0.66251373",
"0.58017147",
"0.57132083",
"0.56815225",
"0.56815225",
"0.5676537",
"0.5673752",
"0.5620985",
"0.55017495",
"0.5484101",
"0.53784776",
"0.5284562",
"0.5257859",
"0.52494276",
"0.5246769",
"0.52426875",
"0.521309",
"0.5204684",
"0.5174859",
"0.5143285",
"0.51371... | 0.6062682 | 1 |
Entrypoint to encode a PCM WAV according to self.codec Calls the corresponding encoding flavour subroutine | def encode(self, wavf: str, dstf: str, cover: str, meta: TrackMeta) -> None:
if self.downmix:
self.downmixWAV(wavf)
if self.codec == 'opus':
self.encodeOpus(wavf, dstf, cover, meta)
elif self.codec == 'flac':
self.encodeFLAC(wavf, dstf, cover, meta)
el... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encode_audio(in_file, out_file):\r\n # construct the encoder\r\n autoencoder = keras.models.load_model(\"audio_autoencoder.model\")\r\n in_layer = keras.layers.Input(shape=(416, 1))\r\n encode = autoencoder.layers[1](in_layer)\r\n encode = autoencoder.layers[2](encode)\r\n encode = autoencode... | [
"0.65444165",
"0.616003",
"0.61182684",
"0.6044659",
"0.599945",
"0.5975797",
"0.59426254",
"0.5871932",
"0.584925",
"0.58197874",
"0.5721502",
"0.57136923",
"0.5708158",
"0.57024765",
"0.56833845",
"0.5681794",
"0.56796414",
"0.5656293",
"0.5639054",
"0.5635989",
"0.5626203"... | 0.708651 | 0 |
Encodes a PCM WAV file to Opus format | def encodeOpus(self, wavf: str, dstf: str, cover: str, meta: TrackMeta) -> None:
# TODO: bitrate 160/128
FNULL = open(os.devnull, 'w')
args = ['opusenc', '--bitrate', '192', '--quiet']
if cover:
args.append('--picture')
args.append(cover)
args.append(wavf)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encode_audio(in_file, out_file):\r\n # construct the encoder\r\n autoencoder = keras.models.load_model(\"audio_autoencoder.model\")\r\n in_layer = keras.layers.Input(shape=(416, 1))\r\n encode = autoencoder.layers[1](in_layer)\r\n encode = autoencoder.layers[2](encode)\r\n encode = autoencode... | [
"0.7447126",
"0.6970458",
"0.69213575",
"0.673158",
"0.663907",
"0.6574715",
"0.64782006",
"0.6477646",
"0.6452267",
"0.63436055",
"0.6342738",
"0.632365",
"0.6308248",
"0.6288879",
"0.628517",
"0.6273824",
"0.6239329",
"0.6218261",
"0.6209541",
"0.6154164",
"0.61016804",
"... | 0.69532764 | 2 |
Encodes a PCM WAV file to FLAC format | def encodeFLAC(self, wavf: str, dstf: str, cover: str, meta: TrackMeta) -> None:
FNULL = open(os.devnull, 'w')
args = ['flac', '-f', '--totally-silent', '--best']
if cover:
args.append('--picture')
args.append(cover)
args.append('-o')
args.append(dstf)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encode_flac(track_metadata):\n\tprint(\"---- Encoding\", track_metadata.file_name, \"to FLAC...\")\n\tnew_file_name = track_metadata.file_name + \".flac\"\n\tffmpeg(\"-i\", track_metadata.file_name, \"-c:a\", \"flac\", \"-compression_level\", \"12\", \"-lpc_passes\", \"8\", \"-lpc_type\", \"3\", \"-threads\", ... | [
"0.72776765",
"0.6860318",
"0.6540664",
"0.6528014",
"0.6487192",
"0.6446292",
"0.6383675",
"0.6361182",
"0.6282809",
"0.6255544",
"0.6238018",
"0.6137223",
"0.61305374",
"0.6121943",
"0.60995096",
"0.609092",
"0.60784394",
"0.6054091",
"0.5974038",
"0.5963611",
"0.59626454",... | 0.7052307 | 1 |
Encodes a PCM WAV file to MPEG4 AAC format (using NeroAAC) | def encodeAAC(self, wavf: str, dstf: str, cover: str, meta: TrackMeta) -> None:
FNULL = open(os.devnull, 'w')
subprocess.call(['neroAacEnc', '-q', '0.5',
'-if', wavf, '-of', dstf], stdout=FNULL, stderr=FNULL)
FNULL.close()
# tag AAC
mm = TrackMeta(meta)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encode_audio(in_file, out_file):\r\n # construct the encoder\r\n autoencoder = keras.models.load_model(\"audio_autoencoder.model\")\r\n in_layer = keras.layers.Input(shape=(416, 1))\r\n encode = autoencoder.layers[1](in_layer)\r\n encode = autoencoder.layers[2](encode)\r\n encode = autoencode... | [
"0.7306032",
"0.62807316",
"0.6186692",
"0.6184887",
"0.61353177",
"0.6118008",
"0.60905915",
"0.60306704",
"0.6010781",
"0.59966815",
"0.5967336",
"0.5942693",
"0.59272087",
"0.59113586",
"0.5872926",
"0.58028793",
"0.57023853",
"0.56894857",
"0.5689196",
"0.5650187",
"0.562... | 0.7470973 | 0 |
Encodes a PCM WAV file to MPEG1 Audio Layer 3 format | def encodeMP3(self, wavf: str, dstf: str, cover: str, meta: TrackMeta) -> None:
FNULL = open(os.devnull, 'w')
subprocess.call(['lame', '-V2', wavf, dstf], stdout=FNULL, stderr=FNULL)
FNULL.close()
# tag MP3
mm = TrackMeta(meta)
mp3 = MP3(dstf, ID3=ID3)
mp3["TIT2"]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encode_audio(in_file, out_file):\r\n # construct the encoder\r\n autoencoder = keras.models.load_model(\"audio_autoencoder.model\")\r\n in_layer = keras.layers.Input(shape=(416, 1))\r\n encode = autoencoder.layers[1](in_layer)\r\n encode = autoencoder.layers[2](encode)\r\n encode = autoencode... | [
"0.7180157",
"0.67253464",
"0.6287279",
"0.62661546",
"0.62112314",
"0.6203485",
"0.61516106",
"0.60963863",
"0.60483384",
"0.60130453",
"0.5990268",
"0.5917148",
"0.5906605",
"0.58948284",
"0.58849406",
"0.58605796",
"0.58453244",
"0.5831902",
"0.5786693",
"0.5777332",
"0.57... | 0.655354 | 2 |
takes the outcomes and selected scenario set (decision variables), returns a single 'diversity' value for the scenario set. | def evaluate_diversity_single(indices, distances, weight=0.5):
i, j = [e for e in zip(*itertools.combinations(indices, 2))]
subset_distances = distances[i, j]
minimum = np.min(subset_distances)
mean = np.mean(subset_distances)
diversity = (1 - weight) * minimum + weight * mean
return [diversity... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_diversity(population):\n\t# average variance of each component\n\treturn np.average(np.var(population, axis = 0))\n\treturn np.average(np.std(population, axis = 0))\n\treturn np.average(np.std(population, axis = 0) / ((self.benchmarks.bound[1] - self.benchmarks.bound[0]) / 2))",
"def diversity(\n ... | [
"0.65562975",
"0.6465593",
"0.5673692",
"0.5498322",
"0.53967047",
"0.5292437",
"0.5262143",
"0.5250632",
"0.52175653",
"0.5182313",
"0.5163027",
"0.50862765",
"0.507137",
"0.50572085",
"0.50517184",
"0.50378966",
"0.5029479",
"0.499668",
"0.49924362",
"0.4977275",
"0.4975866... | 0.52010244 | 9 |
Get the given duration in seconds | def get_duration(days=0, hours=0, minutes=0, seconds=0, millis=0):
duration = 0.0
duration += float(days) * 24 * 60 * 60
duration += float(hours) * 60 * 60
duration += float(minutes) * 60
duration += float(seconds)
duration += millis / 1000.0
return duration | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def seconds(duration):\n if not duration:\n return 0\n try:\n h, m, s = duration_parts(duration)\n return s\n except (ValueError, TypeError):\n return 0",
"def duration_in_seconds(self):\n return self.get_data(\"duration_in_seconds\")",
"def _duration_to_secs(duratio... | [
"0.8274603",
"0.76853216",
"0.76443124",
"0.75087965",
"0.7362068",
"0.73546374",
"0.7218812",
"0.7170379",
"0.71551794",
"0.7144807",
"0.713223",
"0.7123354",
"0.70880836",
"0.708677",
"0.7065162",
"0.70577097",
"0.70576304",
"0.7033154",
"0.7019381",
"0.69986045",
"0.699417... | 0.0 | -1 |
Check if we should still be running, if so, wait until it's time for the next tick. | def tick(self):
next_tick = self.last_tick + self.seconds_per_tick
while self.running:
current_time = time()
if current_time > next_tick:
break
sleep(self.sleep_duration)
if not self.running:
return False
self.last_tic... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wait_for_time():\n while rospy.Time().now().to_sec() == 0:\n pass",
"def wait_for_time():\n while rospy.Time().now().to_sec() == 0:\n pass",
"def wait_for_time():\n while rospy.Time().now().to_sec() == 0:\n pass",
"def wait_for_time():\n while rospy.Time().now().to_sec() ==... | [
"0.7300542",
"0.7300542",
"0.7300542",
"0.7289167",
"0.7247361",
"0.7039833",
"0.6979855",
"0.6862091",
"0.6821541",
"0.6780667",
"0.674327",
"0.6694194",
"0.6670322",
"0.6609794",
"0.65913993",
"0.6578846",
"0.65357697",
"0.6474358",
"0.64478546",
"0.643314",
"0.6413789",
... | 0.6896591 | 7 |
Dynamically load the module property as defined by the search parameter. | def load_from_module(search_definition):
try:
module_name, property_name = search_definition.split(":")
except:
raise ValueError(
'Search definition "{}" is not valid.'.format(search_definition)
)
try:
module = importlib.import_module(module_name)
except Imp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_parameter(self):",
"def import_JobProperties(self,module_name):\n try:\n if(module_name.count('.')==0):\n module=__import__(module_name,globals(),locals())\n elif(module_name.count('.')>0):\n module=__import__(module_name,globals(),locals(),\\\... | [
"0.5654104",
"0.5592349",
"0.5528449",
"0.54257554",
"0.5403773",
"0.5367219",
"0.53629297",
"0.53102595",
"0.5158309",
"0.51294607",
"0.5115421",
"0.5083747",
"0.5082948",
"0.50689006",
"0.5064725",
"0.5059072",
"0.50013876",
"0.49670178",
"0.49537078",
"0.49127337",
"0.4895... | 0.6725258 | 0 |
Change the value in s to its binary representation. | def tobits(s):
# Get the length of the input string
length = len(s)
# Create an empty list
outputbits = [0] * length
# Run the for loop
for i in range(0, length):
# Create an empty string
stchar = ''
# Run the loop for each character
for char in s[i]:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def s2b (s):\n return s.encode()",
"def s2b(s):\n return s.encode('utf-8')",
"def to_binary_string(x):\n return \"{0:b}\".format(x)",
"def repr_as_binary(value):\n b = bin(value)[2:]\n return b.zfill(len(b) + -len(b) % 8)",
"def binstr(x):\n xs = binary_repr(x)\n\n outstr = xs;... | [
"0.7148659",
"0.6838792",
"0.66999453",
"0.6415657",
"0.6405314",
"0.62653095",
"0.59890795",
"0.5958184",
"0.5947648",
"0.5778404",
"0.57623476",
"0.57416505",
"0.5738603",
"0.57354444",
"0.5729073",
"0.572353",
"0.572353",
"0.5695623",
"0.56772715",
"0.5676499",
"0.5673497"... | 0.63373107 | 5 |
change the value in bits to string. | def frombits(bits):
# Create an empty string
outputstring = ''
# Get the length of bits
length = len(bits)
# Run the for loop
for i in range(0, int(length / 8)):
# Get the character for each 8 bits
temp = chr(int(bits[8 * i:8 * i + 8], 2))
# Append each character to a str... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_bit_string(value):\n\n return \"{0:b}\".format(value).zfill(8)",
"def bits2string(b=None):\n return ''.join([chr(int(x, 2)) for x in b])",
"def valueToString():",
"def to_string(self, name, value):\r\n \r\n return str(value)",
"def make_bitstring(num):\n return bin(num)[2:]"... | [
"0.7182922",
"0.70788354",
"0.6883576",
"0.68563175",
"0.6700194",
"0.6655907",
"0.65955603",
"0.6521708",
"0.6513384",
"0.6439261",
"0.6436823",
"0.6392127",
"0.63915265",
"0.6379998",
"0.63605124",
"0.6318937",
"0.6283902",
"0.6192956",
"0.61704415",
"0.6163797",
"0.6146986... | 0.59056246 | 45 |
Append padding to message in order to become multiple of 16 in order to fit in AES input | def padding(message):
# Convert the string to bits by calling the tobits function
mbits = tobits(message)
# Get the length of bits
length = len(mbits)
# Calculate the strengthening vector length
strengthmessage = (bin(int(length))[2:]).zfill(64 * ((len(bin(int(length))[2:]) + 63) // 64))
#... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_padding(input_str):\r\n padding_len = AES.block_size - len(input_str) % AES.block_size\r\n return input_str + padding_len * chr(padding_len)",
"def pad(data):\r\n bytes_to_pad = AES.block_size - len(data) % AES.block_size\r\n return data + (bytes_to_pad * chr(bytes_to_pad))",
"def ... | [
"0.75792027",
"0.74822587",
"0.7470095",
"0.739368",
"0.7360763",
"0.71821815",
"0.67783034",
"0.66801685",
"0.6679499",
"0.6643136",
"0.6631054",
"0.6626734",
"0.6618439",
"0.66098475",
"0.6549192",
"0.6508206",
"0.6430022",
"0.63941205",
"0.63530207",
"0.6349969",
"0.634504... | 0.7016211 | 6 |
This function computes the MAC of message using key. The MAC function is CBCMAC with AES and both single1 padding and length strengthening provided by the padding function. key must be convertible to bytes of length 16 messuge must be convertible to bytes type | def CBCMACbasedOnAES(message, key):
# Convert the message into bytes
message1 = bytes(message)
# Convert the key into bytes
key1 = bytes(key)
# Create the AES object
aes_obj = AES.new(key1, AES.MODE_CBC, iv)
# Encrypt the message
MAC = aes_obj.encrypt(message1)
# Return the MAC of ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cbc_mac(key, data):\n engine = AES.new(key, AES.MODE_CBC, get_zero_vector(16))\n return engine.encrypt(data)[-16:]",
"def make_hmac(message, key):\n h = HMAC.new(key)\n h.update(message)\n return h.hexdigest()",
"def get_cipher_key(key):\n k = (\n key[0] ^ key[4],\n ... | [
"0.7086036",
"0.611308",
"0.5901191",
"0.5669914",
"0.56285095",
"0.5557149",
"0.5410308",
"0.5361496",
"0.5354697",
"0.53063726",
"0.5291547",
"0.52718997",
"0.52700454",
"0.5262614",
"0.5262613",
"0.5235734",
"0.5188047",
"0.5168812",
"0.5162046",
"0.51358014",
"0.5132436",... | 0.80590457 | 0 |
Split the main histogram file into a number of files based on the xaxis of the histograms. You can put all met_0j histograms into a single file and all met_1j1b histograms into a single file. | def split4fit(infile, histogram_list=['met_0j','met_1pj']):
import ROOT
outpfx = infile.split('.root')[0]
if '/' in outpfx:
outpfx = outpfx.split('/')[-1]
infile = ROOT.TFile(infile,'read')
lok = [str(o.GetName()) for o in infile.GetListOfKeys()]
def make_a_file(hist_name):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_histograms(self, folder_name):\n histograms_folder_name = folder_name + '_histograms'\n\n try:\n print(\"Making dir \" + str(histograms_folder_name) + \" for histograms\")\n os.mkdir(histograms_folder_name)\n except OSError:\n print(\"Folder exists, hav... | [
"0.5699574",
"0.5582589",
"0.5546733",
"0.55327415",
"0.54630715",
"0.54044586",
"0.53796023",
"0.5354796",
"0.5354093",
"0.53540707",
"0.5308832",
"0.5264176",
"0.52597815",
"0.52456474",
"0.5224068",
"0.51899284",
"0.51747006",
"0.51713526",
"0.5169178",
"0.5167327",
"0.516... | 0.70357597 | 0 |
Creates an ordered list of archers with their score, hits and golds from the excel file containing all scores, named "OutdoorScores.xlsx" | def CategoryScore(Category):
Category = pd.read_excel('OutdoorScores.xlsx', Category ,
usecols=[0,1,2,3,4])
ResultCategory = Category.sort_values(['Score','Golds','Hits'],
ascending=[False,False,False],na_position='last')
ResultCategory = Resu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_leaders():\n wb = openpyxl.load_workbook(filename='leaderboard.xlsx')\n sheet = wb['Sheet1']\n names = []\n ascores = []\n i = 1\n for j in range(10):\n names.append(str(sheet.cell(row=i, column=1).value))\n ascores.append(int(sheet.cell(row=i, column=2).value))\n i... | [
"0.6795039",
"0.6045968",
"0.5869129",
"0.5824975",
"0.5738895",
"0.5729558",
"0.5721775",
"0.5709046",
"0.5646328",
"0.5606915",
"0.55951196",
"0.5586269",
"0.5577598",
"0.548148",
"0.5480782",
"0.54732007",
"0.5448698",
"0.5438781",
"0.5431352",
"0.5423162",
"0.5350822",
... | 0.48932105 | 91 |
Function to print individual scores per category | def PrintCategoryScore(Cat):
print()
print("########## Individual Category Results ##########")
for i in range(len(Cat)): # prints out the results per category
print()
print(Cat[i])
print(CategoryScore(Cat[i]))
print()
return print("----- End of Individuals Categor... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_scores(result_collector):\n # print(\"\\n# Metric: Cohen's kappa\")\n # result_collector.set_metric(['k_cohen', 'k'])\n # result_collector.print_all_results()\n print(\"\\n# Metric: Macro avg. F1\")\n result_collector.set_metric([\"macro_avg\", \"fscore\"])\n # result_collector.print_al... | [
"0.67260253",
"0.6665418",
"0.66344786",
"0.6530227",
"0.65061975",
"0.6398446",
"0.62773705",
"0.62684315",
"0.6259877",
"0.6157813",
"0.6103413",
"0.6028164",
"0.5972317",
"0.5953665",
"0.59463376",
"0.5870147",
"0.57962006",
"0.5781991",
"0.5767299",
"0.57437664",
"0.57170... | 0.82049257 | 0 |
Combines all scores from all categories, except compound categories, such that an experienced team can be created. | def Combined_Non_Compound_Results(level):
CombinedResults = pd.DataFrame({},columns=['Name','Club','Score',
'Golds', 'Hits'])
# Initial empty dataframe to append in to
for i in level:
CombinedResults = CombinedResults.append(CategoryScore(i))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_all_evaluation(self, tag_bundle_set):\n categories_list = []\n for num, category in enumerate(self.categories):\n (is_matching_category, op_result_meta_info) = category.apply(tag_bundle_set)\n if is_matching_category:\n categories_list.append(\n ... | [
"0.6232284",
"0.5805466",
"0.56819975",
"0.5554579",
"0.55330455",
"0.5505344",
"0.53095824",
"0.52563643",
"0.5238515",
"0.51255673",
"0.5124239",
"0.50875473",
"0.50687027",
"0.50635606",
"0.50389135",
"0.501613",
"0.50091064",
"0.49548933",
"0.49239996",
"0.4914003",
"0.49... | 0.5833497 | 1 |
"level" refers to either NovCategories or AllCategories, i.e. this function returns either novice or experienced teams, where experienced teams can contain novices. | def TeamScores(level,team_N):
groupresults = Combined_Non_Compound_Results(level).groupby('Club')
# groups clubs together in a big list just for NMR
# will need to generalise for all categories
LoR = [ frame for LoRs, frame in groupresults ]
TeamTable = pd.DataFrame({},columns=['... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_level(self, level):\n return",
"def getLevel(self, level):\n mingroup = None\n groups = self.console.storage.getGroups()\n\n for x in groups:\n\n if x.level < level:\n continue\n\n if mingroup is None:\n mingroup = x\n ... | [
"0.6421769",
"0.6160101",
"0.579061",
"0.57043594",
"0.5589996",
"0.5533693",
"0.54887515",
"0.54760265",
"0.5471949",
"0.5441435",
"0.541128",
"0.540279",
"0.53987706",
"0.5366603",
"0.5304298",
"0.52911276",
"0.5269117",
"0.5265375",
"0.52508336",
"0.5245916",
"0.52325886",... | 0.0 | -1 |
Initializer that takes in a list of number of neurons in each layer randn(m, n) returns m x n matrix of random numbers from a normal distribution zip(a, b) returns list of tuples with values from a, b | def __init__(self, sizes: list):
self.num_layers = len(sizes)
self.sizes = sizes
self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_random_matrix(n):\n return [[random.randint(1, 50) for i in range(n)] for j in range(n)]",
"def init_random_params(scale, layer_sizes, rs=npr.RandomState(0)):\n return [(scale * rs.randn(m, n), # weight matrix\n scale * rs.randn(n)) # bias vector\n for m, n in zip... | [
"0.6493381",
"0.6480992",
"0.6416156",
"0.6342152",
"0.62880176",
"0.6283137",
"0.6260111",
"0.6217703",
"0.6192845",
"0.6174658",
"0.6168335",
"0.6104254",
"0.60990536",
"0.60782176",
"0.60746795",
"0.6063433",
"0.60263085",
"0.60250354",
"0.59839183",
"0.59801257",
"0.59784... | 0.55047 | 80 |
Return the output of the network if is input | def feed_forward(self, a):
for b, w in zip(self.biases, self.weights):
a = sigmoid(np.dot(w, a) + b)
return a | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def input(self):\n connected_node = self.get_connected_node()\n if connected_node:\n #it is not possible to connect to an input\n return connected_node.output()\n return None",
"def pred_from_net_output(self, net_output: ALL_NET_OUTPUT) -> torch.Tensor:\n raise N... | [
"0.7112945",
"0.6837349",
"0.6812708",
"0.6740701",
"0.6722642",
"0.657854",
"0.6458213",
"0.6381645",
"0.63765216",
"0.6358677",
"0.625985",
"0.6219313",
"0.6201402",
"0.61769295",
"0.615385",
"0.6140945",
"0.61316967",
"0.60971904",
"0.60626006",
"0.6061749",
"0.606071",
... | 0.0 | -1 |
Train the neural net using minibatch stochastic gradient descent If is supplied, then the program will evaluate the network after each epoch training_data is a list of tuples (x, y) with x as input and y as expected output | def sgd(self, training_data: list, num_epochs: int, mini_batch_size: int, eta: float, test_data=None):
n = len(training_data)
for j in range(num_epochs):
random.shuffle(training_data)
mini_batches = [training_data[k: k + mini_batch_size] for k in range(0, n, mini_batch_size)]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def miniBatchStochasticGD(self, x, y, batchSize, epochs):\n print(\"Training using stochastic minibatch gradient descent\")\n epoch = 0\n fullSetSize = x.shape[0]\n #output training progress ten times in run\n outputChunk = int ( epochs / 10 )\n\n while epoch <= epochs:\n ... | [
"0.72270536",
"0.71475214",
"0.7036032",
"0.7021487",
"0.69404864",
"0.69394267",
"0.69327646",
"0.69167167",
"0.6907639",
"0.6885638",
"0.68781966",
"0.6866682",
"0.68590695",
"0.68407106",
"0.68397886",
"0.6797864",
"0.6782636",
"0.67748296",
"0.6770139",
"0.676445",
"0.676... | 0.0 | -1 |
Update the biases and weights according to the minibatch | def update_mini_batch(self, mini_batch: list, eta: float):
# Create a set of biases and weights that are zeros
nabla_b = [np.zeros(b.shape) for b in self.biases]
nabla_w = [np.zeros(w.shape) for w in self.weights]
# Update gradients for biases and weights
for x, y in mini_batch:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_weights(self):\n\t\tpass",
"def update_weights(self):\n self._weights = self._weights + self.update_weights_value\n self.weights_clipping()",
"def update_mini_batch2_4(self, mini_batch, eta):\r\n nabla_b = [np.zeros(b.shape) for b in self.biases]\r\n nabla_w = [np.zeros(w... | [
"0.7421371",
"0.6991882",
"0.6848822",
"0.67945004",
"0.67168677",
"0.66101074",
"0.65153664",
"0.65024835",
"0.64673924",
"0.64332306",
"0.64307845",
"0.63667667",
"0.63380885",
"0.6334833",
"0.6333449",
"0.63224673",
"0.6308737",
"0.63058054",
"0.6305587",
"0.6304924",
"0.6... | 0.58211875 | 100 |
Return a tuple (nabla_b, nabla_w) representing the gradient for the cost function C_x Each of and are lists of NumPy arrays similar in structure to and | def backprop(self, x, y):
nabla_b = [np.zeros(b.shape) for b in self.biases]
nabla_w = [np.zeros(w.shape) for w in self.weights]
# Feed forward
activation = x
activations = [x]
zs = [] # Store the weighted inputs of each layer (z before activation function)
for ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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,\... | [
"0.6407299",
"0.6327713",
"0.6275338",
"0.6226583",
"0.6159513",
"0.60856426",
"0.6059724",
"0.6057005",
"0.60185087",
"0.6004246",
"0.5938753",
"0.5938481",
"0.5900218",
"0.58863527",
"0.5880659",
"0.5858331",
"0.57814264",
"0.5776528",
"0.5766199",
"0.5753891",
"0.5751687",... | 0.0 | -1 |
Return the number of test inputs for which the neural network outputs the correct result. Note that the neural network's output is assumed to be the index of whichever neuron in the final layer has the highest activation. | def evaluate(self, test_data):
test_results = [(np.argmax(self.feed_forward(x)), y) for (x, y) in test_data]
return sum(int(x == y) for (x, y) in test_results) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_network(neural_network, test_data):\n total_trials = 0\n correct_trials = 0\n output_values = [np.argmax(neural_network.calculate_output(vector[1])) for vector in test_data]\n expected_values = list(zip(*test_data))[0]\n for expected, recieved in zip(expected_values,output_values):\n ... | [
"0.71643096",
"0.678337",
"0.66984856",
"0.6695219",
"0.6695219",
"0.6681218",
"0.6619715",
"0.66186917",
"0.6527112",
"0.6512901",
"0.6510943",
"0.6478449",
"0.64484787",
"0.6436919",
"0.6436919",
"0.6424878",
"0.6382965",
"0.6375347",
"0.6356472",
"0.634797",
"0.6315814",
... | 0.621531 | 24 |
Return the vector of partial derivatives \partial C_x / \partial a for the output activations Based on the quadratic cost function C(x) = 1/(2n) (y a^L(x))^2 where x is input y is expected output a^L is the actual output | def cost_derivative(self, output_activations, y):
return (output_activations-y) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cost_derivative(self, output_activations, y):\r\n return (output_activations-y)",
"def cost_derivative(output_activations, y):\n return (output_activations - y)",
"def cost_derivative(self, output_activations, y):\n\t\treturn (output_activations - y)",
"def deriv_costFunction(self, x, y... | [
"0.63106906",
"0.6288777",
"0.6248431",
"0.61870795",
"0.61130613",
"0.60892075",
"0.6084112",
"0.6036914",
"0.60203856",
"0.59552675",
"0.5933606",
"0.5922783",
"0.59008473",
"0.5899504",
"0.58983827",
"0.5898196",
"0.5894403",
"0.58335376",
"0.57893485",
"0.5781006",
"0.577... | 0.62181246 | 6 |
Derivative of the sigmoid function. | def sigmoid_prime(z):
return sigmoid(z)*(1-sigmoid(z)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sigmoid_derivative(x):\n return x * (1-x)",
"def sigmoid_derivative(x):\n return x * (1.0 - x)",
"def sigmoid_derivative(x):\n\n return sigmoid(x) * (1 - sigmoid(x))",
"def derivative_sigmoid(x):\n return x * (1 - x)",
"def derivative_sigmoid(x):\n return x * (1 - x)",
"def sigmoid_der... | [
"0.84754366",
"0.8450928",
"0.8396931",
"0.83485264",
"0.83485264",
"0.8298343",
"0.80539966",
"0.7753385",
"0.77070266",
"0.7498153",
"0.7464916",
"0.7454039",
"0.7401582",
"0.7385017",
"0.73829913",
"0.7346935",
"0.7321687",
"0.73094004",
"0.7192053",
"0.7113881",
"0.709236... | 0.0 | -1 |
TM_fluid returns the 2x2 Transfer Matrix of a fluid layer | def TM_fluid(layer, kx, om):
h = layer.d
rho = layer.medium.rho
K = layer.medium.K
k = om*np.sqrt(rho/K)
ky = np.sqrt(k**2-kx**2)
T = np.zeros((2, 2), dtype=complex)
T[0, 0] = np.cos(ky*h)
T[1, 0] = (om**2*rho/ky)*np.sin(ky*h)
T[0, 1] = -(ky/(om**2*rho))*np.sin(ky*h)
T[1, 1] = n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fluid_func(self):\n residual = []\n for fluid, x in self.inl[0].fluid.val.items():\n res = x * self.inl[0].m.val_SI\n for o in self.outl:\n res -= o.fluid.val[fluid] * o.m.val_SI\n residual += [res]\n return residual",
"def fluid_func(self)... | [
"0.5768485",
"0.56176883",
"0.5443617",
"0.5435858",
"0.5388646",
"0.53567904",
"0.53567904",
"0.53390956",
"0.52819616",
"0.52702206",
"0.52634484",
"0.5213695",
"0.5176987",
"0.51402587",
"0.50595313",
"0.50586605",
"0.5050682",
"0.5046748",
"0.5044931",
"0.49993876",
"0.49... | 0.6433278 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.