= 2:\n model.addLayer(DenseLayer(num_neurons,activation()))\n if num_layers >= 3:\n model.addLayer(DenseLayer(num_neurons,activation()))\n\n model.addLayer(DenseLayer(Y.shape[1],LinearActivation()))\n model.initialize(QuadraticCost())\n \n Y_pred = model.predict((X_test - np.mean(X, axis = 0)) / np.std(X, axis = 0)) \n Y_pred = Y_pred * np.std(Y, axis = 0) + np.mean(Y, axis = 0)\n mse = np.mean(np.sqrt(np.sum((Y_pred - Y_test) ** 2, axis = 1))) \n return mse","def calculate_costs(self):\n cost_matrix = self.make_cost_matrix()\n \n if self.greedy:\n # Riesen et al., \"Greedy Graph Edit Distance\"\n costs = []\n psi = []\n \n for row in range(self.N):\n phi = self.M\n row_min = sys.maxint\n for column in range(self.N+self.M):\n if column not in psi:\n if cost_matrix[row, column] < row_min:\n row_min = cost_matrix[row, column]\n phi = column\n \n costs.append(row_min)\n if phi < self.M:\n psi.append(phi)\n \n for row in range(self.N, self.N+self.M):\n if (row - self.N) not in psi:\n costs.append(cost_matrix[row, row - self.N])\n else:\n # Riesen & Bunke, \"Approximate graph edit distance computation by means of bipartite graph matching\"\n row_ind, col_ind = optimize.linear_sum_assignment(cost_matrix)\n \n if self.verbose:\n for row, column in (row_ind, col_ind):\n value = cost_matrix[row, column]\n print '%d, %d, %.4f' % (row, column, value)\n \n return row_ind, col_ind, cost_matrix[row_ind, col_ind]","def deepnn(self, x, ind):\n '''\n print(x.shape)\n indices = ind\n self.ind = ind\n depth = 18\n oh = tf.one_hot(indices, depth)\n self.oh = oh\n\n s = tf.matmul(oh, self.scale)\n self.s = s\n \n '''\n \n \n #h_layer1 = tf.layers.dense(inputs=x, units=1, name='h0', activation=tf.nn.relu)\n #h_layer0 = tf.layers.dense(inputs=x, units=100, name='h0', activation=tf.nn.relu)\n #h_layer0_drop = tf.nn.dropout(h_layer0, self.keep_prob, name='h0_drop')\n #h_layer1 = tf.layers.dense(inputs = h_layer0, units = 1, name = 'h1', activation = tf.nn.relu)\n \n stop1 = int(self._xdims/3)\n x1 = x[:,:stop1]\n x2 = x[:,stop1:2*stop1]\n x3 = x[:,2*stop1:3*stop1]\n #x4 = x[:,3*stop1:4*stop1]\n #x5 = x[:,4*stop1:]\n d1 = tf.layers.dense(inputs=x1, units=100, name='h0_1', activation=tf.nn.relu)\n d1_layer0_drop = tf.nn.dropout(d1, self.keep_prob, name='d1_drop')\n d2 = tf.layers.dense(inputs=x2, units=100, name='h0_2', activation=tf.nn.relu)\n d2_layer0_drop = tf.nn.dropout(d2, self.keep_prob, name='d2_drop')\n d3 = tf.layers.dense(inputs=x3, units=100, name='h0_3', activation=tf.nn.relu)\n d3_layer0_drop = tf.nn.dropout(d3, self.keep_prob, name='d3_drop')\n #d4 = tf.layers.dense(inputs=x2, units=100, name='h0_4', activation=tf.nn.relu)\n #d4_layer0_drop = tf.nn.dropout(d4, self.keep_prob, name='d2_drop')\n #d5 = tf.layers.dense(inputs=x3, units=100, name='h0_5', activation=tf.nn.relu)\n #d5_layer0_drop = tf.nn.dropout(d5, self.keep_prob, name='d3_drop')\n \n layer_2 = tf.concat([d1,d2,d3],1)#,d4,d5], 1)\n h_layer1 = tf.layers.dense(inputs=layer_2, units=1, name='output', activation=tf.nn.relu)\n \n '''\n out = tf.multiply(s,h_layer1)\n self.out = out\n self.h0 = h_layer1\n return out\n '''\n return h_layer1","def run_visualization(image):\n # for image in images:\n try:\n with tf.gfile.FastGFile(image, 'rb') as f:\n jpeg_str = f.read()\n original_im = Image.open(BytesIO(jpeg_str))\n except IOError:\n print('Cannot retrieve image')\n return\n\n # print('running deeplab on image {0}'.format(image))\n resized_im, seg_map = MODEL.run(original_im)\n seg_map = seg_map.astype(np.uint8) * 255\n resized_im = np.array(resized_im, dtype=np.uint8)\n resized_im = cv2.cvtColor(resized_im, cv2.COLOR_BGR2RGB)\n # vis_segmentation(resized_im, seg_map,FULL_COLOR_MAP ,LABEL_NAMES)\n overlay_image = cv2.addWeighted(resized_im, 0.8, cv2.merge((seg_map * 0, seg_map, seg_map * 0)), 0.2, 0)\n # time.sleep(params.SEC_BETWEEN_PREDICTION)\n\n return resized_im, seg_map, overlay_image.astype(np.uint8)","def make_neural_net_challenging():\n i0 = Input('i0', -1.0) # this input is immutable\n i1 = Input('i1', 0.0)\n i2 = Input('i2', 0.0)\n seed_random()\n wt1 = random_weight()\n wt2 = random_weight()\n wt3 = random_weight()\n wt4 = random_weight()\n wt5 = random_weight()\n wt6 = random_weight()\n wt7 = random_weight()\n wt8 = random_weight()\n wt9 = random_weight()\n wt10 = random_weight()\n\t\n w1A = Weight('w1A', wt1)\n w2A = Weight('w2A', wt2)\n w1B = Weight('w1B', wt3)\n w2B = Weight('w2B', wt4)\n wA = Weight('wA', -1)\n wB = Weight('wB', -1)\n wAC = Weight('wAC', wt5)\n wBC = Weight('wBC', wt6)\n wC = Weight('wC', -1)\n wAD = Weight('wAD', wt7)\n wBD = Weight('wBD', wt8)\n wD = Weight('wD', -1)\n wCE = Weight('wCE', wt9)\n wDE = Weight('wDE', wt10)\n wE = Weight('wE', -1)\n\n # Inputs must be in the same order as their associated weights\n A = Neuron('A', [i1,i2,i0], [w1A,w2A,wA])\n B = Neuron('B', [i1,i2,i0], [w1B,w2B,wB])\n C = Neuron('C', [A,B,i0], [wAC,wBC,wC])\n D = Neuron('D', [A,B,i0], [wAD,wBD,wD])\n E = Neuron('D', [C,D,i0], [wCE,wDE,wE])\n P = PerformanceElem(E, 0.0)\n\n net = Network(P,[A, B, C, D, E])\n return net","def add_objective(self): \n \n if \"CSS\" in self.algorithm:\n \n if self.num_hidden == 0:\n \n data_term = self.compute_energy(self.x, self.batch_size)\n \n else:\n \n data_term = self.compute_free_energy(self.x)\n \n normalizer_term = self.add_css_approximation(data_term)\n \n if \"CD\" in self.algorithm and self.num_hidden ==0:\n \n data_term = self.compute_energy(self.x, self.batch_size)\n \n normalizer_term = self.compute_energy(self.x_gibbs, \n self.batch_size)\n \n normalizer_term = -T.mean(normalizer_term)\n \n if \"CD\" in self.algorithm and self.num_hidden > 0:\n \n data_term = self.compute_free_energy(self.x)\n \n normalizer_term = self.compute_free_energy(self.rbm_cd_samples)\n \n normalizer_term = -T.mean(normalizer_term)\n \n # cost is negative log likelihood \n self.cost = T.mean(data_term) + normalizer_term","def compute_visuals(self):\n pass","def run():\n cons_in, soln_in, disc = make_discriminator()\n target, loss, accuracy, optimiser = make_training_nodes(disc)\n training_set_sampler = make_sampler(cons_in, soln_in, target)\n test_set_sampler = make_sampler(cons_in, soln_in, target)\n\n disc.get_session().run(tf.global_variables_initializer())\n\n fit(\n disc.get_session(),\n optimiser,\n training_set_sampler,\n 250,\n 2000,\n 32,\n [(\"Loss\", loss), (\"Accuracy\", accuracy)],\n )\n\n print(\n \"Validation accuracy: {}\".format(\n disc.feed(accuracy, test_set_sampler.batch(1024))\n )\n )\n\n plot_surface(\n evaluate_surface(\n lambda x, y: Circles.solve([0, 0, 0.25], [x, y, 0.25]),\n (-1, 1, 0.08),\n (-1, 1, 0.08),\n ),\n x_label=\"Solution x\",\n y_label=\"Solution y\",\n z_label=\"p(satisfied | x, y)\",\n )\n\n plot_surface(\n evaluate_surface(\n lambda x, y: disc.feed(\n disc.output_node, {cons_in: [[0, 0, 0.25]], soln_in: [[x, y, 0.25]]}\n )[0],\n (-1, 1, 0.08),\n (-1, 1, 0.08),\n ),\n x_label=\"Solution x\",\n y_label=\"Solution y\",\n z_label=\"p(satisfied | x, y)\",\n )","def negSamplingCostAndGradient(predicted, target, outputVectors, dataset,\n K=10):\n\n # Sampling of indices is done for you. Do not modify this if you\n # wish to match the autograder and receive points!\n indices = [target]\n indices.extend(getNegativeSamples(target, dataset, K))\n\n ### YOUR CODE HERE\n # Similar to softmax, we find the target matrix\n # v_c structured as 1xD matrix\n # u_o assume to be 1xD matrix\n # u_k assume to be K x D matrix\n # we pull the data assuming that each row represent one vector\n v_c = predicted\n u_o = outputVectors[target]\n u_k = outputVectors[indices]\n\n\n # The intermediary matrix outputs\n # z_o, h_o: single scalar number\n # z_k, h_k: K x 1 vector, wich each number associated with a neg sample\n z_o = np.dot(u_o, v_c)\n h_o = sigmoid(z_o)\n z_k = np.dot(u_k, v_c)\n h_k = sigmoid( - z_k)\n\n J_1 = - np.log(h_o)\n J_2 = - np.sum( np.log(h_k) )\n cost = J_1+ J_2\n\n # Return the gradient for the prediction function\n # the prediction vector interacts with both the predicted vector\n # the negative sample vectors so below are both parts of the gradient\n # here we are trying to increase the prediction matrix to maximize\n # the similarity with the predicted vector\n # output is a 1 x D matrix\n grad_pred_o = - (1 - h_o)*u_o\n\n # the second part is tyring to decrease\n # similarity with the negative sample vectors\n # K x 1 multiply be input is a k x D matrix, we will need to sum all negative samples\n # along the rows. output is a 1 x D matrix\n # reshape h_k so that it can multiple\n grad_pred_k = np.dot(( 1 - h_k).T, u_k)\n # find the predicted matrix gradient\n # output is a 1 x D matrix\n gradPred = grad_pred_o + grad_pred_k\n\n\n # Return the gradient of the output vector\n # create a matrix the same shape as outputVector\n grad = np.zeros(outputVectors.shape)\n # first find the gradient wrt to the target output vector\n # here we want to increase the similarity between\n # the target output vector and the center vector\n # outputs is a 1 x D matrix\n grad_u_o = - (1-h_o)*v_c\n\n # print('***************grad_u_o************')\n # print(grad_u_o)\n # print(grad_u_o.shape)\n # replace the target row in output vector gradient\n grad[target, ] = grad_u_o\n # then find the gradient descent of all the u_k matrices\n # K x 1 matrix multiply by 1 x 3\n # K x D\n grad_uk = - np.outer((h_k - 1), v_c)\n # print('***************grad_uk************')\n # print(grad_uk)\n # for each token (row) replace gradient\n for k in xrange(u_k.shape[0]):\n index = indices[k]\n grad[index] += grad_uk[k]\n\n ### END YOUR CODE\n return cost, gradPred, grad","def neural_net_ex4_ng():\n # ==================\n # read data\n dataset = loadmat('data/ex4data1.mat')\n print(dataset.keys())\n\n y = dataset['y'] # 5000 x 1\n print('dims y: ', y.shape)\n # print('y[0]: ', y[0])\n\n X = dataset['X'] # 5000 x 400\n print('dims X: ', X.shape)\n # print('X[0]: ', X[0])\n\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\n\n num_samples_test = X_test.shape[0]\n\n # ==================\n # display data\n\n # pick 20 examples and visualize them\n fig = plt.figure(figsize=(10, 8), facecolor='white')\n fig.add_subplot(651)\n samples = np.random.choice(num_samples_test, 10)\n print('samples:', samples)\n plt.imshow(X_test[samples, :].reshape(-1, 20).T, cmap=\"Greys\")\n plt.axis('off')\n\n # ==================\n # run neural net\n hidden_layer_size = 25\n\n mlp = MLPClassifier(hidden_layer_sizes=(25,), max_iter=20, alpha=1e-4,\n solver='sgd', verbose=False, tol=1e-4, random_state=1,\n learning_rate_init=.1)\n mlp.fit(X_train, y_train.ravel())\n\n predictions = mlp.predict(X_test)\n print('Test set accuracy: {} %'.format(np.mean(predictions == y_test.ravel())*100))\n\n # print(confusion_matrix(y_test, predictions))\n # print(classification_report(y_test, predictions))\n print(\"Training set score: %f\" % mlp.score(X_train, y_train))\n print(\"Test set score: %f\" % mlp.score(X_test, y_test))\n print('coeffs shape', (mlp.coefs_[0]).shape)\n\n # ==================\n # display coefficients of hidden layer\n fig.add_subplot(652)\n plt.imshow(mlp.coefs_[0][:, 0].reshape(20, 20))\n plt.axis('off')\n\n gs = gridspec.GridSpec(6, 5)\n cur_img_idx = 5\n\n # use global min / max to ensure all weights are shown on the same scale\n vmin, vmax = mlp.coefs_[0].min(), mlp.coefs_[0].max()\n for coef, ax in zip(mlp.coefs_[0].T, range(hidden_layer_size)):\n fig.add_subplot(gs[cur_img_idx])\n plt.imshow(coef.reshape(20, 20), cmap=plt.cm.gray, vmin=.5 * vmin, vmax=.5 * vmax)\n plt.axis('off')\n cur_img_idx += 1\n\n plt.show()","def __init__(self, input_nodes, hidden_nodes, hidden_layers, output_nodes):\n # Class members:\n # num_input_nodes\n # num_hidden_nodes\n # num_hidden_layers\n # num_output_nodes\n # weights = [[num_hidden_nodes, num_input_nodes],[num_hidden_nodes, num_hidden_nodes],[]<- for each hl,\n # [num_output_nodes, num_hidden_nodes]]\n # biases\n\n self.num_input_nodes = input_nodes\n self.num_hidden_nodes = hidden_nodes\n self.num_hidden_layers = hidden_layers\n self.num_output_nodes = output_nodes\n\n self.weights = []\n for i in range(self.num_hidden_layers + 1):\n if i is 0:\n # first weights array is input to hidden\n self.weights.append(.5 * np.random.rand(self.num_hidden_nodes, self.num_input_nodes) - .25)\n\n elif i < self.num_hidden_layers:\n # next weight array is hidden nodes to hidden nodes\n self.weights.append(.5 * np.random.rand(self.num_hidden_nodes, self.num_hidden_nodes) - .25)\n else:\n # last weight array is hidden nodes to output nodes\n self.weights.append(.5 * np.random.rand(self.num_output_nodes, self.num_hidden_nodes) - .25)\n\n self.biases = []\n for i in range(self.num_hidden_layers + 1):\n if i < self.num_hidden_layers:\n # for every hidden node there is a bias\n self.biases.append(0.5 * np.random.rand(self.num_hidden_nodes) - .25)\n else:\n # for the output node there is a bias as well\n self.biases.append(0.5 * np.random.rand(self.num_output_nodes) - .25)\n\n self.activation = np.vectorize(self.tanh, otypes=[float])","def optimize(self):\n self.output = self.net.forward(Variable(self.source))\n self.optimizer.zero_grad()\n self.loss = self.loss_function(self.output, Variable(self.target))\n self.loss.backward()\n self.optimizer.step()","def neural_network(X, Y, X_test, Y_test, num_neurons, activation):\n \n X_n = (X - np.mean(X, axis = 0)) / np.std(X, axis = 0)\n Y_n = (Y - np.mean(Y, axis = 0)) / np.std(Y, axis = 0)\n \n if activation == \"ReLU\":\n activation = ReLUActivation\n elif activation == \"tanh\":\n activation = TanhActivation\n else:\n print('Null activation')\n \n model = Model(X_n.shape[1])\n model.addLayer(DenseLayer(num_neurons, activation()))\n model.addLayer(DenseLayer(num_neurons, activation()))\n model.addLayer(DenseLayer(Y.shape[1],LinearActivation()))\n model.initialize(QuadraticCost())\n\n Y_pred = model.predict((X_test - np.mean(X, axis = 0)) / np.std(X, axis = 0)) \n Y_pred = Y_pred * np.std(Y, axis = 0) + np.mean(Y, axis = 0)\n mse = np.mean(np.sqrt(np.sum((Y_pred - Y_test) ** 2, axis = 1))) \n\n return mse","def runNN(selectables_interests=[[0.0, 0.1, 0.6, 0.7], [0.0, 0.5, 0.6, 1]], profile_interests = [0.0, 0.1, 0.2, 0.3]):\n #Intialise a single neuron neural network.\n # Apply vertical normalisation for the pageobject interests\n if len(selectables_interests)>0:\n selectables_interests = normalize(selectables_interests, axis=0, norm='l1')\n else:\n # If there is nothing to compare it to, return the current profile.\n return profile_interests\n # For the given size of the first element in the array (number of interests) add a dimension of such size\n Interest_Array_Inputs = [[] for i in range(len(selectables_interests[0]))]\n Interest_Array_Outputs = [[] for i in range(len(selectables_interests[0]))]\n # Creating instances of 3 dimensional Inputs/Outputs sets\n for ida, ll in enumerate(selectables_interests):\n # For the number of permutations\n current_fuzzy_element_permutation = fuzzy_permutation(ll)\n for index in range(len(current_fuzzy_element_permutation[0])):\n # Insert array inside column Interest for the input, output.\n Interest_Array_Inputs[current_fuzzy_element_permutation[0][index][0]].append(current_fuzzy_element_permutation[0][index][1][:])\n Interest_Array_Outputs[current_fuzzy_element_permutation[1][index][0]].append([current_fuzzy_element_permutation[1][index][1]])\n profile_Interest_Inputs = []\n # Creating the list of inputs (Leaving out an interest to be predicted)\n for index, inputList in enumerate(fuzzy_permutation(profile_interests)[0]):\n profile_Interest_Inputs.append(inputList[1])\n\n collected_interests = []\n # Training on each individual interest\n for i in range(len(profile_interests)):\n collected_interests.append(initialise_train_result(Interest_Array_Inputs[i], Interest_Array_Outputs[i], profile_Interest_Inputs[i]))\n well_ordered_interests = collected_interests[::-1]\n # Returns the outcoming interests.\n return well_ordered_interests","def nnCostFunction2(nn_params, input_layer_size, hidden_layer_size, num_labels, X, y, lambda_):\n # Reshape nn_params back into the parameters Theta1 and Theta2, the weight matrices\n # for our 2 layer neural network\n Theta1 = nn_params[:hidden_layer_size * (input_layer_size + 1)].reshape(\n (hidden_layer_size, input_layer_size + 1))\n Theta2 = nn_params[hidden_layer_size *\n (input_layer_size + 1):].reshape((num_labels, hidden_layer_size + 1))\n\n # Setup some useful variables\n m = X.shape[0]\n\n # Add ones to the X data matrix\n X = np.insert(X, 0, 1, axis=1)\n\n # Perform forward propagation for layer 2\n z2 = np.matmul(X, Theta1.transpose())\n a2 = sigmoid(z2)\n a2 = np.insert(a2, 0, 1, axis=1)\n z3 = np.matmul(a2, Theta2.transpose())\n a3 = sigmoid(z3)\n\n # turn Y into a matrix with a new column for each category and marked with 1\n y_one_hot = np.zeros_like(a3)\n for i in range(m):\n y_one_hot[i, y[i] - 1] = 1\n\n # Calculate the cost of our forward prop\n ones = np.ones_like(a3)\n A = np.matmul(y_one_hot.transpose(), np.log(a3)) + \\\n np.matmul((ones - y_one_hot).transpose(), np.log(ones - a3))\n J = -1 / m * A.trace()\n J += lambda_ / (2 * m) * \\\n (np.sum(Theta1[:, 1:] ** 2) + np.sum(Theta2[:, 1:] ** 2))\n\n # Perform backward propagation to calculate deltas & gradients\n delta3 = a3 - y_one_hot\n delta2 = np.matmul(delta3, Theta2[:, 1:]) * sigmoidGradient(z2)\n Theta2_grad = np.matmul(a2.transpose(), delta3).transpose()\n Theta1_grad = np.matmul(X.transpose(), delta2).transpose()\n\n Theta1_grad[:, 1:] += lambda_ * Theta1[:, 1:]\n Theta2_grad[:, 1:] += lambda_ * Theta2[:, 1:]\n Theta1_grad /= m\n Theta2_grad /= m\n grad = np.concatenate([Theta1_grad.reshape(-1), Theta2_grad.reshape(-1)])\n return J, grad","def optimize(self):\n\n self.logger.info(\"Solving with Dynamic Slope Scaling Procedure in Julia :\")\n optimization_start = time.time()\n\n # 1. Preprocess for old network graph\n if self.old_network_graph is not None:\n\n # DSSP on old network\n old_network_obj = sum(list(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).values()))-1e-5\n try:\n self.check_infeasibility(self.old_network_graph, old_network_obj)\n except DHCOptimizerException as e:\n e.data = \"Invalid existing network: \" + e.data\n raise e\n\n flows, obj_val = self.optimize_with_dssp_julia(self.old_network_graph, old_network_obj, set())\n self.logger.info(\"Optimization phase time: %.2fs\" % (time.time() - optimization_start))\n solution_old_graph = self.build_solution_graph(self.old_network_graph, flows)\n\n if self.modify_old_network:\n\n # Add max capacity on old edges\n self.old_capacity = deepcopy(flows)\n old_buildings = list(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).values())\n for key in flows:\n if (key[1],key[0],0) not in self.old_capacity and key[1] not in old_buildings:\n self.old_capacity[(key[1],key[0],0)] = self.old_capacity[key]\n\n # Add Imaginary edges\n for edge in self.old_capacity:\n if self.optimization_graph.has_edge(*edge):\n\n # add nodes\n if not self.optimization_graph.has_node(config.IM_PREFIX+edge[0]):\n self.optimization_graph.add_node(config.IM_PREFIX+edge[0])\n self.optimization_graph.nodes[config.IM_PREFIX+edge[0]][config.GPD_GEO_KEY] = \\\n self.optimization_graph.nodes[edge[0]][config.GPD_GEO_KEY]\n if not self.optimization_graph.has_node(config.IM_PREFIX+edge[1]):\n self.optimization_graph.add_node(config.IM_PREFIX+edge[1])\n self.optimization_graph.nodes[config.IM_PREFIX+edge[1]][config.GPD_GEO_KEY] = \\\n self.optimization_graph.nodes[edge[1]][config.GPD_GEO_KEY]\n # add edges\n if not self.optimization_graph.has_edge(edge[0],config.IM_PREFIX+edge[0]):\n self.optimization_graph.add_edge(edge[0],config.IM_PREFIX+edge[0])\n if not self.optimization_graph.has_edge(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1]):\n self.optimization_graph.add_edge(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1])\n if not self.optimization_graph.has_edge(config.IM_PREFIX+edge[1],edge[1]):\n self.optimization_graph.add_edge(config.IM_PREFIX+edge[1],edge[1])\n\n # put cost\n self.optimization_graph.edges[(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1],0)][config.EDGE_COST_KEY] = \\\n self.optimization_graph.edges[(edge[0],edge[1],0)][config.EDGE_COST_KEY]\n self.optimization_graph.edges[(edge[0],edge[1],0)][config.EDGE_COST_KEY] = 1e-5\n self.optimization_graph.edges[(edge[0],config.IM_PREFIX+edge[0],0)][config.EDGE_COST_KEY] = 1e-5\n self.optimization_graph.edges[(config.IM_PREFIX+edge[1],edge[1],0)][config.EDGE_COST_KEY] = 1e-5\n\n else:\n # if we don't modify the old network, we have to change the capacity of the supplies\n already_consummed = {}\n for edge in solution_old_graph.edges():\n if solution_old_graph.nodes[edge[0]].get(config.NODE_TYPE_KEY) == config.SUPPLY_NODE_TYPE:\n already_consummed[edge[0]] = already_consummed.get(edge[0], 0) + \\\n solution_old_graph.edges[edge][config.SOLUTION_POWER_FLOW_KEY]\n for source in already_consummed:\n if already_consummed[source] <= self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY]:\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] -= already_consummed[source]\n self.network_objective -= already_consummed[source]\n else:\n self.network_objective -= self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY]\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] = 0\n\n # Remove edges from old network\n edges_to_remove = set()\n for e in self.optimization_graph.edges():\n if self.old_network_graph.has_edge(*e) or self.old_network_graph.has_edge(e[1],e[0]):\n edges_to_remove.add(e)\n self.optimization_graph.remove_edges_from(edges_to_remove)\n\n # Remove isolated buildings of optimization graph\n isolated_to_remove = set()\n for e in self.old_network_graph.edges():\n if e[0] in self.old_network_graph.nodes() and \\\n self.optimization_graph.nodes[e[1]].get(config.NODE_TYPE_KEY) == config.BUILDING_NODE_TYPE:\n isolated_to_remove.add(e)\n self.optimization_graph.remove_edges_from(isolated_to_remove)\n\n # Remove buildings from old network\n for n, data in self.old_network_graph.nodes(data=True):\n if data.get(config.NODE_TYPE_KEY) == config.BUILDING_NODE_TYPE:\n self.optimization_graph.remove_node(n)\n\n # Re-link sources\n sources = set()\n for n, data in self.optimization_graph.nodes(data=True):\n if data.get(config.NODE_TYPE_KEY) == config.SUPPLY_NODE_TYPE:\n sources.add(n)\n source_graph = self.optimization_graph.subgraph(sources).copy()\n self.optimization_graph.remove_nodes_from(sources)\n gnx.remove_isolates(self.optimization_graph)\n node_filter = lambda n: self.optimization_graph.nodes.get(n,{}).get(config.NODE_TYPE_KEY) != config.BUILDING_NODE_TYPE\n gnx.spatial_points_merge(self.optimization_graph, source_graph.nodes_to_gdf(), node_filter=node_filter, inplace=True)\n\n # fill missing information\n gnx.fill_edges_missing_geometry_attributes(self.optimization_graph)\n gnx.fill_length_attribute(self.optimization_graph, config.EDGE_LENGTH_KEY, only_missing=True)\n gnx.fill_length_attribute(self.optimization_graph, config.EDGE_COST_KEY, only_missing=True)\n for e in self.optimization_graph.edges(keys=True):\n self.optimization_graph.edges[e][config.LEASTCOST_COEF_KEY] = \\\n self.optimization_graph.edges[e].get(config.LEASTCOST_COEF_KEY,0)\n\n\n\n # 2. Process the DSSP on optimization graph\n self.check_is_ready()\n self.check_infeasibility(self.optimization_graph, self.network_objective)\n\n if self.old_network_graph is not None and self.modify_old_network:\n old_buildings = set(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).keys())\n else:\n old_buildings = set()\n flows, obj_val = self.optimize_with_dssp_julia(self.optimization_graph, self.network_objective, old_buildings,postprocess= (not self.modify_old_network))\n self.logger.info(\"Optimization phase time: %.2fs\" % (time.time() - optimization_start))\n self.solution_graph = self.build_solution_graph(self.optimization_graph, flows, self.connected)\n\n # 3. Postprocess for old network graph\n if self.old_network_graph is not None:\n \n if self.modify_old_network:\n # Put the right supply capacity and cost\n for edge in self.old_capacity:\n if self.solution_graph.has_edge(edge[0],edge[1]):\n self.solution_graph.edges[(edge[0],edge[1])][config.EDGE_COST_KEY] = \\\n self.optimization_graph.edges[(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1],0)][config.EDGE_COST_KEY]\n \n # Remove imaginary edges\n imaginary_nodes_to_remove = set()\n nodes_to_relabel = {}\n for edge in self.solution_graph.edges():\n if str(edge[0]).startswith(config.IM_PREFIX) and str(edge[1]).startswith(config.IM_PREFIX):\n real_edge = edge[0][len(config.IM_PREFIX):],edge[1][len(config.IM_PREFIX):]\n self.old_capacity[(real_edge[0], real_edge[1], 0)] = pd.np.inf\n self.old_capacity[(real_edge[1], real_edge[0], 0)] = pd.np.inf\n if not self.solution_graph.has_edge(*real_edge):\n for i in range(2):\n nodes_to_relabel[edge[i]] = real_edge[i]\n else:\n self.solution_graph.edges[real_edge[0],real_edge[1]][config.SOLUTION_POWER_FLOW_KEY] += \\\n self.solution_graph.edges[edge].get(config.SOLUTION_POWER_FLOW_KEY,0)\n imaginary_nodes_to_remove.add(edge[0])\n imaginary_nodes_to_remove.add(edge[1])\n elif str(edge[0]).startswith(config.IM_PREFIX):\n imaginary_nodes_to_remove.add(edge[0])\n elif str(edge[1]).startswith(config.IM_PREFIX):\n imaginary_nodes_to_remove.add(edge[1])\n\n nx.relabel_nodes(self.solution_graph, nodes_to_relabel, copy=False)\n self.solution_graph.remove_nodes_from(list(imaginary_nodes_to_remove))\n for node in nodes_to_relabel.values():\n if self.solution_graph.has_edge(node, node):\n self.solution_graph.remove_edge(node, node)\n\n else:\n for source in nx.get_node_attributes(self.solution_graph, config.SUPPLY_POWER_CAPACITY_KEY):\n self.solution_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] += already_consummed.get(source,0)\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] += already_consummed.get(source,0)\n\n return flows, obj_val","def negSamplingCostAndGradient(predicted, target, outputVectors, dataset,\n K=10):\n\n # Sampling of indices is done for you. Do not modify this if you\n # wish to match the autograder and receive points!\n indices = [target]\n indices.extend(getNegativeSamples(target, dataset, K))\n\n ### YOUR CODE HERE\n #The cost now is maximize the predicted and target pair,\n #minimizing the predicted and the sampled pairs\n cost = 0\n gradPred = np.zeros(predicted.shape[0])\n grad = np.zeros(outputVectors.shape)\n\n for indice in indices:\n target_vector = outputVectors[indice]\n vector_product = np.dot(target_vector,predicted)\n if indice != target:\n cost += -np.log(sigmoid(-vector_product))\n gradPred += sigmoid(vector_product)*target_vector\n # use += in case of repeatance\n grad[indice,:] += sigmoid(vector_product)*predicted\n else:\n cost += -np.log(sigmoid(vector_product))\n gradPred += (sigmoid(vector_product) - 1)*target_vector\n grad[indice,:] += (sigmoid(vector_product)-1)*predicted\n ### END YOUR CODE\n #print indices\n\n return cost, gradPred, grad","def sim_average_cost(self, dictionary):\n\t\tif toggles.DEBUG_FLAG:\n\t\t\tprint \"Running: sim_average_cost\"\n\t\tf = open(toggles.OUTPUT_PATH + toggles.RUN_NAME + '_estimated_costs.csv', 'a')\n\n\t\tfor p in toggles.CHOSEN_PREDS:\n\t\t\tpred_cost = 0.0\n\t\t\tpred = Predicate.objects.all().get(pk=p+1)\n\t\t\tf.write(pred.question.question_text + '\\n')\n\n\t\t\t#iterate through to find each ip cost\n\t\t\tfor ip in IP_Pair.objects.filter(predicate=pred):\n\t\t\t\titem_cost = 0.0\n\t\t\t\t# sample toggles.COST_SAMPLES times\n\t\t\t\tfor x in range(toggles.COST_SAMPLES):\n\t\t\t\t\t# running one sampling\n\t\t\t\t\twhile ip.status_votes < toggles.NUM_CERTAIN_VOTES:\n\t\t\t\t\t\t# get the vote\n\t\t\t\t\t\tvalue = choice(dictionary[ip])\n\t\t\t\t\t\tif value == True:\n\t\t\t\t\t\t\tip.value += 1\n\t\t\t\t\t\t\tip.num_yes += 1\n\t\t\t\t\t\telif value == False:\n\t\t\t\t\t\t\tip.value -= 1\n\t\t\t\t\t\t\tip.num_no +=1\n\n\t\t\t\t\t\tip.status_votes += 1\n\n\t\t\t\t\t\t# check if ip is done\n\t\t\t\t\t\tif ip.status_votes == toggles.NUM_CERTAIN_VOTES:\n\t\t\t\t\t\t\t\tif ip.value > 0:\n\t\t\t\t\t\t\t\t\tuncertaintyLevel = btdtr(ip.num_yes+1, ip.num_no+1, toggles.DECISION_THRESHOLD)\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tuncertaintyLevel = btdtr(ip.num_no+1, ip.num_yes+1, toggles.DECISION_THRESHOLD)\n\t\t\t\t\t\t\t\tif uncertaintyLevel < toggles.UNCERTAINTY_THRESHOLD:\n\t\t\t\t\t\t\t\t\titem_cost += (ip.num_yes + ip.num_no)\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tip.status_votes -= 2\n\n\t\t\t\t\t# reset values\n\t\t\t\t\tip.value = 0\n\t\t\t\t\tip.num_yes = 0\n\t\t\t\t\tip.num_no = 0\n\t\t\t\t\tip.status_votes = 0\n\n\t\t\t\titem_cost = item_cost/float(toggles.COST_SAMPLES)\n\t\t\t\tpred_cost += item_cost\n\t\t\t\tf.write(ip.item.name + ': ' + str(item_cost) + \" \")\n\n\t\t\tpred_cost = float(pred_cost)/IP_Pair.objects.filter(predicate=pred).count()\n\t\t\tf.write('\\npredicate average cost: ' + str(pred_cost) + '\\n \\n')\n\t\tf.close()\n\t\tif toggles.DEBUG_FLAG:\n\t\t\tprint \"Wrote File: \" + toggles.OUTPUT_PATH + toggles.RUN_NAME + '_estimated_costs.csv'","def build_and_display_network():\n bpn = NeuralNetwork.BackPropagationNetwork((input_nodes, hidden_nodes, output_nodes),[None, sigmoid, linear])\n DisplayNetwork.displayLayers(bpn.matrixDimension)\n\n return bpn","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\")","def neural_network(z, dim_out):\n hidden_dim = 15\n net1 = slim.fully_connected(z, hidden_dim, activation_fn=None)\n net2 = slim.fully_connected(net1, dim_out, activation_fn=tf.tanh)\n return net2","def model(training_images, training_labels, validation_images, validation_labels, iteration_count, learning_rate, show_cost):\n\n\t# init weight and bias arrays\n\tw, b = init_zero(training_images.shape[0]) \n\n\t# train model and obtain weight and bias \n\tparameters, gradients, costs = gradient_descent(w=w, b=b, image_matrix=training_images, true_labels=training_labels,\n\t iteration_count=iteration_count, learning_rate=learning_rate, show_cost=show_cost)\n\n\tw = parameters[\"w\"]\n\tb = parameters[\"b\"]\n\n\tprediction_training_labels = predict(w, b, training_images)\n\tprediction_validation_labels = predict(w, b, validation_images)\n\n\t# Calculates the average proximity of each prediction to the true (normalized)\n\ttraining_accuracy = (1 - np.mean(np.abs(prediction_training_labels - training_labels)))\n\tvalidation_accuracy = (1 - np.mean(np.abs(prediction_validation_labels - validation_labels)))\n\n\tprint(\"training accuracy: %s\" % str(training_accuracy))\n\tprint(\"validation accuracy: %s\" % str(validation_accuracy))\n\n\tdata = {\n\t\"costs\": costs,\n\t\"prediction_training_labels\": prediction_training_labels,\n\t\"prediction_validation_labels\": prediction_validation_labels,\n\t\"original_training_labels\": training_class_set,\n\t\"original_validation_labels\": validation_class_set,\n\t\"w\": w,\n\t\"b\": b,\n\t\"learning_rate\": learning_rate,\n\t\"interation_count\": iteration_count\n\t}\n\n\treturn data","def model(X_train, Y_train, X_dev, Y_dev, numOutputNodes, learning_rate = 0.003,\n iterations = 2000, minibatch_size = 16, layer1 = 25, beta = 0, dropout = 1.0, istanh1 = False, batchnorm = True, print_cost = True, is_charge = False):\n \n # reset all variables to allow the network to be trained multiple times with different hyperparameters\n sess = tf.Session()\n tf.reset_default_graph()\n\n tf.set_random_seed(1) # to keep consistent results\n seed = 1 # to keep consistent results\n (n_x, m) = X_train.shape # n_x : input size (the other dimension is the number of examples in the train set)\n n_y = Y_train.shape[0] # n_y : output size\n costs = [] # holds data for graphing\n dev_costs = []\n \n # Create Placeholders of shape (n_x, n_y)\n X, Y = create_placeholders(n_x, n_y)\n parameters = initialize_parameters(layer1, 1, regression = True) # Initialize parameters, with one hidden layer\n training = tf.placeholder_with_default(False, shape=(), name='training') # Create a boolean to use for implementing batch norm and dropout correctly\n\n # Forward propagation: Build the forward propagation in the tensorflow graph\n Z3 = forward_propagation(X, parameters, training, istanh1, False, batchnorm, dropout, regression = True)\n\n # Cost function: Add cost function to tensorflow graph\n cost = compute_reg_cost(Z3, Y, parameters, beta)\n\n update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) # allows for prediction at test time to work with batch normalization; allows for updating of global mean and variance\n with tf.control_dependencies(update_ops):\n # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.\n optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)\n\n # Initialize all the variables\n init = tf.global_variables_initializer()\n saver = tf.train.Saver()\n\n # Calculate the correct predictions\n correct_prediction = tf.less_equal(tf.abs(tf.divide(tf.subtract(Z3, Y), Y)), tf.fill([1,1], 0.05)) \n # define one measure of accuracy by counting a prediction as correct if it's within 5% of the true value\n \n # Calculate the mean absolute percentage error of the predictions\n MAPE = tf.scalar_mul(100, tf.reduce_mean(tf.abs(tf.divide(tf.subtract(Z3, Y), Y))))\n\n # Calculate accuracy on the test set\n accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n\n # Start the session to compute the tensorflow graph\n with tf.Session() as sess:\n sess.run(init)\n\n # Print the hyperparameters for this particular model\n print('Learning Rate: %s, Mini-Batch Size: %d, Beta: %s, %d Nodes in Hidden Layer, %d Output Nodes, %d Iterations, %s Dropout Prob, Hidden Layer Tanh: %s, Batch Norm: %s' \\\n % (str(learning_rate).rstrip('0'), minibatch_size, str(beta).rstrip('0'), layer1, numOutputNodes, iterations, str(dropout).rstrip('0'), istanh1, batchnorm))\n \n for epoch in range(iterations):\n epoch_cost = 0. # Defines a cost related to an epoch\n seed = seed + 1\n minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)\n num_minibatches = len(minibatches) \n\n for minibatch in minibatches:\n # Select a minibatch\n (minibatch_X, minibatch_Y) = minibatch\n \n # Run the session on one minibatch, and add the cost to the epoch cost\n _ , minibatch_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y, training: True})\n epoch_cost += minibatch_cost / num_minibatches\n \n # save the training and cross-validation cost every 5 epochs\n if print_cost == True and epoch % 5 == 0:\n costs.append(epoch_cost)\n dev_cost = sess.run(cost, feed_dict = {X: X_dev, Y: Y_dev, training: False})\n dev_costs.append(dev_cost)\n\n # print the cost after every 200 epochs\n if print_cost == True and epoch % 200 == 0: # used during testing to ensure gradient descent is working properly\n train_accuracy = accuracy.eval({X: X_train, Y: Y_train, training: False})\n train_mape = MAPE.eval({X: X_train, Y: Y_train, training: False})\n print(\"Training cost after iteration %i: %f, accuracy: %f, MAPE: %f %%\" % (epoch, epoch_cost, train_accuracy, train_mape))\n \n dev_cost = sess.run(cost, feed_dict={X:X_dev, Y: Y_dev, training: False})\n dev_accuracy = accuracy.eval({X: X_dev, Y: Y_dev, training: False})\n dev_mape = MAPE.eval({X: X_dev, Y: Y_dev, training: False})\n print(\"Dev cost after iteration %i: %f, accuracy: %f, MAPE: %f %%\" % (epoch, dev_cost, dev_accuracy, dev_mape))\n\n # # Plot the cost\n # if print_cost:\n # iter_num = np.arange(iterations / 5) * 5\n # plt.plot(iter_num, np.squeeze(costs), label = 'training')\n # plt.plot(iter_num, np.squeeze(dev_costs), label = 'cross-validation')\n # plt.ylabel('cost')\n # plt.xlabel('iterations')\n # # plt.ylim(top = 0.01, bottom = 0.002) # y range used to plot for averaged spectra\n # plt.ylim(top = 0.0075, bottom = 0.001) # y range used to plot for training on charges\n # plt.title('Cost vs. Iterations')\n # plt.legend()\n # plt.show()\n\n # Save the parameters in a variable\n parameters = sess.run(parameters)\n if is_charge:\n saver.save(sess, \"./charge_reg_models/charge_regression_model_{}_{}_{}_{}.ckpt\".format(learning_rate, iterations, layer1, beta))\n else:\n saver.save(sess, \"./reg_models/regression_model_{}_{}_{}_{}.ckpt\".format(learning_rate, iterations, layer1, beta))\n\n train_acc = accuracy.eval({X: X_train, Y: Y_train, training: False})\n dev_acc = accuracy.eval({X: X_dev, Y: Y_dev, training: False})\n \n mape_train = MAPE.eval({X: X_train, Y: Y_train, training: False})\n mape_dev = MAPE.eval({X: X_dev, Y: Y_dev, training: False})\n\n accs = [train_acc, dev_acc, mape_train, mape_dev]\n\n print(\"Train Accuracy:\", train_acc, \"; MAPE:\", mape_train)\n print(\"Dev Accuracy:\", dev_acc, \"; MAPE:\", mape_dev)\n\n return accs, parameters","def ComputeGradients(self, input_data: list, target_output_data: list):\n delta = 1e-6\n normal_cost = self.Cost(input_data, target_output_data)\n\n # Evaluate Gradient for Hidden Layer Biases\n for i in range(self.hidden_layer_biases.shape[0]):\n original_bias_value = self.hidden_layer_biases[i]\n self.hidden_layer_biases[i] += delta\n plusdelta_cost = self.Cost(input_data, target_output_data)\n self.hidden_layer_biases[i] = original_bias_value\n self.hidden_biases_gradient[i] = (plusdelta_cost - normal_cost) / delta\n\n # Evaluate Gradient for Output Layer Biases\n for i in range(self.output_layer_biases.shape[0]):\n original_bias_value = self.output_layer_biases[i]\n self.output_layer_biases[i] += delta\n plusdelta_cost = self.Cost(input_data, target_output_data)\n self.output_layer_biases[i] = original_bias_value\n self.output_biases_gradient[i] = (plusdelta_cost - normal_cost) / delta\n\n # Evaluate Gradient for Input Layer to Hidden Layer Weights\n for i in range(self.input_to_hidden_weights.shape[0]):\n for h in range(self.input_to_hidden_weights.shape[1]):\n original_bias_value = self.input_to_hidden_weights[i, h]\n self.input_to_hidden_weights[i, h] += delta\n plusdelta_cost = self.Cost(input_data, target_output_data)\n self.input_to_hidden_weights[i, h] = original_bias_value\n self.input_to_hidden_weights_gradient[i, h] = (plusdelta_cost - normal_cost) / delta\n\n # Evaluate Gradient for Input Layer to Hidden Layer Weights\n for h in range(self.hidden_to_output_weights.shape[0]):\n for o in range(self.hidden_to_output_weights.shape[1]):\n original_bias_value = self.hidden_to_output_weights[h, o]\n self.hidden_to_output_weights[h, o] += delta\n plusdelta_cost = self.Cost(input_data, target_output_data)\n self.hidden_to_output_weights[h, o] = original_bias_value\n self.hidden_to_output_weights_gradient[h, o] = (plusdelta_cost - normal_cost) / delta","def nn(data):\n training_set = SupervisedDataSet*\n\n\n input_nodes = 3\n hidden_layer_1 = 10\n hidden_layer_2 = 10\n output_layer = 5\n\n net = buildNetwork(input_nodes, hidden_layer_1, hidden_layer_2, output_layer, bias=True, hiddenclass=TanhLayer)","def Solve(self, cost, termination=None, ExtraArgs=(), **kwds):\n # process and activate input settings\n sigint_callback = kwds.pop('sigint_callback', None)\n settings = self._process_inputs(kwds)\n disp = settings['disp'] if 'disp' in settings else False\n echo = settings['callback'] if 'callback' in settings else None\n# for key in settings:\n# exec \"%s = settings['%s']\" % (key,key)\n if disp in ['verbose', 'all']: verbose = True\n else: verbose = False\n #-------------------------------------------------------------\n\n from python_map import python_map\n if self._map != python_map:\n #FIXME: EvaluationMonitor fails for MPI, throws error for 'pp'\n from mystic.monitors import Null\n evalmon = Null()\n else: evalmon = self._evalmon\n fcalls, cost = wrap_function(cost, ExtraArgs, evalmon)\n\n # set up signal handler\n #self._EARLYEXIT = False\n self._generateHandler(sigint_callback) \n\n # activate signal_handler\n #import threading as thread\n #mainthread = isinstance(thread.current_thread(), thread._MainThread)\n #if mainthread: #XXX: if not mainthread, signal will raise ValueError\n import signal\n if self._handle_sigint:\n signal.signal(signal.SIGINT,self.signal_handler)\n\n # register termination function\n if termination is not None: self.SetTermination(termination)\n\n # get the nested solver instance\n solver = self._AbstractEnsembleSolver__get_solver_instance()\n #-------------------------------------------------------------\n\n # generate starting points\n initial_values = self._InitialPoints()\n\n # run optimizer for each grid point\n from copy import deepcopy as _copy\n op = [_copy(solver) for i in range(len(initial_values))]\n #cf = [cost for i in range(len(initial_values))]\n vb = [verbose for i in range(len(initial_values))]\n cb = [echo for i in range(len(initial_values))] #XXX: remove?\n at = self.id if self.id else 0 # start at self.id\n id = range(at,at+len(initial_values))\n\n # generate the local_optimize function\n def local_optimize(solver, x0, rank=None, disp=False, callback=None):\n from copy import deepcopy as _copy\n from mystic.tools import isNull\n solver.id = rank\n solver.SetInitialPoints(x0)\n if solver._useStrictRange: #XXX: always, settable, or sync'd ?\n solver.SetStrictRanges(min=solver._strictMin, \\\n max=solver._strictMax) # or lower,upper ?\n solver.Solve(cost, disp=disp, callback=callback)\n sm = solver._stepmon\n em = solver._evalmon\n if isNull(sm): sm = ([],[],[],[])\n else: sm = (_copy(sm._x),_copy(sm._y),_copy(sm._id),_copy(sm._info))\n if isNull(em): em = ([],[],[],[])\n else: em = (_copy(em._x),_copy(em._y),_copy(em._id),_copy(em._info))\n return solver, sm, em\n\n # map:: solver = local_optimize(solver, x0, id, verbose)\n results = self._map(local_optimize, op, initial_values, id, \\\n vb, cb, **self._mapconfig)\n\n # save initial state\n self._AbstractSolver__save_state()\n #XXX: HACK TO GET CONTENT OF ALL MONITORS\n # reconnect monitors; save all solvers\n from mystic.monitors import Monitor\n while results: #XXX: option to not save allSolvers? skip this and _copy\n _solver, _stepmon, _evalmon = results.pop()\n sm = Monitor()\n sm._x,sm._y,sm._id,sm._info = _stepmon\n _solver._stepmon.extend(sm)\n del sm\n em = Monitor()\n em._x,em._y,em._id,em._info = _evalmon\n _solver._evalmon.extend(em)\n del em\n self._allSolvers[len(results)] = _solver\n del results, _solver, _stepmon, _evalmon\n #XXX: END HACK\n\n # get the results with the lowest energy\n self._bestSolver = self._allSolvers[0]\n bestpath = self._bestSolver._stepmon\n besteval = self._bestSolver._evalmon\n self._total_evals = self._bestSolver.evaluations\n for solver in self._allSolvers[1:]:\n self._total_evals += solver.evaluations # add func evals\n if solver.bestEnergy < self._bestSolver.bestEnergy:\n self._bestSolver = solver\n bestpath = solver._stepmon\n besteval = solver._evalmon\n\n # return results to internals\n self.population = self._bestSolver.population #XXX: pointer? copy?\n self.popEnergy = self._bestSolver.popEnergy #XXX: pointer? copy?\n self.bestSolution = self._bestSolver.bestSolution #XXX: pointer? copy?\n self.bestEnergy = self._bestSolver.bestEnergy\n self.trialSolution = self._bestSolver.trialSolution #XXX: pointer? copy?\n self._fcalls = self._bestSolver._fcalls #XXX: pointer? copy?\n self._maxiter = self._bestSolver._maxiter\n self._maxfun = self._bestSolver._maxfun\n\n # write 'bests' to monitors #XXX: non-best monitors may be useful too\n self._stepmon = bestpath #XXX: pointer? copy?\n self._evalmon = besteval #XXX: pointer? copy?\n self.energy_history = None\n self.solution_history = None\n #from mystic.tools import isNull\n #if isNull(bestpath):\n # self._stepmon = bestpath\n #else:\n # for i in range(len(bestpath.y)):\n # self._stepmon(bestpath.x[i], bestpath.y[i], self.id)\n # #XXX: could apply callback here, or in exec'd code\n #if isNull(besteval):\n # self._evalmon = besteval\n #else:\n # for i in range(len(besteval.y)):\n # self._evalmon(besteval.x[i], besteval.y[i])\n #-------------------------------------------------------------\n\n # restore default handler for signal interrupts\n if self._handle_sigint:\n signal.signal(signal.SIGINT,signal.default_int_handler)\n\n # log any termination messages\n msg = self.Terminated(disp=disp, info=True)\n if msg: self._stepmon.info('STOP(\"%s\")' % msg)\n # save final state\n self._AbstractSolver__save_state(force=True)\n return","def main():\n inputs = tf.placeholder(tf.float32, shape=[3, None])\n targets = tf.placeholder(tf.float32, shape=[1, None])\n outputs = apply_network(inputs)\n loss = tf.reduce_mean(tf.square(outputs - targets))\n\n opt = tf.train.AdamOptimizer()\n minimize = opt.minimize(loss)\n\n with tf.Session() as sess:\n sess.run(tf.global_variables_initializer())\n train_x, train_y = make_data(5000)\n test_x, test_y = make_data(2000)\n train_dict = {inputs: train_x, targets: train_y}\n test_dict = {inputs: test_x, targets: test_y}\n for i in range(0, 5000):\n if i % 100 == 0:\n print('epoch %d: cost=%f val_cost=%f' %\n (i, sess.run(loss, feed_dict=train_dict),\n sess.run(loss, feed_dict=test_dict)))\n sess.run(minimize, feed_dict=train_dict)","def explain(self, validation_data, model, class_index, **extra):\n images, _ = validation_data\n\n gradients = self.compute_gradients(images, model, class_index, **extra)\n\n grayscale_gradients = transform_to_normalized_grayscale(\n tf.abs(gradients)\n ).numpy()\n\n grid = grid_display(grayscale_gradients)\n\n return grid","def main():\n\n dataset = ConvMNIST(64)\n print(dataset.get_train().x.shape)\n\n\n inputs = Value(type=tf.float32, shape=(None, 28, 28, 1), cls = None)\n targets = Value(type=tf.int64, shape=(None), cls = 10)\n learning_rate = 0.0001\n\n fc_hidden = [1024, 500]\n c_h = [\n (3, 3, 1, 32),\n (3, 3, 32, 64)\n ]\n conv_hidden = ConvHidden(conv_weights=c_h, fc_weights=fc_hidden)\n\n config = Config(inputs, targets, conv_hidden, learning_rate)\n\n network = ConvNetworkBuilder(config)\n hidden = FFConvHiddenBuilder()\n _ = network.build_network(hidden)\n\n\n train_config = TrainerConfig(\n epochs = EPOCHS, display_after = DISPLAY_STEP, \n keep_prob = KEEP_PROB,checkpoint_path=None, \n summary_path=None\n )\n\n trainer = Trainer(network, train_config)\n trainer.train(dataset)","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 negSamplingCostAndGradient(predicted, target, outputVectors, dataset,\n K=10):\n\n # Sampling of indices is done for you. Do not modify this if you\n # wish to match the autograder and receive points!\n indices = [target]\n indices.extend(getNegativeSamples(target, dataset, K))\n\n ### YOUR CODE HERE\n grad = np.zeros_like(outputVectors)\n gradPred = np.zeros_like(predicted)\n cost = 0.0\n probability = 0.0\n for sample_idx in indices:\n similarity = outputVectors[sample_idx].dot(predicted.T)\n probability = sigmoid(similarity) # squash to 0 ~ 1\n if sample_idx == target: # positive sample\n #p = sigmoid(outputVectors[sample_idx].dot(predicted.T))\n cost += -np.log(sigmoid(similarity))\n else: # negative sample\n #p = sigmoid(-outputVectors[sample_idx].dot(predicted.T))\n cost += -np.log(sigmoid(-similarity)) # deduction from reference 2.\n \n if sample_idx == target:\n grad[sample_idx, :] += (probability - 1) * predicted\n gradPred += (probability - 1) * outputVectors[sample_idx]\n else:\n grad[sample_idx, :] += probability * predicted\n gradPred += probability * outputVectors[sample_idx]\n '''\n V, D = outputVectors.shape\n one_hot_target = np.zeros(V)\n one_hot_target[target] = 1\n cost = 0\n gradPred = np.zeros_like(predicted)\n grad = np.zeros_like(outputVectors)\n \n for idx in indices:\n context_vector = outputVectors[idx] # embedding vector (1, D)\n cosine_similarity = normalizeRows(predicted).dot(normalizeRows(context_vector).T)\n print('neg sample, consine_similarity={0}'.format(cosine_similarity))\n binary_class = sigmoid(cosine_similarity)\n print('neg sample, binary_class={0}'.format(binary_class))\n \n if idx == target:\n cost += binary_class - 1\n else:\n cost += binary_class\n \n dlogits = sigmoid_grad(cosine_similarity)\n #gradPred += dlogits * normalizeRows(context_vector)\n #grad += np.outer(one_hot_target, dlogits * normalizeRows(predicted))\n gradPred += dlogits\n grad += np.outer(one_hot_target, dlogits)\n '''\n ### END YOUR CODE\n\n return cost, gradPred, grad","def run_negative():\n\tdef cy1(x, y): return y[:,0] - 2.5 # y < 2.5\n\tdef cy2(x, y): return 3 - y[:,0] # y > 3\n\tdef cx1(x, y): return -0.3 - x[:,0] # x > -0.3\n\tdef cx2(x, y): return x[:,0] - 0.3 # x < 0.3\n\n\tdef addons():\n\t\tdom = np.arange(-0.3, 0.3, 0.05)\n\t\tplt.fill_between(dom, 3.0, plt.ylim()[1], facecolor='#E41A1C', alpha=0.5, zorder=101)\n\t\tplt.fill_between(dom, plt.ylim()[0], 2.5, facecolor='#E41A1C', alpha=0.5, zorder=101)\n\n\tbnn = BNNSVGDRegressor(uid=\"bnn-negative-eg\", configfile=\"configs/bnn-negative-eg.json\")\n\tbnn.load(**toy1())\n\tbnn.add_negative_constraint((-5.0, 5.0), [cy1, cx1, cx2])\n\tbnn.add_negative_constraint((-5.0, 5.0), [cy2, cx1, cx2])\n\tbnn.infer()\n\tbnn.plot_pp(plot_title=\"Predictive Posterior Plot\", domain=np.arange(-5, 5, 0.05), ylims=(-9, 7), addons=addons)","def hidden_layers(self):\n\t\tif self.hidden is None:\n\t\t\tself.hidden, self.inputs, self.weights_all, self.biases_all = [], [], [], []\n\t\t\tlast_hidden = self.x\n\t\t\tif self.covnet == 1:\n\t\t\t\ty_conv, self._drouput, self.hidden, self.inputs = deepnn(self.x)\n\t\t\telif self.covnet == 2:\n\t\t\t\ty_c, self.hidden, self.inputs = multi_layer_perceptron(self.x, self.input_size, self.num_of_classes,\n\t\t\t\t self.layerSize[0], self.layerSize[1])\n\t\t\telse:\n\n\t\t\t\tself._drouput = 'dr'\n\t\t\t\t# self.hidden.append(self.x)\n\t\t\t\tfor i in range(1, len(self.all_layer_sizes)):\n\t\t\t\t\tname_scope = 'hidden' + str(i - 1)\n\t\t\t\t\trow_size, col_size = self.all_layer_sizes[i - 1], self.all_layer_sizes[i]\n\t\t\t\t\tactivation_function = self.activation_function\n\t\t\t\t\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function,\n\t\t\t\t\t last_hidden)\n\t\t\t\tname_scope = 'final_layer'\n\t\t\t\trow_size, col_size = self.layerSize[-1], self.num_of_classes\n\t\t\t\tactivation_function = None\n\t\t\t\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function, last_hidden)\n\t\treturn self.hidden","def __init__(self, calcGrad, calcCost, input, alpha = 0.01, gamma = 0.1):\n\tVisualizer.__init__(self, calcGrad, calcCost, input)\n\tself.alpha = alpha\n\tself.gamma = gamma","def visualize_manipulation_training(flow, epoch, save_dir=None):\n\n # Basic figure setup\n images_x = 3\n images_y = 3 if isinstance(flow.codec, DCN) else 2\n fig = Figure(figsize=(18, 10 / images_x * images_y))\n conf = np.array(flow.fan.performance['confusion'])\n \n # Draw the plots\n ax = fig.add_subplot(images_y, images_x, 1)\n ax.plot(flow.nip.performance['loss']['training'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['loss']['training'], 0))\n ax.set_ylabel('{} NIP loss'.format(flow.nip.class_name))\n ax.set_title('Loss')\n\n ax = fig.add_subplot(images_y, images_x, 2)\n ax.plot(flow.nip.performance['psnr']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['psnr']['validation'], 0))\n ax.set_ylabel('{} NIP psnr'.format(flow.nip.class_name))\n ax.set_title('PSNR')\n ax.set_ylim([30, 50])\n\n ax = fig.add_subplot(images_y, images_x, 3)\n ax.plot(flow.nip.performance['ssim']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['ssim']['validation'], 0))\n ax.set_ylabel('{} NIP ssim'.format(flow.nip.class_name))\n ax.set_title('SSIM')\n ax.set_ylim([0.8, 1])\n \n ax = fig.add_subplot(images_y, images_x, 4)\n ax.plot(flow.fan.performance['loss']['training'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.fan.performance['loss']['training'], 0))\n ax.set_ylabel('FAN loss')\n\n ax = fig.add_subplot(images_y, images_x, 5)\n ax.plot(flow.fan.performance['accuracy']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.fan.performance['accuracy']['validation'], 0))\n ax.set_ylabel('FAN accuracy')\n ax.set_ylim([0, 1])\n\n # The confusion matrix\n ax = fig.add_subplot(images_y, images_x, 6)\n ax.imshow(conf, vmin=0, vmax=1)\n\n ax.set_xticks(range(flow.n_classes))\n ax.set_xticklabels(flow._forensics_classes, rotation='vertical')\n ax.set_yticks(range(flow.n_classes))\n ax.set_yticklabels(flow._forensics_classes)\n\n for r in range(flow.n_classes):\n ax.text(r, r, '{:.2f}'.format(conf[r, r]), horizontalalignment='center', color='b' if conf[r, r] > 0.5 else 'w')\n\n ax.set_xlabel('PREDICTED class')\n ax.set_ylabel('TRUE class')\n ax.set_title('Accuracy: {:.2f}'.format(np.mean(np.diag(conf))))\n\n # If the compression model is a trainable DCN, include it's validation metrics\n if images_y == 3:\n ax = fig.add_subplot(images_y, images_x, 7)\n ax.plot(flow.codec.performance['loss']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['loss']['validation'], 0))\n ax.set_ylabel('DCN loss')\n\n ax = fig.add_subplot(images_y, images_x, 8)\n ax.plot(flow.codec.performance['ssim']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['ssim']['validation'], 0))\n ax.set_ylabel('DCN ssim')\n ax.set_ylim([0.8, 1])\n\n ax = fig.add_subplot(images_y, images_x, 9)\n ax.plot(flow.codec.performance['entropy']['validation'], '.', alpha=0.25)\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['entropy']['validation'], 0))\n ax.set_ylabel('DCN entropy')\n\n if save_dir is not None:\n if not os.path.exists(save_dir):\n os.makedirs(save_dir)\n fig.savefig('{}/manip_validation_{:05d}.jpg'.format(save_dir, epoch), bbox_inches='tight', dpi=100)\n del fig\n\n else:\n return fig","def nnObjFunction(params, *args):\n \n n_input, n_hidden, n_class, training_data, training_label, lambdaval = args\n \n w1 = params[0:n_hidden * (n_input + 1)].reshape( (n_hidden, (n_input + 1)))\n w2 = params[(n_hidden * (n_input + 1)):].reshape((n_class, (n_hidden + 1)))\n obj_val = 0\n obj_grad = np.array([])\n \n \n \n # initialize a gradient vector matrix with w1\n gradient_matrix_w1 = np.zeros(w1.shape) \n \n # initialize a gradient vector matrix with w2\n gradient_matrix_w2 = np.zeros(w2.shape) \n \n #transpose of input matrix\n input_mat = training_data.transpose() \n \n #transpose of label matrix(expected output)\n label_expected_mat = training_label.transpose() \n \n #get number of coulumns in matrix a1 which is equal to the total number of inputs\n number_of_input_columns = input_mat.shape[1] \n \n #Calculate the bias as input from hiddenlayer\n input_bias = np.tile(1,(1,np.size(input_mat,1)))\n \n #adding bias column in matrix\n input_mat=np.concatenate((input_mat,input_bias), axis=0) \n \n # multipy input with the corresponding wieght vector\n input_hidden_layer = np.dot(w1,input_mat)\n \n # output of hidden layer \n output_hidden_layer = sigmoid(input_hidden_layer) \n \n # calculate bias for hidden layer\n hidden_layer_bias = np.tile(1,(1,np.size(output_hidden_layer,1)))\n \n #adding bias column in hidden layer\n output_hidden_layer = np.concatenate((output_hidden_layer,hidden_layer_bias), axis=0) \n \n # multipy output of hidden layer with the corresponding wieght vector\n input_output_layer = np.dot(w2,output_hidden_layer) \n \n # output of output layer\n output_output_layer = sigmoid(input_output_layer) \n \n # Regularization of neural network\n error_function_mat=label_expected_mat*np.log(output_output_layer)+(1-label_expected_mat)*np.log(1-output_output_layer) \n obj_val= - np.sum(error_function_mat[:])/number_of_input_columns\n \n #ew1=w1**2\n #ew2=w2**2\n error_function = ((np.sum(pow(w1[:],2)) + np.sum(pow(w2[:],2)))/(2*number_of_input_columns))*lambdaval\n obj_val=obj_val+error_function\n \n print obj_val\n # claculate delta for hidden and output layer \n delta_output_layer = (output_output_layer - label_expected_mat) \n delta_hidden_layer = np.dot(w2.transpose(), delta_output_layer)*(output_hidden_layer*(1-output_hidden_layer))\n change_in_W1 = np.dot(delta_hidden_layer , input_mat.transpose())\n change_in_W2 = np.dot(delta_output_layer , output_hidden_layer.transpose())\n \n #remove the bias row\n change_in_W1 = change_in_W1[:-1,:]\n \n \n #update weight matrix\n gradient_matrix_w1 = gradient_matrix_w1 + change_in_W1\n gradient_matrix_w2 = gradient_matrix_w2 + change_in_W2\n \n #regularization of updated weight matrix\n gradient_matrix_w1 = (gradient_matrix_w1 + lambdaval*w1)/number_of_input_columns\n gradient_matrix_w2 = (gradient_matrix_w2 + lambdaval*w2)/number_of_input_columns\n obj_grad = np.concatenate((gradient_matrix_w1.flatten(),gradient_matrix_w2.flatten()), axis=0) \n \n print obj_grad\n return (obj_val,obj_grad)","def optimize(self,max_iter=100):\n\n\n for itr in range(max_iter):\n opt_logs = self.opt.minimize(self.tot_neg_elbo,sum([expert.trainable_variables for expert in self.experts],())) \n print(self.neg_elbo)","def optimize(self):\n self.check_is_ready()\n self.check_infeasibility()\n solution_graph, obj_val = self.find_shortest_network_with_ADH((self.old_network_graph is not None))\n self.solution_graph = gnx.GeoMultiGraph(solution_graph, crs=self.optimization_graph.crs)","def plot_cost(self):\n steps = np.arange(len(self.cost_values))\n plt.plot(steps, self.cost_values, '-o')\n plt.xlabel(\"Steps\")\n plt.ylabel(\"Cost value\")\n plt.title(\"Cost value per step using Gradient Descent\")\n plt.show()","def train(self, X, Y, num_iterations = 1000, learning_rate = 0.01, print_cost = False, plot_cost = False):\n costs = []\n \n for i in range(num_iterations + 1):\n grads, cost = self.propagate(X,Y)\n \n # Retrieve derivatives from grads\n dw = grads[\"dw\"]\n db = grads[\"db\"]\n \n # Update rule\n self.weight = self.weight - learning_rate * dw\n self.bias = self.bias - learning_rate * db\n \n # Record the costs\n if i % 100 == 0:\n costs.append(cost)\n \n # Print the cost every 100 training examples\n if print_cost and i % 100 == 0:\n print(f\"cost after iteration: {i} is {np.round(cost, 4)}\")\n \n grads = {\"dw\": dw,\n \"db\": db}\n\n if plot_cost:\n plt.plot(np.arange(len(costs)) * 100, costs)\n plt.xlabel(\"epoch\")\n plt.ylabel(\"cost\")\n plt.title(f\"Logistic curve fitting loss function (learning rate={learning_rate})\")\n plt.show()\n \n return grads, costs","def main():\n # Load and preprocess the data.\n ((x_train, y_train), (x_test, y_test)) = (\n preprocess_dataset(x, y) for (x, y) in datasets.mnist.load_data()\n )\n (_, n_classes) = y_train.shape\n\n # Create and fit the original model.\n model = create_model(\n LAYER_SIZES,\n n_classes,\n layer_fn=functools.partial(layers.Dense, use_bias=False),\n layer_kwargs_fn=dense_kwargs,\n )\n model.fit(x_train, y_train, batch_size=BATCH_SIZE, epochs=N_EPOCHS)\n\n # Evaluate the pruning methods.\n pruning_methods = [(\"weight\", prune_weights), (\"neuron\", prune_neurons)]\n for (method_name, pruning_fn) in pruning_methods:\n # Compute the evaluation curves.\n (accuracy_curve, time_curve) = zip(\n *[\n evaluate_fraction(pruning_fn, model, (x_test, y_test), fraction)\n for fraction in PRUNING_FRACTIONS\n ]\n )\n # Plot them.\n for (subplot, curve) in [(211, accuracy_curve), (212, time_curve)]:\n plt.subplot(subplot)\n plt.plot(PRUNING_FRACTIONS, curve, label=method_name)\n\n if method_name == \"neuron\":\n # The first evaluated model in neuron pruning is the unpruned\n # one. Use it as a baseline.\n (baseline, *_) = curve\n plt.plot((0, 1), (baseline, baseline), \"--\", label=\"unpruned\")\n\n # Add some labels to the plots.\n for (subplot, y_label) in [(211, \"accuracy\"), (212, \"inference time\")]:\n plt.subplot(subplot)\n plt.xlabel(\"pruning fraction\")\n plt.ylabel(y_label)\n plt.legend()\n plt.show()","def model(X_train, Y_train, X_test, Y_test, test_imgs, learning_rate=.0003,\n num_epochs=100, minibatch_size=64, print_cost=True):\n ops.reset_default_graph\n tf.set_random_seed(1)\n seed = 3\n (m, n_H0, n_W0, n_C0) = X_train.shape\n n_y = Y_train.shape[1]\n costs = []\n\n X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y)\n\n parameters = initialize_parameters()\n\n Z6 = forward_propogation(X, parameters)\n\n cost = compute_cost(Z6, Y)\n\n optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)\n\n init = tf.global_variables_initializer()\n\n with tf.Session() as sess:\n sess.run(init)\n for epoch in range(num_epochs):\n minibatch_cost =0.\n num_minibatches = int(m/minibatch_size)\n seed = seed + 1\n minibatches = random_mini_batches(X_train, Y_train,\n minibatch_size, seed)\n\n print('USING ONLY FIRST MINIBATCH. DELETE AfTER TETING!')\n\n #for minibatch in minibatches:\n minibatch = minibatches[1]\n (minibatch_X, minibatch_Y) = minibatch\n _, temp_cost = sess.run([optimizer, cost],\n feed_dict={X:minibatch_X, Y:minibatch_Y})\n minibatch_cost += temp_cost / num_minibatches\n\n if print_cost == True:\n print (\"Cost after epoch %i: %f\" % (epoch, minibatch_cost))\n if print_cost == True:\n costs.append(minibatch_cost)\n\n\n # plot the cost\n plt.plot(np.squeeze(costs))\n plt.ylabel('cost')\n plt.xlabel('iterations (per tens)')\n plt.title(\"Learning rate =\" + str(learning_rate))\n plt.show()\n\n # Calculate the correct predictions\n predict_op = tf.argmax(Z6, 1)\n correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1))\n\n # Calculate accuracy on the test set\n# accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n# print(accuracy)\n# train_accuracy = accuracy.eval({X: X_train, Y: Y_train})\n# test_accuracy = accuracy.eval({X: X_test, Y: Y_test})\n# print(\"Train Accuracy:\", train_accuracy)\n# print(\"Test Accuracy:\", test_accuracy)\n\n # Predict on REAL test set\n print('using test set')\n predicted_lables = np.zeros(test_imgs.shape[0])\n predicted_lables[0:3999] = predict_op.eval(feed_dict={X: test_imgs[0:3999]})\n\n\n return train_accuracy, test_accuracy, parameters, predicted_lables","def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\n\n ### YOUR CODE HERE\n y_hat = softmax(np.dot(outputVectors,predicted))\n y = np.zeros(outputVectors.shape[0])\n y[target] = 1.0\n\n cost = -np.log(y_hat[target])\n gradPred = np.dot(outputVectors.T,y_hat - y)\n grad = np.outer(y_hat - y,predicted)\n ### END YOUR CODE\n\n return cost, gradPred, grad","def build_dense_network(data, hidden_layers, **kwargs):\n # Input layer\n with tf.variable_scope(\"layer_1\"): \n weights = tf.get_variable(\"weights\", shape = [input_shape[-1] + 1\n , hidden_layers[0]], initializer = tf.variance_scaling_initializer())\n\n output = tf.nn.leaky_relu(tf.matmul(tf.concat([data, tf.ones(dtype = tf.float32\n , shape = (tf.shape(data)[0], 1))], axis = 1) # concat\n , weights, name = \"multiply\") # matmul\n , α, name = \"output\") # leaky relu\n\n # DROP-OUT after the activation func\n output = tf.nn.dropout(output, keep_prob=δ, name = \"output\") \n\n # Hidden layers 1 to len(hidden_layers) - 1\n for i in range(2, len(hidden_layers)-1+2):\n\n with tf.variable_scope(f\"layer_{i}\"):\n n_nodes = hidden_layers[i-1]\n\n weights = tf.get_variable(\"weights\", shape = [hidden_layers[i-2]+1, hidden_layers[i-1]], initializer = tf.variance_scaling_initializer())\n output = tf.nn.leaky_relu(tf.matmul(tf.concat([output, tf.ones(dtype = tf.float32, shape = (tf.shape(data)[0], 1))], axis = 1), weights, name = \"multiply\"), α, name = \"output\")\n\n # DROP-OUT after the activation func\n output = tf.nn.dropout(output, keep_prob=δ, name = \"output\") \n\n # Output layer\n with tf.variable_scope(f\"layer_{len(hidden_layers)+1}\"):\n\n weights = tf.get_variable(\"weights\", shape = (hidden_layers[1]+1, n_summaries), initializer = tf.variance_scaling_initializer())\n output = tf.identity(tf.matmul(tf.concat([output, tf.ones(dtype = tf.float32, shape = (tf.shape(data)[0], 1))], axis = 1), weights, name = \"multiply\"), name = \"output\")\n # NO DROP-OUT in the last layer\n\n\n return output","def get_network(encoded, is_training, scale=1., weight_decay=0.00004):\n with tf.variable_scope(\"Dense\"):\n batch_size = encoded.get_shape()[0].value\n end_points = {}\n bn_params = {\"is_training\": is_training,\n 'epsilon': 1e-3\n }\n pc = tf.reshape(encoded, [batch_size, 1, 1, -1])\n net = slim.conv2d(pc,\n # 400,\n max(int(round(400 * scale)), 32),\n [1, 1],\n padding='SAME',\n stride=1,\n normalizer_fn=slim.batch_norm,\n normalizer_params=bn_params,\n biases_initializer=tf.zeros_initializer(),\n weights_regularizer=slim.l2_regularizer(weight_decay),\n scope='fc1',\n activation_fn=tf.nn.relu6)\n net = slim.dropout(net, keep_prob=0.8, is_training=is_training, scope='dp1')\n net = slim.conv2d(net,\n # 400,\n max(int(round(400 * scale)), 32),\n [1, 1],\n padding='SAME',\n stride=1,\n normalizer_fn=slim.batch_norm,\n normalizer_params=bn_params,\n biases_initializer=tf.zeros_initializer(),\n weights_regularizer=slim.l2_regularizer(weight_decay),\n scope='fc2',\n activation_fn=tf.nn.relu6)\n net = slim.dropout(net, keep_prob=0.4, is_training=is_training, scope='dp2')\n net = slim.conv2d(net,\n 40, [1, 1],\n padding='SAME',\n stride=1,\n # normalizer_fn=slim.batch_norm,\n # normalizer_params=bn_params,\n biases_initializer=tf.zeros_initializer(),\n weights_regularizer=slim.l2_regularizer(weight_decay),\n scope='fc3',\n # activation_fn=tf.nn.relu6,\n activation_fn=None,\n )\n # print(net)\n net = tf.reshape(net, [batch_size, -1])\n return net, end_points","def visualize(self):\n\n self.check_model()\n show(prepare(self.model, self.vectorized_data, self.vectorizer, mds='tsne'))","def model(self, img, label, bias, filters):\n prediction, z, flat, layers = self.predict(bias, img, filters)\n\n loss = self.categorical_crossentropy(prediction, label)\n\n # backpropagation\n dout = prediction - np.asarray(label).reshape((15, 1))\n dflat, dw8, db8, dw7, db7 = self.dense_layer_backprop(dout, flat, filters[6:8], bias[6:8], z)\n\n dconv6 = dflat.reshape(layers[-1].shape)\n dconv6[layers[-1] <= 0] = 0\n dconv5, df6, db6 = self.conv_layer_backprop(dconv6, layers[-2], filters[5])\n dconv5[layers[-2] <= 0] = 0\n dpool2, df5, db5 = self.conv_layer_backprop(dconv5, layers[-3], filters[4])\n dconv4 = self.pooling_layer_backprop(dpool2, layers[-4])\n dconv4[layers[-4] <= 0] = 0\n dconv3, df4, db4 = self.conv_layer_backprop(dconv4, layers[-5], filters[3])\n dconv3[layers[-5] <= 0] = 0\n dpool1, df3, db3 = self.conv_layer_backprop(dconv3, layers[-6], filters[2])\n dconv2 = self.pooling_layer_backprop(dpool1, layers[-7])\n dconv2[layers[-7] <= 0] = 0\n dconv1, df2, db2 = self.conv_layer_backprop(dconv2, layers[-8], filters[1])\n dconv1[layers[-8] <= 0] = 0\n dimg, df1, db1 = self.conv_layer_backprop(dconv1, img[0], filters[0])\n\n weight_gradients = [df1, df2, df3, df4, df5, df6, dw7, dw8]\n bias_gradients = [db1, db2, db3, db4, db5, db6, db7, db8]\n\n return weight_gradients, bias_gradients, loss","def loss_graph(self, training_costs, test_costs, learning_rate, training_accuracy, test_accuracy, val_accuracy,\n layers, data_size, n_neighbours, dropout_layer, dropout_rate):\n\n plt.plot(training_costs, label=\"Training loss\")\n plt.plot(test_costs, label=\"Test loss\")\n plt.xlabel(\"Iterations\", size='medium')\n plt.ylabel(\"Cost function (%)\", size='medium')\n plt.suptitle(\"Cost function while training the neural network\", size='medium', ha='center')\n if True in dropout_layer:\n plt.title(\"layers: {}, dropout rate: {}, learning rate: {}\".format(layers, dropout_rate, learning_rate),\n size='small', ha='center')\n else:\n plt.title(\"layers: {}, learning rate: {}\".format(layers, learning_rate), size='small', ha='center')\n plt.figtext(0.77, 0.35, \"Training accuracy\\n{0:.2f}%\".format(training_accuracy), size='medium')\n plt.figtext(0.77, 0.25, \"Test accuracy\\n{0:.2f}%\".format(test_accuracy), size='medium')\n plt.figtext(0.77, 0.15, \"Validation accuracy\\n{0:.2f}%\".format(val_accuracy), size='medium')\n if n_neighbours == 0:\n plt.figtext(0.77, 0.80, \"Neighbours\\nexcluded\", size='medium')\n else:\n plt.figtext(0.77, 0.80, \"{} neighbours\\nincluded\".format(n_neighbours), size='medium')\n plt.figtext(0.77, 0.70, \"{}\\nsamples\".format(data_size))\n plt.legend(loc='right', bbox_to_anchor=(1.39, 0.5))\n plt.subplots_adjust(right=0.75)\n working_dir = os.path.dirname(os.path.abspath(__file__))\n saving(working_dir + \"/output_ANN/loss_plots/{}_error_{}\".format(n_neighbours, data_size))","def learning_viz(self) :\n self.train\n history = self.history\n plot_loss(history)","def __init__(self, rate, sigmoid, hidden, examples, variables, layers, rule, dropout):\n self.rate = rate\n self.sigmoid = sigmoid\n self.inputs = variables \n self.vis_layer = []\n self.hidden_layers = []\n self.hidden = hidden\n self.variables = variables\n self.data = BOOLEAN(examples, self.variables)\n self.layers = layers-1\n self.rule = rule\n self.dropout = dropout\n self.length = int(math.pow(2, self.variables))\n for _ in xrange(self.hidden):\n self.vis_layer.append(Neuron(self.rate, self.sigmoid, self.inputs+1, dropout))\n for layer in xrange(self.layers):\n self.hidden_layers.append([])\n for _ in xrange(self.hidden):\n self.hidden_layers[layer].append(Neuron(self.rate, self.sigmoid, self.hidden+1, dropout))\n if self.hidden > 0:\n self.output_neuron = Neuron(self.rate, self.sigmoid, self.hidden+1, dropout)\n else:\n self.output_neuron = Neuron(self.rate, self.sigmoid, self.inputs+1, dropout)","def main() -> None:\n\n # Load pickled (adj, feat) tuple\n with open(os.path.join(NETWORK_DIR, PICKLE_FILE), \"rb\") as file:\n adj, features = pickle.load(file)\n\n g = nx.Graph(adj) # Recreate graph using node indices (0 to num_nodes-1)\n\n # Draw the network\n # nx.draw_networkx(g, with_labels=False, node_size=50, node_color=\"r\")\n # plt.show()\n\n # Preprocessing (train/test split)\n np.random.seed(0) # make sure train-test split is consistent\n adj_sparse = nx.to_scipy_sparse_matrix(g)\n\n # Perform train-test split\n (\n adj_train,\n train_edges,\n train_edges_false,\n val_edges,\n val_edges_false,\n test_edges,\n test_edges_false,\n ) = mask_test_edges(adj_sparse, test_frac=0.3, val_frac=0.1)\n\n # new graph object with only non-hidden edges\n g_train = nx.from_scipy_sparse_matrix(adj_train)\n\n # Inspect train/test split\n print(\"Total nodes:\", adj_sparse.shape[0])\n\n # adj is symmetric, so nnz (num non-zero) = 2 * num_edges\n print(\"Total edges:\", int(adj_sparse.nnz / 2))\n print(\"Training edges (positive):\", len(train_edges))\n print(\"Training edges (negative):\", len(train_edges_false))\n print(\"Validation edges (positive):\", len(val_edges))\n print(\"Validation edges (negative):\", len(val_edges_false))\n print(\"Test edges (positive):\", len(test_edges))\n print(\"Test edges (negative):\", len(test_edges_false))\n\n # Train node2vec (Learn Node Embeddings)\n\n # node2vec settings\n # NOTE: When p = q = 1, this is equivalent to DeepWalk\n\n P = 1 # Return hyperparameter\n Q = 1 # In-out hyperparameter\n WINDOW_SIZE = 10 # Context size for optimization\n NUM_WALKS = 10 # Number of walks per source\n WALK_LENGTH = 80 # Length of walk per source\n DIMENSIONS = 128 # Embedding dimension\n DIRECTED = False # Graph directed/undirected\n WORKERS = 8 # Num. parallel workers\n ITER = 1 # SGD epochs\n\n # Preprocessing, generate walks\n\n # create node2vec graph instance\n g_n2v = node2vec.Graph(g_train, DIRECTED, P, Q)\n g_n2v.preprocess_transition_probs()\n walks = g_n2v.simulate_walks(NUM_WALKS, WALK_LENGTH)\n walks = [list(map(str, walk)) for walk in walks]\n\n # Train skip-gram model\n model = Word2Vec(\n walks,\n size=DIMENSIONS,\n window=WINDOW_SIZE,\n min_count=0,\n sg=1,\n workers=WORKERS,\n iter=ITER,\n )\n\n # Store embeddings mapping\n emb_mappings = model.wv\n\n print(emb_mappings)\n\n # Create node embeddings matrix (rows = nodes, columns = embedding features)\n emb_list = []\n for node_index in range(0, adj_sparse.shape[0]):\n node_str = str(node_index)\n node_emb = emb_mappings[node_str]\n emb_list.append(node_emb)\n emb_matrix = np.vstack(emb_list)\n\n def get_edge_embeddings(edge_list):\n \"\"\"\n Generate bootstrapped edge embeddings (as is done in node2vec paper)\n Edge embedding for (v1, v2) = hadamard product of node embeddings for\n v1, v2.\n \"\"\"\n embs = []\n for edge in edge_list:\n node1 = edge[0]\n node2 = edge[1]\n emb1 = emb_matrix[node1]\n emb2 = emb_matrix[node2]\n edge_emb = np.multiply(emb1, emb2)\n embs.append(edge_emb)\n embs = np.array(embs)\n return embs\n\n # Train-set edge embeddings\n pos_train_edge_embs = get_edge_embeddings(train_edges)\n neg_train_edge_embs = get_edge_embeddings(train_edges_false)\n train_edge_embs = np.concatenate(\n [pos_train_edge_embs, neg_train_edge_embs]\n )\n\n # Create train-set edge labels: 1 = real edge, 0 = false edge\n train_edge_labels = np.concatenate(\n [np.ones(len(train_edges)), np.zeros(len(train_edges_false))]\n )\n\n # Val-set edge embeddings, labels\n pos_val_edge_embs = get_edge_embeddings(val_edges)\n neg_val_edge_embs = get_edge_embeddings(val_edges_false)\n val_edge_embs = np.concatenate([pos_val_edge_embs, neg_val_edge_embs])\n val_edge_labels = np.concatenate(\n [np.ones(len(val_edges)), np.zeros(len(val_edges_false))]\n )\n\n # Test-set edge embeddings, labels\n pos_test_edge_embs = get_edge_embeddings(test_edges)\n neg_test_edge_embs = get_edge_embeddings(test_edges_false)\n test_edge_embs = np.concatenate([pos_test_edge_embs, neg_test_edge_embs])\n\n # Create val-set edge labels: 1 = real edge, 0 = false edge\n test_edge_labels = np.concatenate(\n [np.ones(len(test_edges)), np.zeros(len(test_edges_false))]\n )\n\n # Train logistic regression classifier on train-set edge embeddings\n edge_classifier = LogisticRegression(random_state=0)\n edge_classifier.fit(train_edge_embs, train_edge_labels)\n\n # Predicted edge scores: probability of being of class \"1\" (real edge)\n val_preds = edge_classifier.predict_proba(val_edge_embs)[:, 1]\n val_roc = roc_auc_score(val_edge_labels, val_preds)\n val_ap = average_precision_score(val_edge_labels, val_preds)\n\n # Predicted edge scores: probability of being of class \"1\" (real edge)\n test_preds = edge_classifier.predict_proba(test_edge_embs)[:, 1]\n test_roc = roc_auc_score(test_edge_labels, test_preds)\n test_ap = average_precision_score(test_edge_labels, test_preds)\n\n print(\"node2vec Validation ROC score: \", str(val_roc))\n print(\"node2vec Validation AP score: \", str(val_ap))\n print(\"node2vec Test ROC score: \", str(test_roc))\n print(\"node2vec Test AP score: \", str(test_ap))","def model(X_train, Y_train, X_test, Y_test, num_iterations, learning_rate, print_cost):\n\n\n # initialize parameters with zeros\n w, b = initialize_with_zeros(X_train.shape[0]);\n\n print(\"w.shape() = \" +str(w.shape)+ \", b = \" +str(b));\n\n # Gradient descent\n parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost);\n \n # Retrieve parameters w and b from dictionary \"parameters\"\n w = parameters[\"w\"]\n b = parameters[\"b\"]\n \n # Predict test/train set examples \n Y_prediction_test = predict(w, b, X_test)\n Y_prediction_train = predict(w, b, X_train)\n\n # Print train/test Errors\n print(\"train accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))\n print(\"test accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))\n \n d = {\"costs\": costs,\n \"Y_prediction_test\": Y_prediction_test, \n \"Y_prediction_train\" : Y_prediction_train, \n \"w\" : w,\n \"b\" : b,\n \"learning_rate\" : learning_rate,\n \"num_iterations\": num_iterations}\n \n return d","def main():\n # Initializing learning rate\n learning_rate = 0.0005\n # Initializing stopping criteria\n stopping_criteria = 0.01\n # load the data training data from a csv file with an url\n training_x,testing_x, training_y, testing_y,mean,sd= ai.store_data(\"https://github.com/santiagocantu98/K-Nearest-Neightbours/raw/master/diabetes.csv\",\"training\")\n normal_testing = np.copy(testing_x)\n\n # scalates the features of the testing data\n testing_data_scaled,mean,sd = ai.scale_features(testing_x,mean,sd)\n ai.print_scaled_data(testing_data_scaled,\"testing\")\n ai.calculate_euclidean_distance(training_x, training_y , testing_data_scaled, testing_y,normal_testing)","def testvis(layers='first'):\n\n\tfrom scipy.io import loadmat\n\tfrom setup import NeuralNetwork as nnsetup\n\n\tresult = loadmat(\"goodmatx.mat\")\n\tw1 = result['v1']\n\tw0 = result['v0']\n\tx,y = result['train_x'], result['train_y']\n\n\t# result = loadmat(\"ducky.mat\")\n\t# x = result['train_x']\n\t# y = result['train_y']\n\n\tsize = [x.shape[1], 1000, y.shape[1]]\n\n\tnn = nnsetup([size[0],size[1],size[0]],output='sigm')\n\n\tnn.W[0] = w0\n\tnn.W[1] = w1\n\t\n\tfor i in range(50):\n\t\tvisualize( nn, x, k = 3000+i*4, layers=layers, mode='save' )","def gradient_descent(w, b, image_matrix, true_labels, iteration_count, learning_rate, show_cost):\n\n\tcosts = []\n\n\tfor i in range(iteration_count):\n\t\tgradients, cost = propagate(w, b, image_matrix, true_labels)\n\t\t# if math.isnan(cost):\n\t\t# \tA = sigmoid(np.dot(w.T, image_matrix) + b)\n\t\t# \tprint(np.squeeze(A))\n\t\t# \tprint(cross_entropy_cost(image_matrix.shape[1], A, true_labels))\n\n\t\tdw = gradients['dw'] # obtaining weight gradient from back propagation\n\t\tdb = gradients['db'] # obtaining bias gradient from back propagation\n\n\t\tw = w - learning_rate * dw # w array stepping towards local minimum with steps of length: learning_rate\n\t\tb = b - learning_rate * db # b value stepping\n\n\t\t# appends cost value at given iteration increments to costs array for analystics\n\t\tcollection_rate = 1\n\t\tif i % collection_rate == 0:\n\t\t\tcosts.append(cost)\n\n\t\t# Shows cost value every 100 iterations if True\n\t\tif show_cost and i % 100 == 0 and i != 0:\n\t\t\tprint('Iteration: %i, Cost: %f' % (i, cost))\n\n\tparameters = {\n\t\"w\": w,\n\t\"b\": b\n\t}\n\n\tgradients = {\n\t\"dw\": dw,\n\t\"db\": db,\n\t}\n\n\treturn parameters, gradients, costs","def train():\n\n ### DO NOT CHANGE SEEDS!\n # Set the random seeds for reproducibility\n np.random.seed(42)\n\n ## Prepare all functions\n # Get number of units in each hidden layer specified in the string such as 100,100\n if FLAGS.dnn_hidden_units:\n dnn_hidden_units = FLAGS.dnn_hidden_units.split(\",\")\n dnn_hidden_units = [int(dnn_hidden_unit_) for dnn_hidden_unit_ in dnn_hidden_units]\n else:\n dnn_hidden_units = []\n\n # Get negative slope parameter for LeakyReLU\n neg_slope = FLAGS.neg_slope\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n import matplotlib.pyplot as plt\n\n data = cifar10_utils.get_cifar10(FLAGS.data_dir)\n train = data['train']\n test = data['test']\n dim_x = train.images.shape[1]*train.images.shape[2]*train.images.shape[3]\n\n mlp = MLP(dim_x, dnn_hidden_units, train.labels.shape[1], neg_slope)\n loss_module = CrossEntropyModule()\n\n loss_train = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\n loss_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\n accuracy_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\n\n images_test = test.images\n labels_test = test.labels\n images_test = np.reshape(images_test, (images_test.shape[0], dim_x))\n\n for i in range(0, FLAGS.max_steps):\n if PRINTS:\n print('iter', i+1, end='\\r')\n images, labels = train.next_batch(FLAGS.batch_size) \n images = np.reshape(images, (images.shape[0], dim_x))\n\n pred = mlp.forward(images)\n loss = loss_module.forward(pred, labels)\n loss_grad = loss_module.backward(pred, labels)\n mlp.backward(loss_grad)\n\n for module in reversed(mlp.modules):\n if isinstance(module, LinearModule):\n module.params['weight'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['weight']\n module.params['bias'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['bias']\n if (i+1) % FLAGS.eval_freq == 0:\n pred_test = mlp.forward(images_test)\n loss_train[i // FLAGS.eval_freq] = loss\n accuracy_test[i // FLAGS.eval_freq] = accuracy(pred_test, labels_test)\n loss_test[i // FLAGS.eval_freq] = loss_module.forward(pred_test, labels_test)\n if PRINTS:\n print()\n print('test_loss:', loss_test[i // FLAGS.eval_freq])\n print('test_accuracy:', accuracy_test[i // FLAGS.eval_freq])\n print('train_loss:', loss_train[i // FLAGS.eval_freq])\n\n if PLOTS:\n fig, ax = plt.subplots(1, 2, figsize=(10,5))\n fig.suptitle('Training curves for Numpy MLP\\nFinal test accuracy: {:0.4f}, default configuration'.format(accuracy_test[i // FLAGS.eval_freq]))\n\n ax[0].set_title('Loss')\n ax[0].set_ylabel('Loss value')\n ax[0].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\n ax[0].plot(loss_train, label='Train')\n ax[0].plot(loss_test, label='Test')\n ax[0].legend()\n\n ax[1].set_title('Accuracy')\n ax[1].set_ylabel('Accuracy value')\n ax[1].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\n ax[1].plot(accuracy_test, label='Test')\n ax[1].legend()\n plt.show()\n\n\n ########################\n # END OF YOUR CODE #\n #######################","def trainNet():","def build_graph(self):\n # place holders for inputs here \n HIDDEN_LAYER = self.FLAGS.feature_layer_size\n \n self.x_i = tf.placeholder(dtype=tf.float32, shape = (None, self.INPUT_DIM), name=\"x_i\")\n self.a_i = tf.placeholder(dtype=tf.float32, shape = (None, self.ACTION_DIM), name = \"a_i\")\n self.q_opc = tf.placeholder(dtype=tf.float32, shape = (None, 1), name = \"q_opc\")\n self.q_ret = tf.placeholder(dtype=tf.float32, shape = (None, 1), name = \"q_ret\" )\n self.c = self.FLAGS.c # truncation threshold constant\n \n self.actor_net = PolicyNet(HIDDEN_LAYER, self.ACTION_DIM, name= self.name + \"_actor\", co_var = self.co_var)\n self.critic_net = AdvantageValueNet(HIDDEN_LAYER , name= self.name + \"_critic\")\n \n self.policy_xi_stats, self.policy_xi_dist = self.actor_net(self.x_i)\n \n self.val_xi, self.adv_xi_ai = self.critic_net(self.x_i, self.a_i, self.policy_xi_dist)\n \n #sample a' now\n self.a_i_ = tf.reshape(self.policy_xi_dist.sample(1), shape=[-1,self.ACTION_DIM])\n self.a_i_ = tf.clip_by_value(self.a_i_, self.env.action_space.low[0], self.env.action_space.high[0]) #20190828 add clipping\n \n _, self.adv_xi_ai_ = self.critic_net(self.x_i, self.a_i_, self.policy_xi_dist) # val will be the same for \n \n _, self.average_policy_xi_dist = self.average_actor_net(self.x_i) # can this be done better ?\n \n self.prob_a_i = tf.reshape(self.policy_xi_dist.prob(self.a_i),shape=[-1,1]) + 1e-8\n self.prob_a_i_ = tf.reshape(self.policy_xi_dist.prob(self.a_i_),shape=[-1,1]) + 1e-8\n \n self.log_prob_a_i = tf.log(self.prob_a_i)\n self.log_prob_a_i_ = tf.log(self.prob_a_i_)\n \n # for predicting 1-step a_i', p_i, p_i',\n self.u_i = tf.placeholder(dtype=tf.float32, shape = (None, 2*self.ACTION_DIM))\n \n #self.u_i_dist = tf.contrib.distributions.MultivariateNormalDiag(loc= self.u_i, \n # scale_diag = tf.ones_like(self.u_i) * self.co_var)\n self.u_i_dist = tf.contrib.distributions.MultivariateNormalDiag(loc= self.u_i[:,0], scale_diag=self.u_i[:,1])\n \n self.u_i_prob_a_i = tf.reshape(self.u_i_dist.prob(self.a_i),shape=[-1,1]) + 1e-8\n self.u_i_prob_a_i_ = tf.reshape(self.u_i_dist.prob(self.a_i_),shape=[-1,1]) + 1e-8\n \n self.p_i = tf.divide(self.prob_a_i, self.u_i_prob_a_i)\n self.p_i_ = tf.divide(self.prob_a_i_ , self.u_i_prob_a_i_)\n \n\n # take care of NaNs here, for importance sampling weights (might be an extra step)\n self.p_i = tf.where(tf.is_nan(self.p_i), tf.zeros_like(self.p_i), self.p_i)\n self.p_i_ = tf.where(tf.is_nan(self.p_i_), tf.zeros_like(self.p_i_), self.p_i_)\n\n self.c_i = tf.minimum(1. , tf.pow(self.p_i, 1.0/self.ACTION_DIM))\n \n \n # for verification about checking if params are getting synched\n self.local_actor_vars = self.actor_net.local_params()\n self.global_actor_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'global_actor')\n \n self.local_critic_vars = self.critic_net.local_params()\n self.global_critic_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'global_critic')\n \n \n # Sync ops from global\n self.sync_local_actor_op = self.actor_net.update_local_params_op('global_actor') # global actor\n self.sync_local_critic_op = self.critic_net.update_local_params_op('global_critic')\n \n # soft update the average network\n self.soft_update_average_actor_op = self.average_actor_net.soft_update_from_target_params('global_actor',\n self.FLAGS.tau)\n \n #Get gradients from local network using local losses\n \n g1 = tf.reshape(tf.gradients((self.log_prob_a_i * (self.q_opc - self.val_xi)),self.policy_xi_stats,\n name=self.name+\"g1_grads\", unconnected_gradients='zero'), shape = [-1,2*self.ACTION_DIM])\n g2 = (self.adv_xi_ai_ - self.val_xi) * tf.reshape(tf.gradients((self.log_prob_a_i_), \n self.policy_xi_stats, name=self.name+\"g2_grads\", unconnected_gradients='zero'), shape = [-1,2*self.ACTION_DIM])\n \n \n self.g = tf.minimum(self.c, self.p_i) * g1 + tf.nn.relu(1 - tf.divide(self.c , self.p_i_)) * g2\n \n \n self.k = tf.reshape(tf.gradients(tf.contrib.distributions.kl_divergence(self.average_policy_xi_dist, \n self.policy_xi_dist), self.policy_xi_stats, unconnected_gradients='zero'), shape = [-1,2*self.ACTION_DIM])\n \n \n \n self.kg = tf.reduce_sum( tf.multiply(self.g, self.k), 1, keep_dims=True)\n \n #print \"kg\", self.kg\n \n self.k2 = tf.reduce_sum( tf.multiply(self.k, self.k), 1, keep_dims=True)\n \n self.reg_g = self.g - tf.maximum(tf.zeros_like(self.g), tf.divide((self.kg - self.FLAGS.delta), self.k2) ) * self.k\n \n # take gradients wrt to the local params\n self.actor_grads = tf.gradients(self.policy_xi_stats, self.local_actor_vars, \n grad_ys= -self.reg_g, name=\"actor_grads\", unconnected_gradients='zero')\n \n \n #for ti,tj in zip(self.actor_grads, self.global_actor_vars):\n # print ti, \"\\n\", tj , \"\\n\", \"===========\"\n \n # apply local gradients to the global network\n self.actor_train_op = self.optimizer.apply_gradients(zip(self.actor_grads, self.global_actor_vars),\n global_step=tf.train.get_global_step())\n \n \n # critic loss function and updates\n \n # take gradient wrt to local variables\n self.critic_loss_1 = ((self.q_ret - self.adv_xi_ai) ** 2.0) / 2.0\n \n # for predicting 1-step a_i', p_i, p_i',\n self.v_target = tf.placeholder(dtype=tf.float32, shape = (None, 1))\n \n #self.v_trunc = tf.minimum(self.p_i, 1.0) * (self.q_ret - self.adv_xi_ai) + self.val_xi\n self.critic_loss_2 = ((self.v_target - self.val_xi) ** 2.0) / 2.0\n \n self.critic_loss = self.critic_loss_1 + self.critic_loss_2\n \n #Apply local gradients to global network\n \n self.critic_grads = tf.gradients(self.critic_loss, self.local_critic_vars)\n \n self.critic_train_op = self.optimizer.apply_gradients(zip(self.critic_grads, self.global_critic_vars),\n global_step=tf.train.get_global_step())\n \n # critic_summaries op\n critic_grads_summary = []\n print('-----------------------------------------------------------------')\n print('Create critic_grads_summary histogram ')\n for grad,var in zip(self.critic_grads, self.local_critic_vars):\n print('{} - {}'.format(var.name, grad))\n critic_grads_summary.append(tf.summary.histogram(var.name + '/gradient', grad))\n critic_grads_summary.append(tf.summary.histogram(var.name + '/weight', var))\n \n self.critic_summary_op = tf.summary.merge([\n tf.summary.scalar(self.name + \"_critc_mean_loss_Q\", tf.reduce_mean(self.critic_loss_1)),\n tf.summary.scalar(self.name + \"_critc_mean_loss_V\", tf.reduce_mean(self.critic_loss_2)),\n tf.summary.scalar(self.name + \"_critc_sum_loss_Q\", tf.reduce_sum(self.critic_loss_1)),\n tf.summary.scalar(self.name + \"_critc_sum_loss_V\", tf.reduce_sum(self.critic_loss_2)),\n tf.summary.scalar(self.name + \"_critc_mean_loss\", tf.reduce_mean(self.critic_loss)),\n tf.summary.scalar(self.name + \"_critc_sum_loss\", tf.reduce_sum(self.critic_loss)),\n tf.summary.histogram(self.name + \"_val_target\", self.v_target),\n tf.summary.histogram(self.name + \"_val_pred\", self.val_xi),\n tf.summary.histogram(self.name + \"_Q_pred\", self.adv_xi_ai),\n tf.summary.histogram(self.name + \"_Q_ret\", self.q_ret),\n tf.summary.histogram(self.name + \"_Q_opc\", self.q_opc),\n ] + critic_grads_summary)\n \n \n # actor summaries op\n\n actor_grads_summary = []\n print('-----------------------------------------------------------------')\n print('Create actor_grads_summary histogram ')\n for grad,var in zip(self.actor_grads, self.local_actor_vars):\n print('{} - {}'.format(var.name, grad))\n actor_grads_summary.append(tf.summary.histogram(var.name + '/gradient', grad))\n actor_grads_summary.append(tf.summary.histogram(var.name + '/weight', var))\n \n\n self.actor_summary_op = tf.summary.merge([\n tf.summary.scalar(self.name + \"_actor_mean_loss_reg_g\", tf.reduce_mean(self.reg_g)),\n tf.summary.scalar(self.name + \"_actor_neg_mean_loss_reg_g\", tf.reduce_mean(-self.reg_g)),\n tf.summary.scalar(self.name + \"_actor_sum_loss_reg_g\", tf.reduce_sum(self.reg_g)),\n tf.summary.scalar(self.name + \"_actor_neg_sum_reg_g\", tf.reduce_sum(-self.reg_g)),\n tf.summary.scalar(self.name + \"_actor_sum_g\", tf.reduce_sum(self.g)),\n tf.summary.scalar(self.name + \"_actor_neg_sum_g\", tf.reduce_sum(-self.g)),\n tf.summary.scalar(self.name + \"_actor_mean_kl\", tf.reduce_mean(self.k)),\n tf.summary.scalar(self.name + \"_actor_sum_kl\", tf.reduce_sum(self.k)),\n tf.summary.histogram(self.name + \"_policy_stats\", self.policy_xi_stats),\n ] + actor_grads_summary )","def linear_eval(train_ds, model, task, epochs=10, eval_ds=None):\n\n print('==========LINEAR EVAL==========')\n\n # Filter out undesired examples with excluded_label\n ds = train_ds.filter(lambda x: x['label'] != task['excluded_label'])\n ds = ds.map(data_utils.finetune_preprocess)\n ds = ds.shuffle(1000)\n ds = ds.batch(FLAGS.lineareval_bs)\n\n # loss, metrics, optimizers\n train_loss= tf.keras.metrics.Mean(name='train_loss')\n train_sup_acc = tf.keras.metrics.Accuracy(name='train_supervised_accuracy')\n criterion_sup = tf.nn.softmax_cross_entropy_with_logits \n optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)\n\n # Base network and projection head layers are not trainable in linear_eval\n model.resnet.trainable = False\n model.ph.trainable = False \n\n for epoch in range(epochs): \n model.resnet.trainable = False\n train_loss.reset_states()\n train_sup_acc.reset_states()\n for x in ds:\n with tf.GradientTape() as tape:\n image = x['image']\n labels = x[task['name']]\n out = model(image, mode='supervised', sup_layers=1, training=True)\n metrics.update_supervised_accuracy(train_sup_acc, labels, out)\n\n loss = criterion_sup(tf.one_hot(labels, depth=task['num_classes']), out)\n loss = tf.math.reduce_mean(loss)\n gradients = tape.gradient(loss, model.trainable_variables)\n optimizer.apply_gradients(\n filter(lambda gv: gv[0] is not None, zip(gradients, model.trainable_variables))\n )\n train_loss.update_state(loss)\n print('supervised (linear eval) loss')\n print(train_loss.result())\n print('supervised (linear eval) accuracy')\n print(train_sup_acc.result())\n\n # Evaluate results on eval_ds if possible\n if eval_ds is not None:\n evaluate(eval_ds, model, task)\n \n model.resnet.trainable = True\n model.ph.trainable = True","def find_results(data,weight_matrix,params):\r\n \r\n data = data.astype(np.float32)\r\n weight_matrix = weight_matrix.astype(np.float32)\r\n \r\n rank = params['rank']\r\n lamb = params['lambda']\r\n lr = params['lr']\r\n hidden_pairs = params['hidden_pairs']\r\n cost_functions.lamb = lamb\r\n\r\n f = cost_functions.frobenius \r\n V_masked = create_mask(data,hidden_pairs)\r\n bool_mask = V_masked.notnull().values\r\n tf_mask = tf.Variable(bool_mask)\r\n \r\n V = tf.constant(V_masked.values)\r\n laplacian_matrix = laplacian(weight_matrix).astype(np.float32)\r\n W, H = init_W_H(V.shape, rank=rank)\r\n WH = tf.matmul(W, H)\r\n L = tf.constant(laplacian_matrix)\r\n WTLW = tf.matmul(tf.matmul(tf.transpose(W), L), W)\r\n\r\n cost = f(V, tf_mask, WH, WTLW)\r\n train_step = tf.train.ProximalGradientDescentOptimizer(lr).minimize(cost)\r\n init = tf.global_variables_initializer()\r\n clip = get_clip(W, H)\r\n\r\n sess = tf.Session()\r\n sess.run(init)\r\n\r\n previous_cost = sess.run(cost)\r\n sess.run(train_step)\r\n sess.run(clip)\r\n initial_difference = previous_cost - sess.run(cost)\r\n\r\n matrix_errors = []\r\n graph_errors = []\r\n imputation_error = []\r\n\r\n learnt_W = sess.run(W).astype(np.float32)\r\n learnt_H = sess.run(H).astype(np.float32)\r\n imputation_norm = np.linalg.norm((data - learnt_W.dot(learnt_H))[~bool_mask])\r\n \r\n i = 0\r\n while np.isfinite(sess.run(cost)) and previous_cost-sess.run(cost) > TARGET_DIFFERENCE * initial_difference and i<=max_iterations:\r\n previous_cost = sess.run(cost)\r\n sess.run(train_step)\r\n sess.run(clip)\r\n matrix_errors.append(sess.run(cost_functions.matrix_cost))\r\n graph_errors.append(sess.run(cost_functions.graph_cost))\r\n i+=1\r\n\r\n learnt_W = sess.run(W).astype(np.float32)\r\n learnt_H = sess.run(H).astype(np.float32)\r\n\r\n imputation_norm = np.linalg.norm((data - learnt_W.dot(learnt_H))[~bool_mask])\r\n imputation_error.append(imputation_norm)\r\n\r\n return {'imputation_error':imputation_norm,'W':sess.run(W),'H':sess.run(H),\r\n 'graph_error':graph_errors,'matrix_error':matrix_errors,'imputation_error_list':imputation_error}","def test_cost(self):\n # Get components for the network\n data = array([[1, 0], [0, 1]])\n cdata = LabeledCData(data, labels=array([0, 1]))\n encoder = BinaryEncoding(cdata)\n ansatz = ProductAnsatz(2)\n measure = Measurement(2, [0, 1])\n\n # Define a basic predictor (function which inputs a measurement outcome and returns a label)\n def predictor(outcome):\n return 0\n\n # Build the network\n qnn = Network(layers=[encoder, ansatz, measure], computer=\"2q-qvm\", predictor=predictor)\n\n # Compute the cost of the network\n cost = qnn.cost(angles={0: [0.0], 1: [0.0]})\n\n self.assertAlmostEqual(cost, 0.5)","def mini_model(self):\n with tf.variable_scope(name_or_scope='human2d_network'):\n # down-sampling\n resi_0 = res_layer(self._input, filters=16, strides=2, kernel_size=7, training=self.training, name='resi_0')\n resi_1 = res_layer(resi_0, filters=32, strides=1, kernel_size=3, training=self.training, name='resi_1')\n pool_0 = max_pool_layer(resi_1, name='pool_0')\n resi_2 = res_layer(pool_0, filters=32, strides=1, kernel_size=3, training=self.training, name='resi_2')\n # hourglass module\n resi_3 = res_layer(resi_2, filters=64, strides=1, kernel_size=3, training=self.training, name='resi_3')\n hrgs_0 = hourglass_layer(resi_3, training=True, name='hrgs_0')\n # keypoint output\n keypoint_pre_0 = res_layer(hrgs_0, filters=64, strides=1, kernel_size=3, training=self.training,\n name='keypoint_pre_0')\n keypoint_pre_1 = res_layer(keypoint_pre_0, filters=64, strides=1, kernel_size=3, training=self.training,\n name='keypoint_pre_1')\n keypoint_pre_2 = res_layer(keypoint_pre_1, filters=64, strides=1, kernel_size=3, training=self.training,\n name='keypoint_pre_2')\n keypoint_output_raw = res_layer(keypoint_pre_2, filters=14, strides=1, kernel_size=1,\n training=self.training, bottleneck=False, name='keypoint_output_raw')\n keypoint_output = tf.nn.sigmoid(x=keypoint_output_raw, name='keypoint_output')\n # silhouette output\n silhouette_pre_0 = res_layer(hrgs_0, filters=64, strides=1, kernel_size=3, training=self.training,\n name='silhouette_pre_0')\n silhouette_pre_1 = res_layer(silhouette_pre_0, filters=64, strides=1, kernel_size=3, training=self.training,\n name='silhouette_pre_1')\n silhouette_pre_2 = res_layer(silhouette_pre_1, filters=64, strides=1, kernel_size=3, training=self.training,\n name='silhouette_pre_2')\n silhouette_output_raw = res_layer(silhouette_pre_2, filters=2, strides=1, kernel_size=1,\n training=self.training, bottleneck=False, name='silhouette_output_raw')\n silhouette_output = tf.nn.softmax(logits=silhouette_output_raw, name='silhouette_output')\n # return\n return None, None, keypoint_output, silhouette_output","def main():\n # construct the argument parse and parse the arguments\n args = argparse.ArgumentParser()\n args.add_argument(\"-o\", \"--output\", required=True, help=\"path to the output loss/accuracy plot\")\n args = vars(args.parse_args())\n\n # grab the MNIST dataset (if this is your first time using this\n # dataset then the 11MB download may take a minute)\n print(\"[INFO] accessing MNIST...\")\n ((train_x, train_y), (test_x, test_y)) = mnist.load_data()\n\n # each image in the MNIST dataset is represented as a 28x28x1\n # image, but in order to apply a standard neural network we must\n # first \"flatten\" the image to be simple list of 28x28=784 pixels\n train_x = train_x.reshape((train_x.shape[0], 28 * 28 * 1))\n test_x = test_x.reshape((test_x.shape[0], 28 * 28 * 1))\n # scale data to the range of [0, 1]\n train_x = train_x.astype(\"float32\") / 255.0\n test_x = test_x.astype(\"float32\") / 255.0\n\n # convert the labels from integers to vectors\n label_binarizer = LabelBinarizer()\n train_y = label_binarizer.fit_transform(train_y)\n test_y = label_binarizer.transform(test_y)\n\n # define the 784-256-128-10 architecture using Keras\n model = Sequential()\n model.add(Dense(256, input_shape=(784,), activation=\"sigmoid\"))\n model.add(Dense(128, activation=\"sigmoid\"))\n model.add(Dense(10, activation=\"softmax\"))\n\n # train the model using SGD\n print(\"[INFO] training network...\")\n sgd = SGD(0.01)\n model.compile(loss=\"categorical_crossentropy\", optimizer=sgd, metrics=[\"accuracy\"])\n model_fit = model.fit(train_x, train_y, validation_data=(test_x, test_y), epochs=100, batch_size=128)\n\n # evaluate the network\n print(\"[INFO] evaluating network...\")\n predictions = model.predict(test_x, batch_size=128)\n print(\n classification_report(\n test_y.argmax(axis=1), predictions.argmax(axis=1), target_names=[str(x) for x in label_binarizer.classes_]\n )\n )\n\n # plot the training loss and accuracy\n plt.style.use(\"ggplot\")\n plt.figure()\n plt.plot(np.arange(0, 100), model_fit.history[\"loss\"], label=\"train_loss\")\n plt.plot(np.arange(0, 100), model_fit.history[\"val_loss\"], label=\"val_loss\")\n plt.plot(np.arange(0, 100), model_fit.history[\"acc\"], label=\"train_acc\")\n plt.plot(np.arange(0, 100), model_fit.history[\"val_acc\"], label=\"val_acc\")\n plt.title(\"Training Loss and Accuracy\")\n plt.xlabel(\"Epoch #\")\n plt.ylabel(\"Loss/Accuracy\")\n plt.legend()\n plt.savefig(args[\"output\"])","def build_graph(self):\n if self.model == 'dense':\n # ForecastNet with two densely connected hidden layers in a cell and Mixture Density Network outputs\n self.outputs, self.mu, self.sigma, self.cost = forecastnet_graph(self.X,\n self.Y,\n self.hidden_dim,\n self.out_seq_length,\n self.is_training)\n elif self.model == 'conv':\n # ForecastNet with a convlutional neural network in a cell and Mixture Density Network outputs\n self.outputs, self.mu, self.sigma, self.cost = forecastnet_conv_graph(self.X,\n self.Y,\n self.hidden_dim,\n self.out_seq_length,\n self.is_training)\n elif self.model == 'dense2':\n # ForecastNet with two densely connected hidden layers in a cell and linear outputs\n self.outputs, self.cost = forecastnet_graph2(self.X,\n self.Y,\n self.hidden_dim,\n self.out_seq_length,\n self.is_training)\n elif self.model == 'conv2':\n # ForecastNet with a convolutional neural network in a cell and linear outputs\n self.outputs, self.cost = forecastnet_conv_graph2(self.X,\n self.Y,\n self.hidden_dim,\n self.out_seq_length,\n self.is_training)","def cost_derivative(self,output_results,y):\r\n\t\treturn (output_results-y)","def dev_network(self):\n freeze_model(self.eval_net)\n for data_set_name, data_set in self.data_to_dev.items():\n #print(data_set_name)\n valid_iter = make_data_iter(\n dataset=data_set, batch_size=1, batch_type=self.batch_type,\n shuffle=False, train=False)\n valid_sources_raw = data_set.src\n\n \n # don't track gradients during validation\n r_total = 0\n roptimal_total = 0\n all_outputs = []\n i_sample = 0\n\n for valid_batch in iter(valid_iter):\n # run as during training to get validation loss (e.g. xent)\n\n batch = Batch(valid_batch, self.pad_index, use_cuda=self.use_cuda)\n\n encoder_output, encoder_hidden = self.model.encode(\n batch.src, batch.src_lengths,\n batch.src_mask)\n\n # if maximum output length is \n # not globally specified, adapt to src len\n if self.max_output_length is None:\n self.max_output_length = int(max(batch.src_lengths.cpu().numpy()) * 1.5)\n\n batch_size = batch.src_mask.size(0)\n prev_y = batch.src_mask.new_full(size=[batch_size, 1], fill_value=self.bos_index,\n dtype=torch.long)\n output = []\n hidden = self.model.decoder._init_hidden(encoder_hidden)\n prev_att_vector = None\n finished = batch.src_mask.new_zeros((batch_size, 1)).byte()\n\n # pylint: disable=unused-variable\n for t in range(self.max_output_length):\n \n\n # if i_sample == 0 or i_sample == 3 or i_sample == 6:\n # print(\"state on t = \", t, \" : \" , state)\n\n # decode one single step\n logits, hidden, att_probs, prev_att_vector = self.model.decoder(\n encoder_output=encoder_output,\n encoder_hidden=encoder_hidden,\n src_mask=batch.src_mask,\n trg_embed=self.model.trg_embed(prev_y),\n hidden=hidden,\n prev_att_vector=prev_att_vector,\n unroll_steps=1)\n # greedy decoding: choose arg max over vocabulary in each step with egreedy porbability\n \n if self.state_type == 'hidden':\n state = torch.cat(hidden, dim=2).squeeze(1).detach().cpu()[0]\n else:\n state = torch.FloatTensor(prev_att_vector.squeeze(1).detach().cpu().numpy()[0])\n\n logits = self.eval_net(state)\n logits = logits.reshape([1,1,-1]) \n #print(type(logits), logits.shape, logits)\n next_word = torch.argmax(logits, dim=-1) \n a = next_word.squeeze(1).detach().cpu().numpy()[0]\n prev_y = next_word\n \n output.append(next_word.squeeze(1).detach().cpu().numpy())\n prev_y = next_word\n \n # check if previous symbol was <eos>\n is_eos = torch.eq(next_word, self.eos_index)\n finished += is_eos\n # stop predicting if <eos> reached for all elements in batch\n if (finished >= 1).sum() == batch_size:\n break\n stacked_output = np.stack(output, axis=1) # batch, time\n\n #decode back to symbols\n decoded_valid_in = self.model.trg_vocab.arrays_to_sentences(arrays=batch.src,\n cut_at_eos=True)\n decoded_valid_out_trg = self.model.trg_vocab.arrays_to_sentences(arrays=batch.trg,\n cut_at_eos=True)\n decoded_valid_out = self.model.trg_vocab.arrays_to_sentences(arrays=stacked_output,\n cut_at_eos=True)\n \n \n\n hyp = stacked_output\n\n r = self.Reward(batch.trg, hyp , show = False)\n \n if i_sample == 0 or i_sample == 3 or i_sample == 6:\n print(\"\\n Sample \", i_sample, \"-------------Target vs Eval_net prediction:--Raw---and---Decoded-----\")\n print(\"Target: \", batch.trg, decoded_valid_out_trg)\n print(\"Eval : \", stacked_output, decoded_valid_out, \"\\n\")\n print(\"Reward: \", r)\n\n #r = self.Reward1(batch.trg, hyp , show = False)\n r_total += sum(r[np.where(r > 0)])\n if i_sample ==0:\n roptimal = self.Reward(batch.trg, batch.trg , show = False)\n roptimal_total += sum(roptimal[np.where(roptimal > 0)])\n \n all_outputs.extend(stacked_output)\n i_sample += 1\n\n assert len(all_outputs) == len(data_set)\n\n # decode back to symbols\n decoded_valid = self.model.trg_vocab.arrays_to_sentences(arrays=all_outputs,\n cut_at_eos=True)\n\n # evaluate with metric on full dataset\n join_char = \" \" if self.level in [\"word\", \"bpe\"] else \"\"\n valid_sources = [join_char.join(s) for s in data_set.src]\n valid_references = [join_char.join(t) for t in data_set.trg]\n valid_hypotheses = [join_char.join(t) for t in decoded_valid]\n\n # post-process\n if self.level == \"bpe\":\n valid_sources = [bpe_postprocess(s) for s in valid_sources]\n valid_references = [bpe_postprocess(v)\n for v in valid_references]\n valid_hypotheses = [bpe_postprocess(v) for\n v in valid_hypotheses]\n\n # if references are given, evaluate against them\n if valid_references:\n assert len(valid_hypotheses) == len(valid_references)\n\n current_valid_score = 0\n if self.eval_metric.lower() == 'bleu':\n # this version does not use any tokenization\n current_valid_score = bleu(valid_hypotheses, valid_references)\n elif self.eval_metric.lower() == 'chrf':\n current_valid_score = chrf(valid_hypotheses, valid_references)\n elif self.eval_metric.lower() == 'token_accuracy':\n current_valid_score = token_accuracy(\n valid_hypotheses, valid_references, level=self.level)\n elif self.eval_metric.lower() == 'sequence_accuracy':\n current_valid_score = sequence_accuracy(\n valid_hypotheses, valid_references)\n else:\n current_valid_score = -1\n\n self.dev_network_count += 1\n self.tb_writer.add_scalar(\"dev/dev_reward\",\n r_total, self.dev_network_count)\n self.tb_writer.add_scalar(\"dev/dev_bleu\",\n current_valid_score, self.dev_network_count)\n \n print(self.dev_network_count ,' r_total and score: ', r_total , current_valid_score)\n\n \n unfreeze_model(self.eval_net)\n return current_valid_score","def __init__(self, input_dim, output_dim, hidden_dim=100, num_layers=2,\r\n num_epochs=100, learning_rate=0.001, threshold=0.1):\r\n super(ReluNet, self).__init__()\r\n\r\n self.input_dim = input_dim\r\n self.output_dim = output_dim\r\n self.hidden_dim = hidden_dim\r\n self.num_layers = num_layers\r\n self.num_epochs = num_epochs\r\n self.threshold = threshold\r\n self.learning_rate = learning_rate\r\n\r\n\r\n \r\n self.layers = nn.ModuleList()\r\n self.layers.append(nn.Linear(input_dim, hidden_dim))\r\n self.layers.append(nn.ReLU())\r\n for i in range(num_layers-1):\r\n self.layers.append(nn.Linear(hidden_dim, hidden_dim))\r\n self.layers.append(nn.ReLU())\r\n # output layer\r\n self.layers.append(nn.Linear(hidden_dim, output_dim))","def neural_network(X, Y, Xs_test, Ys_test,\n lr=0.1, iterations=2000, num_neurons=1000, num_layers=1, activation='ReLU'):\n ## YOUR CODE HERE\n #################\n # Copied from backprop_sol\n meanX = np.mean(X, axis=0)\n stdX = np.std(X, axis=0)\n meanY = np.mean(Y, axis=0)\n stdY = np.std(Y, axis=0)\n X = (X - meanX) / stdX\n Y = (Y - meanY) / stdY\n activations = dict(ReLU=ReLUActivation,\n tanh=TanhActivation,\n linear=LinearActivation)\n\n #### PART G ####\n activation_func = activations[activation]\n model = Model(X.shape[1])\n for iLayer in range(num_layers):\n model.addLayer(DenseLayer(num_neurons, activation_func()))\n model.addLayer(DenseLayer(Y.shape[1], LinearActivation()))\n model.initialize(QuadraticCost())\n\n # Train the model and display the results\n # model.trainBatch(X, Y, int(iterations / 10), iterations, GDOptimizer(eta=lr))\n model.train(X, Y, iterations, GDOptimizer(eta=lr))\n mses = []\n for i, X_test in enumerate(Xs_test):\n Y_test = Ys_test[i]\n Y_pred = model.predict((X_test - meanX) / stdX) * stdY + meanY\n mse = np.mean(np.sqrt(np.sum((Y_pred - Y_test) ** 2, axis=1)))\n mses.append(mse)\n return mses","def makeOptimizationStep(modelNet, targetNet, gameMemory, optimizer):\n statesBatch, actionsBatch, nextStatesBatch, rewardsBatch, terminalMask = gameMemory.getBatch()\n currentQValues = modelNet(statesBatch).gather(1, actionsBatch.unsqueeze(1))\n nextQValues = targetNet(nextStatesBatch).max(1)[0].detach()\n nextQValues[terminalMask == 1] = 0\n expectedQValues = rewardsBatch + nextQValues * DISCOUNT_FACTOR\n expectedQValues = torch.tensor(expectedQValues).unsqueeze(1).to(DEVICE)\n loss = F.smooth_l1_loss(currentQValues, expectedQValues)\n optimizer.zero_grad()\n loss.backward()\n for param in modelNet.parameters():\n param.grad.data.clamp_(-1, 1)\n optimizer.step()","def neural_network(X, Y, Xs_test, Ys_test):\n ## YOUR CODE HERE\n #################\n return 0","def nnObjFunction(params, *args):\r\n \r\n\r\n \r\n n_input, n_hidden, n_class, training_data, training_label, lambdaval = args\r\n w1 = params[0:n_hidden * (n_input + 1)].reshape( (n_hidden, (n_input + 1)))\r\n w2 = params[(n_hidden * (n_input + 1)):].reshape((n_class, (n_hidden + 1)))\r\n\r\n\r\n rowsToChange=xrange(len(training_label))\r\n \r\n oneKEncoding = np.zeros((len(training_label),10))\r\n \r\n for x,y in izip(rowsToChange,training_label):\r\n oneKEncoding[x,int(y)]=1\r\n \r\n training_label=oneKEncoding\r\n\r\n trans_w1=w1.T\r\n trans_w2=w2.T\r\n \r\n #add bias 1\r\n x=np.column_stack((training_data,np.ones(len(training_data))))\r\n #equation1\r\n eq1=np.dot(x,trans_w1)\r\n #equation 2\r\n z=sigmoid(eq1)\r\n #add bias 1\r\n z=np.column_stack((z,np.ones(len(z))))\r\n #equation 3\r\n eq3=np.dot(z,trans_w2)\r\n #equation 4\r\n o=sigmoid(eq3)\r\n\r\n #-----------------------------------------Calculations for gradient weight vector 2---------------------------------------------\r\n \r\n delta=np.subtract(o,training_label)\r\n eq5=np.sum(np.square(delta))\r\n\r\n dabba=(training_label-o)*(1-o)*o\r\n \r\n grad_w2=np.multiply(-1,np.dot(dabba.T,z)) \r\n \r\n\r\n #-----------------------------------------Calculations for gradient weight vector 1---------------------------------------------\r\n\r\n one_minus_z_into_z = (1-z)*z\r\n \r\n \r\n multiply_by_summation = one_minus_z_into_z*np.dot(dabba,w2)\r\n \r\n grad_w1_without_minus_one = np.dot(np.transpose(multiply_by_summation),x)\r\n \r\n\r\n grad_w1=np.multiply(-1,grad_w1_without_minus_one)\r\n \r\n grad_w1 = np.delete(grad_w1, n_hidden,0) \r\n \r\n\r\n #-----------------------------------------Calculations for gradient object value----------------------------------------\r\n\r\n \r\n obj_val=eq5/len(training_data)\r\n \r\n #-----------------------------------------Regularization of gradient val and weight vector-------------------------------\r\n \r\n obj_val = obj_val+ (lambdaval/(2*len(training_data)))*( np.sum(np.square(w1)) + np.sum(np.square(w2)))\r\n grad_w2 = (grad_w2 + lambdaval*w2 )/ len(training_data) \r\n grad_w1 = (grad_w1 + lambdaval*w1 )/ len(training_data) \r\n \r\n \r\n\r\n #-----------------------------------------Concatenate both the weight vectors---------------------------------------------\r\n\r\n obj_grad = np.array([])\r\n obj_grad = np.concatenate((grad_w1.flatten(), grad_w2.flatten()),0)\r\n return (obj_val,obj_grad)","def compute_cost_derivative(AL, Y):\n pass","def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\n\n ### YOUR CODE HERE\n scores = outputVectors.dot(predicted.T) # shape = (V, 1)\n y_hat = softmax(scores)\n cost = -scores[target] + np.log(np.sum(np.exp(scores)))\n one_hot_target = np.zeros_like(y_hat)\n one_hot_target[target] = 1\n grad = np.outer((y_hat - one_hot_target), predicted)\n gradPred = outputVectors.T.dot(y_hat - one_hot_target)\n \n '''\n final_predicted = predicted.dot(outputVectors.T)\n probability = softmax(final_predicted)\n cost = -np.log(probability[target])\n \n one_hot_target = np.zeros_like(probability)\n one_hot_target[target] += 1\n dlogits = probability - one_hot_target\n grad = np.outer(predicted, dlogits).T\n gradPred = outputVectors.T.dot(dlogits)\n '''\n ### END YOUR CODE\n\n return cost, gradPred, grad","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","def get_reconstruction_cost(self, updates, pre_sigmoid_nv):\r\n\r\n cross_entropy = T.mean(\r\n T.sum(self.input * T.log(T.nnet.sigmoid(pre_sigmoid_nv)) +\r\n (1 - self.input) * T.log(1 - T.nnet.sigmoid(pre_sigmoid_nv)),\r\n axis=1))\r\n\r\n return cross_entropy","def fit(self):\n accuracy = 0\n no_improvement = 0\n epochs = trange(self.args.epochs, desc=\"Accuracy\")\n self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.args.learning_rate)\n self.model.train()\n for epoch in epochs:\n self.optimizer.zero_grad()\n prediction = self.model(self.propagation_matrix, self.features)\n loss = torch.nn.functional.nll_loss(prediction[self.train_nodes], self.target[self.train_nodes])\n loss = loss + self.args.lambd*torch.sum(self.model.page_rank_convolution_1.weight_matrix**2)\n loss.backward()\n self.optimizer.step()\n new_accuracy = self.score(self.validation_nodes)\n epochs.set_description(\"Validation Accuracy: %g\" % round(new_accuracy,4))\n if new_accuracy < accuracy:\n no_improvement = no_improvement + 1\n if no_improvement == self.args.early_stopping:\n epochs.close()\n break\n else:\n no_improvement = 0\n accuracy = new_accuracy \n acc = self.score(self.test_nodes)\n print(\"\\nTest accuracy: \" + str(round(acc,4)) )","def direct_solve_least_square(policy, triple_pi_count, grad_log, state_list, tb_illustration):\n w_approxi = [torch.randn(count_parameters(policy), device= \"cuda\", requires_grad = True) for i in range(6)]\n lr = 1e-4\n if tb_illustration:\n sum_record = []\n for time_step in range(50):\n if time_step % 25 == 0:\n lr /= 5\n sum = torch.tensor(0., device= \"cuda\")\n for i in range(triple_pi_count[1].shape[0]):\n s_previous = triple_pi_count[0][i][0]\n action = triple_pi_count[0][i][1]\n s_later = triple_pi_count[0][i][2]\n n = triple_pi_count[1][i]\n sum = sum.add(n * torch.norm(w_approxi[s_later] - w_approxi[s_previous] - grad_log[s_previous][action])**2)\n sum.backward()\n if tb_illustration:\n sum_record.append(sum.cpu().item())\n w_approxi = [(j - lr * j.grad).detach().requires_grad_() for j in w_approxi]\n if tb_illustration:\n plt.plot(sum_record)\n tensorboard.add_figure(\"least square\", plt.gcf())\n with torch.no_grad():\n #w_approxi here is correct only on difference between each other, but its value is not fixed\n w_approxi_r = [(i - w_approxi[0]) for i in w_approxi]\n\n # get the distribution from trajectory, sort is for keeping the order\n state_, count_ = np.unique(np.sort(state_list), return_counts= True)\n state_count = np.zeros(6)\n for state, count in zip(state_,count_):\n state_count[state] = count\n state_distribution = state_count / np.sum(state_count)\n\n w_approxi_0 = - torch.sum(torch.stack([w_approxi_r[i] * state_distribution[i] for i in range(6)]), dim = 0)\n w_approxi_result = [(i + w_approxi_0).cuda() for i in w_approxi_r]\n\n return w_approxi_result","def build_network(self, dimList, actType=\"Tanh\", verbose=True):\n self.Q_network = Model(dimList, actType, verbose=verbose)\n self.target_network = Model(dimList, actType)\n\n if self.device == torch.device(\"cuda\"):\n self.Q_network.cuda()\n self.target_network.cuda()\n\n self.build_optimizer()","def vis_d():\n \n data_gen = generator(fixed_noise)\n# loss = d_loss(discriminator(data_gen), discriminator(grid))\n loss = g_loss(discriminator(grid))\n loss.backward()\n \n grads = - grid.grad.data.numpy()\n grid.grad.data *= 0 \n plt.quiver(X_grid, Y_grid, grads[:, 0], grads[:, 1], color='black',alpha=0.9)","def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):\n \n # initialize parameters with zeros (≈ 1 line of code)\n w, b = initialize_with_zeros(X_train.shape[0]) # 维度应该是X_train.shape[0] \n\n # Gradient descent (≈ 1 line of code)\n parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)\n \n # Retrieve parameters w and b from dictionary \"parameters\"\n w = parameters[\"w\"]\n b = parameters[\"b\"]\n \n # Predict test/train set examples (≈ 2 lines of code)\n Y_prediction_test = predict(w, b, X_test)\n Y_prediction_train = predict(w, b, X_train)\n\n ### END CODE HERE ###\n\n # Print train/test Errors\n print(\"train accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))\n print(\"test accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))\n\n \n d = {\"costs\": costs,\n \"Y_prediction_test\": Y_prediction_test, \n \"Y_prediction_train\" : Y_prediction_train, \n \"w\" : w, \n \"b\" : b,\n \"learning_rate\" : learning_rate,\n \"num_iterations\": num_iterations}\n \n return d","def cost(self, output, labels, weights):\n raise NotImplementedError('Must be overridden by concrete subclass')","def __init__(self, input_size, output_size, hidden_sizes=[],\r\n learning_rate=2.0, weight_scale=0.1, converge=0.01,\r\n random_seed=None):\r\n if random_seed is not None:\r\n seed(random_seed)\r\n\r\n weight_func = partial(normal, 0, weight_scale)\r\n self.converge = converge\r\n self.layers = []\r\n self.layers.append([InputNode(\"in_\" + str(i)) for i in range(input_size)])\r\n for i,layer_size in enumerate(hidden_sizes):\r\n self.layers.append([SigmoidNode(\"hidden_\"+str(i)+\"-\"+str(j),\r\n learning_rate) for j in range(layer_size)])\r\n self.layers.append([SigmoidNode(\"out_\"+str(i), learning_rate) for i\r\n in range(output_size)])\r\n\r\n # densely connect consecutive layers\r\n for source_layer, dest_layer in zip(self.layers, self.layers[1:]):\r\n for source, dest in product(source_layer, dest_layer):\r\n edge = Edge(source, dest, weight_func)\r\n source.out_edges.append(edge)\r\n dest.in_edges.append(edge)\r\n\r\n # connect each node to bias\r\n self.bias = BiasNode()\r\n for layer in self.layers[1:]:\r\n for node in layer:\r\n e = Edge(self.bias, node, weight_func)\r\n node.in_edges.append(e)\r\n self.bias.out_edges.append(e)","def solve(num_wizards, num_constraints, wizards, constraints):\n\n # print(num_wizards)\n # print(num_constraints)\n # print(wizards)\n # print(constraints)\n # node_set = set(wizards)\n \n\n\n def cost(sol,num_constraints,constraints):\n constraints_satisfied = 0\n constraints_failed = []\n output_ordering_map = {k: v for v, k in enumerate(sol)}\n for c in constraints:\n\n m = output_ordering_map # Creating an alias for easy reference\n\n wiz_a = m[c[0]]\n wiz_b = m[c[1]]\n wiz_mid = m[c[2]]\n\n if (wiz_a < wiz_mid < wiz_b) or (wiz_b < wiz_mid < wiz_a):\n constraints_failed.append(c)\n else:\n constraints_satisfied += 1\n return num_constraints - constraints_satisfied\n\n def neighbors(sol):\n wiz1 = random.randint(0,num_wizards-1)\n wiz2 = random.randint(0,num_wizards-1)\n\n new_sol = copy.copy(sol)\n temp = new_sol[wiz1]\n new_sol[wiz1] = new_sol[wiz2]\n new_sol[wiz2] = temp\n \n return new_sol\n\n def acceptance_probability(old_cost,new_cost,T):\n exponent = (old_cost - new_cost) / T\n \n try:\n ans = math.exp(exponent)\n except OverflowError:\n ans = float('inf')\n return ans\n\n\n def anneal(solution, num_constraints, constraints):\n old_cost = 0\n new_cost = 0\n old_cost = cost(solution,num_constraints,constraints)\n T = 1.0\n T_min = 0.000001\n alpha = 0.98\n while T > T_min:\n i = 1\n while i <= 1000:\n new_solution = neighbors(solution)\n new_cost = cost(new_solution,num_constraints,constraints)\n if new_cost == 0:\n return new_solution,new_cost\n ap = acceptance_probability(old_cost, new_cost, T)\n if ap > random.random():\n solution = new_solution\n old_cost = new_cost\n i += 1\n T = T*alpha\n return solution, old_cost\n\n s = copy.copy(wizards)\n random.shuffle(s)\n ret = anneal(s,num_constraints,constraints)\n \n for i in range(10):\n if ret[1] == 0:\n break\n random.shuffle(s)\n new_ret = anneal(s,num_constraints,constraints)\n print(i)\n if new_ret[1] < ret[1]:\n ret = new_ret\n print(\"constraints failed: {0}\".format(ret[1]))\n return ret[0]","def get_reconstruction_cost(self, pre_sigmoid_nv):\n y = self.input\n a = T.nnet.sigmoid(pre_sigmoid_nv)\n\n cross_entropy = -T.mean(\n T.sum(y * T.log(a) + (1 - y) * T.log(1 - a), axis=1)\n )\n\n return cross_entropy","def train(self, epochs = 100, n_input = 10, n_hidden = 40,\n hidden_learning_rate = 0.1, output_learning_rate = 0.1, momentum_learning_rate = 0.9,\n test_size=0.2, cv=3):\n\n # Initialize variables\n self.n_input = n_input\n self.n_hidden = n_hidden\n self.hidden_learning_rate = hidden_learning_rate\n self.output_learning_rate = output_learning_rate\n self.momentum_learning_rate = momentum_learning_rate\n\n self.n_output = len(unique(self.targets))\n self.V_hidden = zeros((self.n_input + 1, self.n_hidden))\n self.W_hidden = random_sample(self.V_hidden.shape)\n self.V_output = zeros((self.n_hidden + 1, self.n_output))\n self.W_output = random_sample(self.V_output.shape)\n\n data = self.dataset.data\n\n # Split into training and test\n X_train, X_test, y_train, y_test = train_test_split(data, self.targets, test_size=test_size)\n\n # Preprocess the data using PCA\n self.pca = PCA(n_components = self.n_input, whiten=True, copy=True)\n X_train = self.pca.fit_transform(X_train)\n X_test = self.pca.transform(X_test)\n self.X = self.pca.transform(data)\n\n # Start the training\n rmse=zeros((epochs,2))\n cerr=zeros((epochs,2))\n for t in arange(epochs):\n\n # Test then Train, since we'll use the training errors\n for i, (inputs, y) in enumerate([[X_test, y_test], [X_train, y_train]]):\n outputs, hidden = self.feed_forward(inputs)\n target=ones(outputs.shape)*(-1.0)\n target[arange(target.shape[0]),y]=1.0\n errors = target - outputs\n rmse[t, i] = sqrt((errors**2).mean()) # RMSE\n cerr[t, i] = (y != argmax(outputs,axis=1)).mean()\n\n yield rmse, cerr, t, epochs\n\n # Update weights using backpropagation\n self.back_propagate(inputs, hidden, outputs, errors)","def evaluate_viz_metrics(y_emb, dataset, verbose=1):\n results = {}\n\n # results[\"trust\"] = trustworthiness(dataset.inputs, y_emb, n_neighbors=5, metric=distance_metric)\n results[\"One NN accuracy\"] = nearest_neighbours_generalisation_accuracy(y_emb, dataset.labels, 1)\n results[\"Avg graph distance\"], results[\"Avg feature distance\"] = combined_dist_metric(y_emb, dataset.inputs, dataset.adj_matrix, k=5)\n results['Total distance'] = results[\"Avg graph distance\"] + results[\"Avg feature distance\"]\n\n if verbose:\n for k, v in results.items():\n print(\"{} = {:.4f}\".format(k, v))\n return results","def add_pseudo_cost_measure(self): \n \n node_index = theano.shared(value=0, name='node_index')\n\n x_bin = T.round(self.x)\n \n # flip node x_i of matrix x_bin and preserve all other bits x_{\\i}\n # Equivalent to x_bin[:, node_index] = 1-x_bin[:, node_index], but assigns\n # the result to x_bin_flip_i, instead of working in place on x_bin\n x_bin_flip_i = T.set_subtensor(x_bin[:, node_index], 1- x_bin[:, node_index])\n \n if self.num_hidden ==0:\n \n fe_x_bin = self.compute_energy(x_bin, self.batch_size)\n \n fe_x_bin_flip_i = self.compute_energy(x_bin_flip_i, self.batch_size)\n \n else:\n \n fe_x_bin = self.compute_free_energy(x_bin)\n \n fe_x_bin_flip_i = self.compute_free_energy(x_bin_flip_i)\n \n # mean(input dimension * log P ( xi | {x -i} ):\n self.pseudo_cost = T.mean(self.num_vars *\\\n T.log(T.nnet.sigmoid(fe_x_bin_flip_i- fe_x_bin)))\n\n # increment bit_i_idx % number as part of updates\n self.updates[node_index] = (node_index + 1) % self.num_vars","def main():\n # Load database\n (images_train, targets_train), (images_test, targets_test) = tf.keras.datasets.mnist.load_data()\n\n # Normalization\n images_train = images_train.reshape(-1, 784).astype(float)\n scaler = StandardScaler()\n images_train = scaler.fit_transform(images_train)\n images_test = images_test.reshape(-1, 784).astype(float)\n images_test = scaler.transform(images_test)\n\n images_train = images_train.reshape(-1, 28, 28, 1).astype(float)\n images_test = images_test.reshape(-1, 28, 28, 1).astype(float)\n\n # One hot encoding\n targets_train = tf.keras.utils.to_categorical(targets_train)\n targets_test = tf.keras.utils.to_categorical(targets_test)\n\n # Network architecture\n model = tf.keras.models.Sequential()\n model.add(tf.keras.layers.Conv2D(30, (5, 5), input_shape=(28, 28, 1), \\\n activation=\"relu\", padding='same'))\n model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))\n model.add(tf.keras.layers.Conv2D(15, (3, 3), activation=\"relu\", padding='same'))\n model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))\n model.add(tf.keras.layers.Flatten())\n model.add(tf.keras.layers.Dense(128, activation=\"relu\"))\n model.add(tf.keras.layers.Dense(50, activation=\"relu\"))\n model.add(tf.keras.layers.Dense(10, activation=\"softmax\"))\n\n # Learn\n optimizer = tf.keras.optimizers.SGD()\n\n @tf.function\n def train_step(images, targets):\n \"\"\"\n Define the training step by step\n \"\"\"\n # Save all operations\n with tf.GradientTape() as tape:\n # Make prediction\n predictions = model(images)\n # Compute loss\n loss = tf.keras.losses.categorical_crossentropy(targets, predictions)\n # Compute gradients\n gradients = tape.gradient(loss, model.trainable_variables)\n # Update model\n optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n\n batch_size = 32\n epochs = 10\n images_per_epoch = len(images_train) // batch_size\n for _ in range(epochs):\n for i in range(images_per_epoch):\n start = i*batch_size\n train_step(images_train[start:start+batch_size], targets_train[start:start+batch_size])\n\n # Compile must be defined to use evaluate method\n model.compile(\n loss=\"categorical_crossentropy\",\n optimizer=\"sgd\",\n metrics=[\"accuracy\"])\n\n # Evaluate on the test database\n scores = model.evaluate(images_test, targets_test, verbose=0)\n print(scores)","def _generateNetwork(self, n_actions, obs_space):\r\n \r\n import tensorflow as tf \r\n self._ALPHA = 1e-3 # learning rate \r\n RESIZED_SCREEN = 84\r\n self._STATE_FRAMES = 3 # states/images used for taking a decision\r\n \r\n # Graph for compressing the input image \r\n x, y, z = obs_space\r\n self._image_input_layer = tf.placeholder(\"float\", \r\n [None, x, y, z])\r\n image_step_size_x = int(np.ceil(float(x / RESIZED_SCREEN)))\r\n image_step_size_y = int(np.ceil(float(y / RESIZED_SCREEN)))\r\n extra_pad_x = RESIZED_SCREEN - int(x / image_step_size_x)\r\n extra_pad_y = RESIZED_SCREEN - int(y / image_step_size_y)\r\n self._image_output_layer = tf.nn.max_pool(\r\n self._image_input_layer, \r\n ksize=[1, image_step_size_x, image_step_size_y, 1],\r\n strides=[1, image_step_size_x, image_step_size_y, 1], \r\n padding=\"VALID\") \r\n \r\n # Function for compressing (and reshaping) the image\r\n self._compressImage = lambda obs : np.pad(\r\n self._session.run(\r\n self._image_output_layer, \r\n feed_dict={self._image_input_layer: np.array([obs])})/255.0, \r\n ((0,0), (0,extra_pad_x), (0,extra_pad_y), (0,0)),\r\n mode='constant') \r\n\r\n CONVOLUTION_FILTER_VECTOR = [6, 6, 4]\r\n CONVOLUTION_STRIDE_VECTOR = [3, 3, 2]\r\n CONVOLUTION_KERNEL_VECTOR = [16, 16, 36]\r\n CONVOLUTION_INPUT_VECTOR = ([z * self._STATE_FRAMES] + \r\n CONVOLUTION_KERNEL_VECTOR[:-1])\r\n FEED_FWD_VECTOR = [(3**2) * CONVOLUTION_KERNEL_VECTOR[-1], 64, \r\n n_actions] \r\n \r\n # The chosen activation function is the Leaky ReLU function\r\n self._activation = lambda x : tf.maximum(0.01*x, x)\r\n\r\n \r\n # Initialization parameters\r\n INITIALIZATION_STDDEV = 0.1\r\n INITIALIZATION_MEAN = 0.00\r\n INITIALIZATION_BIAS = -0.001\r\n\r\n # Convolutional layers\r\n self._input_layer = tf.placeholder(\"float\", \r\n [None, \r\n RESIZED_SCREEN, \r\n RESIZED_SCREEN, \r\n z * self._STATE_FRAMES])\r\n self._convolutional_weights = []\r\n self._convolutional_bias = []\r\n self._hidden_convolutional_layer = [self._input_layer]\r\n\r\n for i in range(len(CONVOLUTION_FILTER_VECTOR)):\r\n self._convolutional_weights.append(tf.Variable(tf.truncated_normal(\r\n [CONVOLUTION_FILTER_VECTOR[i], \r\n CONVOLUTION_FILTER_VECTOR[i], \r\n CONVOLUTION_INPUT_VECTOR[i], \r\n CONVOLUTION_KERNEL_VECTOR[i]], \r\n mean=INITIALIZATION_MEAN, \r\n stddev=INITIALIZATION_STDDEV)))\r\n self._convolutional_bias.append(tf.Variable(tf.constant(\r\n INITIALIZATION_BIAS, \r\n shape=[CONVOLUTION_KERNEL_VECTOR[i]])))\r\n self._hidden_convolutional_layer.append(\r\n self._activation(tf.nn.conv2d(\r\n self._hidden_convolutional_layer[i], \r\n self._convolutional_weights[i], \r\n strides=[1, \r\n CONVOLUTION_STRIDE_VECTOR[i],\r\n CONVOLUTION_STRIDE_VECTOR[i], \r\n 1], \r\n padding=\"VALID\") \r\n + self._convolutional_bias[i]))\r\n \r\n # Feed forward layers\r\n self._hidden_activation_layer = [tf.reshape(\r\n self._hidden_convolutional_layer[-1], \r\n [-1, FEED_FWD_VECTOR[0]])]\r\n self._feed_forward_weights = []\r\n self._feed_forward_bias = []\r\n\r\n for i in range(len(FEED_FWD_VECTOR) - 2):\r\n self._feed_forward_weights.append(tf.Variable(tf.truncated_normal(\r\n [FEED_FWD_VECTOR[i], \r\n FEED_FWD_VECTOR[i+1]], \r\n mean=INITIALIZATION_MEAN, \r\n stddev=INITIALIZATION_STDDEV)))\r\n self._feed_forward_bias.append(tf.Variable(tf.constant(\r\n INITIALIZATION_BIAS, shape=[FEED_FWD_VECTOR[i+1]])))\r\n self._hidden_activation_layer.append(self._activation(\r\n tf.matmul(self._hidden_activation_layer[i], \r\n self._feed_forward_weights[i]) \r\n + self._feed_forward_bias[i])\r\n )\r\n \r\n # The calculation of the state-action value function does not \r\n # require the neurons' activation function\r\n self._feed_forward_weights.append(tf.Variable(tf.truncated_normal(\r\n [FEED_FWD_VECTOR[-2], \r\n FEED_FWD_VECTOR[-1]], \r\n mean=INITIALIZATION_MEAN, \r\n stddev=INITIALIZATION_STDDEV)))\r\n self._feed_forward_bias.append(tf.Variable(tf.constant(\r\n INITIALIZATION_BIAS, \r\n shape=[FEED_FWD_VECTOR[-1]])))\r\n self._state_value_layer = (tf.matmul(self._hidden_activation_layer[-1], \r\n self._feed_forward_weights[-1]) \r\n + self._feed_forward_bias[-1])\r\n\r\n # Define the logic of the optimization\r\n self._action = tf.placeholder(\"float\", [None, n_actions])\r\n self._target = tf.placeholder(\"float\", [None])\r\n self._action_value_vector = tf.reduce_sum(tf.mul(\r\n self._state_value_layer, self._action), reduction_indices=1)\r\n self._cost = tf.reduce_sum(tf.square(\r\n self._target - self._action_value_vector))\r\n self._alpha = tf.placeholder('float')\r\n self._train_operation = tf.train.AdamOptimizer(\r\n self._alpha).minimize(self._cost)\r\n self._session = tf.Session()\r\n\r\n operation_intizializer = tf.initialize_all_variables()\r\n self._saver = tf.train.Saver()\r\n\r\n try:\r\n self._saver.restore(self._session, self._PARAMETERS_FILE_PATH)\r\n print ('Calibrated parameters SUCCESSFULLY LOADED.',\r\n flush=True)\r\n except:\r\n self._session.run(operation_intizializer)\r\n print ('It was not possible to load calibrated parameters.',\r\n flush=True)\r\n \r\n # Definition of feed_forward and optimization functions\r\n self._feedFwd = lambda state : self._session.run(\r\n self._state_value_layer, \r\n feed_dict={self._input_layer: state})\r\n \r\n self._backProp = lambda valueStates, actions, valueTarget : (\r\n self._session.run(self._train_operation, \r\n feed_dict={self._input_layer: valueStates,\r\n self._action: actions,\r\n self._target: valueTarget,\r\n self._alpha : self._ALPHA}))","def optimize(w, b, X, Y, num_iterations=100, learning_rate=0.009, print_cost=False):\n w = copy.deepcopy(w)\n b = copy.deepcopy(b)\n\n costs = []\n\n for i in range(num_iterations):\n grads, cost = propagate(w, b, X, Y)\n dw = grads[\"dw\"]\n db = grads[\"db\"]\n w = w - learning_rate * dw\n b = b - learning_rate * db\n\n if i % 100 == 0:\n costs.append(cost)\n if print_cost:\n print(\"Cost after iteration %i: %f\" % (i, cost))\n\n params = {\"w\": w, \"b\": b}\n\n grads = {\"dw\": dw, \"db\": db}\n\n return params, grads, costs","def transform(self):\n self.validate_ports()\n\n # TODO: Find a more reusable way of enforcing this behavior.\n if self.cost_sim.variable.ndim != 1:\n raise ValueError(\"`cost_sim` must be a vector.\")\n\n if self.cost_diff.variable.ndim != 1:\n raise ValueError(\"`cost_diff` must be a vector.\")\n\n cost_sim = self.cost_sim.variable\n cost_diff = self.cost_diff.variable\n alpha = self.alpha.variable\n margin = self.margin.variable\n\n cost = cost_diff - alpha * cost_sim + margin\n self.output.variable = T.mean(T.pow(functions.relu(cost), 2.0))","def grid_search(verbose):\n\n # Load Ising data.\n Ising_Data = prepare_Ising_DNN()\n\n # Perform grid search over learning rate and number of hidden neurons.\n N_neurons=np.logspace(0,3,4).astype(\"int\") # Check number of neurons over multiple decades.\n learning_rates=np.logspace(-6,-1,6)\n\n # Pre-allocate variables to store accuracy and loss data.\n train_loss=np.zeros((len(N_neurons),len(learning_rates)),dtype=np.float64)\n train_accuracy=np.zeros_like(train_loss)\n test_loss=np.zeros_like(train_loss)\n test_accuracy=np.zeros_like(train_loss)\n critical_loss=np.zeros_like(train_loss)\n critical_accuracy=np.zeros_like(train_loss)\n\n # Grid search.\n for i, neurons in enumerate(N_neurons):\n for j, lr in enumerate(learning_rates):\n\n print(\"training DNN with %4d neurons and SGD lr=%0.6f.\" %(neurons,lr) )\n\n train_loss[i,j],train_accuracy[i,j],\\\n test_loss[i,j],test_accuracy[i,j],\\\n critical_loss[i,j],critical_accuracy[i,j] = evaluate_model(neurons,lr,Ising_Data,verbose)\n\n plot_data(learning_rates,N_neurons,train_accuracy, \"training\")\n plot_data(learning_rates,N_neurons,test_accuracy, \"testing\")\n plot_data(learning_rates,N_neurons,critical_accuracy, \"critical\")"],"string":"[\n \"def deep_dream_of_extreme_control(FLAGS,model,input_images=[],num_iterations=10,step_size=0.1):\\n if len(input_images) == 0:\\n # use predefined images\\n img_dir='/esat/opal/kkelchte/docker_home/pilot_data/visualization_images'\\n input_images=sorted([img_dir+'/'+f for f in os.listdir(img_dir)])\\n\\n print(\\\"[tools.py]: extracting deep dream maps of {0} in {1}\\\".format([os.path.basename(i) for i in input_images], os.path.dirname(input_images[0])))\\n \\n # experts=np.asarray([[k]*(FLAGS.action_quantity if FLAGS.discrete else 1) for v in sorted(model.factor_offsets.values()) for k in model.factor_offsets.keys() if model.factor_offsets[k]==v]).flatten()\\n\\n inputs = load_images(input_images, model.input_size[1:])\\n \\n # collect gradients for output endpoint of evaluation model\\n grads={}\\n with tf.device('/cpu:0'):\\n output_tensor = model.endpoints['eval']['outputs']\\n for i in range(output_tensor.shape[1].value):\\n layer_loss = output_tensor[:,i]\\n gradients = tf.gradients(layer_loss, model.inputs)[0]\\n gradients /= (tf.sqrt(tf.reduce_mean(tf.square(gradients))) + 1e-5)\\n grads[output_tensor.name+'_'+str(i)]=gradients\\n\\n\\n # apply gradient ascent for all outputs and each input image\\n # if number of outputs ==1 apply gradient descent for contrast\\n if len(grads.keys())== 1:\\n opposite_results={}\\n else:\\n opposite_results=None\\n\\n import copy\\n results = {}\\n for gk in grads.keys(): \\n results[gk]=copy.deepcopy(inputs)\\n if isinstance(opposite_results,dict): opposite_results[gk]=copy.deepcopy(inputs)\\n\\n for step in range(num_iterations):\\n if step%10==0: print \\\"{0} step: {1}\\\".format(time.ctime(), step)\\n for i,gk in enumerate(sorted(grads.keys())):\\n results[gk] += step_size * model.sess.run(grads[gk], {model.inputs: results[gk]})\\n if isinstance(opposite_results,dict):\\n opposite_results[gk] -= step_size * model.sess.run(grads[gk], {model.inputs: opposite_results[gk]})\\n\\n # Normalize results within 0:1 range\\n clean_results={}\\n for gk in results.keys():\\n clean_results[gk]=[]\\n for i in range(results[gk].shape[0]):\\n clean_results[gk].append(deprocess_image(results[gk][i], one_channel=True))\\n # results[gk][i]=deprocess_image(results[gk][i], one_channel=True)\\n if isinstance(opposite_results,dict):\\n opposite_results[gk][i]=deprocess_image(opposite_results[gk][i])\\n\\n # combine adjust input images in one overview image\\n # one column for each input image\\n # one row with each extreme control for separate and difference images\\n num_rows=1+len(results.keys())\\n fig, axes = plt.subplots(num_rows ,min(len(input_images),5),figsize=(23, 4*(len(grads.keys())+1)))\\n # fig, axes = plt.subplots(num_rows ,min(len(input_images),5),figsize=(23, 4*(len(grads.keys())+1)))\\n # add original images in first row\\n for i in range(axes.shape[1]):\\n axes[0, i].set_title(os.path.basename(input_images[i]).split('.')[0])\\n axes[0, i].imshow(matplotlibprove(inputs[i]), cmap='inferno')\\n axes[0, i].axis('off')\\n\\n # add for each filter the modified input\\n row_index=1\\n for gk in sorted(results.keys()):\\n for i in range(axes.shape[1]):\\n # print gk\\n # axes[row_index, i].set_title('Grad Asc: '+gk.split('/')[1]+'/'+gk[-1]) \\n axes[row_index, i].set_title('Grad Asc: '+gk)\\n # axes[row_index, i].set_title(experts[row_index-1])\\n\\n axes[row_index, i].imshow(np.concatenate((inputs[i],np.expand_dims(clean_results[gk][i],axis=2)), axis=2), cmap='inferno')\\n # axes[row_index, i].imshow(matplotlibprove(results[gk][i]), cmap='inferno')\\n axes[row_index, i].axis('off')\\n row_index+=1\\n # In cas of continouos controls: visualize the gradient descent and difference\\n # if isinstance(opposite_results,dict):\\n # for gk in opposite_results.keys():\\n # for i in range(axes.shape[1]):\\n # # axes[row_index, i].set_title('Grad Desc: '+gk.split('/')[1]) \\n # axes[row_index, i].set_title('Grad Desc: '+gk) \\n # axes[row_index, i].imshow(matplotlibprove(opposite_results[gk][i]), cmap='inferno')\\n # axes[row_index, i].axis('off')\\n # row_index+=1\\n \\n # # add difference\\n # for gk in opposite_results.keys():\\n # for i in range(axes.shape[1]):\\n # # axes[row_index, i].set_title('Diff: '+gk.split('/')[1]) \\n # axes[row_index, i].set_title('Diff: '+gk) \\n # axes[row_index, i].imshow(matplotlibprove(deprocess_image((opposite_results[gk][i]-results[gk][i])**2)), cmap='inferno')\\n # axes[row_index, i].axis('off')\\n # row_index+=1\\n # else:\\n # # add difference between 2 exteme actions\\n # gk_left=sorted(results.keys())[0]\\n # gk_right=sorted(results.keys())[-1]\\n # for i in range(axes.shape[1]):\\n # # axes[row_index, i].set_title('Diff : '+gk.split('/')[1]) \\n # axes[row_index, i].set_title('Diff : '+gk) \\n # axes[row_index, i].imshow(matplotlibprove(deprocess_image((results[gk_left][i]-results[gk_right][i])**2)), cmap='inferno')\\n # axes[row_index, i].axis('off')\\n # row_index+=1\\n \\n \\n plt.savefig(FLAGS.summary_dir+FLAGS.log_tag+'/control_dream_maps.jpg',bbox_inches='tight')\\n # plt.show()\",\n \"def __init__(self):\\n super().__init__()\\n No_of_Inputs = 2\\n No_of_Outputs = 2\\n No_of_Hidden_nodes = 12\\n \\\"\\\"\\\" Defining the min and max values of the data used in training for normalizing the input values sent by game and denormalize the predicted output values from neural network \\\"\\\"\\\" \\n self.max_X_Distance = 636.2896274868181\\n self.min_X_Distance = -596.6699167751983\\n self.max_Y_Distance = 743.1598623474754\\n self.min_Y_Distance = 65.6244797954829\\n self.max_X_Velocity = 7.994655683732954\\n self.min_X_Velocity = -6.139791884122744\\n self.max_Y_Velocity = 6.116163006403942\\n self.min_Y_Velocity = -5.779221733928611\\n self.Neural_Net = Neuron_Network(No_of_Inputs, No_of_Hidden_nodes, No_of_Outputs)\\n self.Neural_Net.Hidden_Layer_Weights = [[-2.4968545286197834, -1.8753602229555426, -0.212544244291629], [-1.7630022249709958, -3.6728753504716702, 0.9029212995412115], [-9.92308792895824, 18.605900320220044, 0.6546005968930644], [-2.4482999114771995, -1.517816946765758, -0.9193463164391101], [-2.3427861053090684, -2.4881000020941877, 0.4629152770160724], [-2.1591465483332413, 1.0195709398508257, -3.550975138336682], [-4.121604475036676, 1.2541841992381966, 0.20872225266025077], [-2.794714837157948, -0.6250218903568433, -0.9508382423169754], [-2.171501881731379, -2.860403977932674, 0.45023268515928966], [-7.574606539172206, 5.796893890015888, 0.8325562788065618], [-2.3949093030515787, -1.6691739704587119, -0.8994153916849774], [-2.5057827237537236, -1.833523946060227, -0.15265344756899354]]\\n self.Neural_Net.Output_Layer_Weights = [[0.5339576155454724, -7.163855899626589, 4.441573522337238, -0.8487519667092871, 0.194328665944557, -6.253588662045125, 10.355395474689958, -0.5546973711452573, 1.3109277184619805, -2.8628613991153036, -3.4019242278486903, 0.920569758736398, -9.436494568306678], [-1.2778954480096152, 0.7155347068753504, 1.642050336134636, 1.847449069077208, 0.6888835859247565, 1.1005203424912922, 1.8925919549669181, -0.6795836727331039, 0.41572054666867386, 1.2533245105144883, -3.297414893260861, 0.7326422000597372, 0.6620055115639853]]\",\n \"def visualize_saliency_of_output(FLAGS, model, input_images=[]):\\n if len(input_images) == 0:\\n # use predefined images\\n img_dir='/esat/opal/kkelchte/docker_home/pilot_data/visualization_images'\\n input_images=sorted([img_dir+'/'+f for f in os.listdir(img_dir)])\\n\\n print(\\\"[tools.py]: extracting saliency maps of {0} in {1}\\\".format([os.path.basename(i) for i in input_images], os.path.dirname(input_images[0])))\\n \\n \\n inputs = load_images(input_images, model.input_size[1:])\\n\\n print 'shape: ',inputs.shape\\n\\n if 'nfc' in FLAGS.network:\\n inputs = np.concatenate([inputs]*FLAGS.n_frames, axis=-1)\\n \\n # extract deconvolution\\n import tf_cnnvis\\n\\n # layers = ['c']\\n # layers=['MobilenetV1_1/control/Conv2d_1c_1x1/Conv2D']\\n # layers=['MobilenetV1_1/control/Conv2d_1c_1x1/Conv2D','MobilenetV1_1/AvgPool_1a/AvgPool']\\n\\n # layers = [str(i.name) for i in model.sess.graph.get_operations() if 'outputs' in i.name and not 'activations' in i.name and not 'gradients' in i.name]\\n layers = [model.endpoints['eval']['outputs'].name[:-2]] #cut out :0 in the end to change name from tensor to operation name\\n # layers = ['outputs']\\n \\n # results = tf_cnnvis.activation_visualization(sess_graph_path = model.sess, \\n # value_feed_dict = {model.inputs : inputs}, \\n # layers=layers)\\n results = tf_cnnvis.deconv_visualization(sess_graph_path = model.sess, \\n value_feed_dict = {model.inputs : inputs}, \\n layers=layers)\\n\\n # Normalize deconvolution within 0:1 range\\n num_rows=0\\n clean_results={} \\n # Loop over layers\\n for k in results.keys():\\n clean_results[k]=[]\\n # Loop over channels\\n for c in range(len(results[k])):\\n num_rows+=1\\n clean_results[k].append(np.zeros((results[k][c].shape[0:3])))\\n # Loop over images\\n for i in range(results[k][c].shape[0]):\\n clean_results[k][c][i]=deprocess_image(results[k][c][i],one_channel=True)\\n if num_rows > 6:\\n print(\\\"[tools.py]: There are too many columns to create a proper image.\\\")\\n return\\n\\n # create one combined image with each input image on each column\\n fig, axes = plt.subplots(num_rows+1,min(len(input_images),5),figsize=(23, 4*(2*len(results.keys())+1)))\\n # fig, axes = plt.subplots(num_columns+1,min(len(input_images),5),figsize=(23, 4*(2*len(results.keys())+1)))\\n # add original images in first row\\n for i in range(axes.shape[1]):\\n axes[0, i].set_title(os.path.basename(input_images[i]).split('.')[0])\\n axes[0, i].imshow(matplotlibprove(inputs[i]), cmap='inferno')\\n axes[0, i].axis('off')\\n \\n # experts=np.asarray([[k]*(FLAGS.action_quantity if FLAGS.discrete else 1) for v in sorted(model.factor_offsets.values()) for k in model.factor_offsets.keys() if model.factor_offsets[k]==v]).flatten()\\n\\n # add deconvolutions over the columns\\n row_index = 1\\n for k in results.keys(): # go over layers\\n for c in range(len(results[k])): # add each channel in 2 new column\\n for i in range(axes.shape[1]): # fill row going over input images\\n # axes[row_index, i].set_title(k.split('/')[1]+'/'+k.split('/')[2]+'_'+str(c))\\n axes[row_index, i].set_title(k+'_'+str(c))\\n # axes[row_index, i].set_title(experts[c])\\n \\n axes[row_index, i].imshow(np.concatenate((inputs[i],np.expand_dims(clean_results[k][c][i],axis=2)), axis=2))\\n axes[row_index, i].axis('off')\\n # row_index+=2\\n row_index+=1\\n # plt.show()\\n plt.savefig(FLAGS.summary_dir+FLAGS.log_tag+'/saliency_maps.jpg',bbox_inches='tight')\",\n \"def explain(self):\\n # build the 2 versions of the model\\n model = self.build_model()\\n last_conv_model = self.build_cut_model()\\n\\n for i, label_name in enumerate(self.label_names):\\n # This is the algorithm for the last convolution layer's tensor image\\n # Get the index of the image that was classified correctly with the most confidence for the class\\n predicted_col_proba = np.array(self.predicted_labels)[0][:, i]\\n predicted_col_argsort = predicted_col_proba.argsort()[::-1]\\n predicted_col = (predicted_col_proba > 0.2).astype(int)\\n true_col = self.true_labels[:, 0]\\n\\n representative_image_index = None\\n for most_probable_arg_index in predicted_col_argsort:\\n if predicted_col[most_probable_arg_index] == true_col[most_probable_arg_index]:\\n representative_image_index = most_probable_arg_index\\n break\\n\\n # Resize the image to fit the neural network and keep the original resized image\\n original_img = io.imread('{}/{}/{}'.format(path_to_img_directory, self.ex_format, np.array(self.image_names)[representative_image_index]))\\n original_img = cv2.normalize(original_img, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\\n original_img = cv2.resize(original_img, dsize=(self.ex_input_size, self.ex_input_size), interpolation=cv2.INTER_CUBIC)\\n img = np.expand_dims(original_img, axis=0)\\n original_img = original_img[:, :, :3]\\n\\n # Get the output of the neural network for this image as a tensor\\n model.predict(np.array(img))\\n class_output = model.output[:, i]\\n last_conv_layer = model.get_layer(self.ex_last_conv_layer_name1).output\\n # if self.model_name == 'vit':\\n # last_conv_layer = tf.nn.relu(tf.reshape(last_conv_layer[:, :256, :], (-1, 16, 16, 1024)))\\n\\n # Get the output for the cut model\\n cut_img = last_conv_model.predict(np.array(img))[0]\\n if self.model_name == 'vit':\\n cut_img = np.reshape(cut_img[:256, :], (16, 16, 1024))\\n cut_img = np.mean(cut_img, axis=-1)\\n cut_img = cv2.normalize(cut_img, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\\n if self.model_name == 'vit':\\n cut_img[0, 0] = np.mean(cut_img)\\n cut_img = cv2.normalize(cut_img, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\\n cut_img = cv2.resize(cut_img, (self.ex_input_size, self.ex_input_size))\\n\\n # This is the algorithm of the Grad-CAM model\\n # Refine the output of the last convolutional layer according to the class output\\n grads = K.gradients(class_output, last_conv_layer)[0]\\n if self.model_name == 'vit':\\n last_conv_layer = tf.reshape(last_conv_layer[:, :256, :], (-1, 16, 16, 1024))\\n last_conv_layer = last_conv_layer / tf.norm(last_conv_layer)\\n\\n grads = tf.reshape(grads[:, :256, :], (-1, 16, 16, 1024))\\n grads = grads / tf.norm(grads)\\n\\n pooled_grads = K.mean(grads, axis=(0, 1, 2))\\n iterate = K.function([model.input], [pooled_grads, last_conv_layer[0]])\\n pooled_grads_value, conv_layer_output_value = iterate([img])\\n for j in range(self.ex_last_conv_layer_filter_number):\\n conv_layer_output_value[:, :, j] *= pooled_grads_value[j]\\n\\n # Create a 16x16 heatmap and scale it to the same size as the original image\\n heatmap = np.mean(conv_layer_output_value, axis=-1)\\n heatmap = np.maximum(heatmap, 0)\\n heatmap /= np.max(heatmap)\\n heatmap = cv2.resize(heatmap, (self.ex_input_size, self.ex_input_size))\\n heatmap = np.uint8(255 * heatmap)\\n heatmap = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)\\n heatmap = cv2.normalize(heatmap, None, alpha=0, beta=1, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)\\n superimposed_img = cv2.addWeighted(original_img, 0.7, heatmap, 0.4, 0)\\n\\n # save the original image\\n plt.matshow(original_img)\\n plt.axis('off')\\n plt.title(label_name, fontdict={'fontsize': 18})\\n plt.savefig('{}/{}/{}_{}.png'.format(path_to_explainable, 'original', self.model_name, label_name), bbox_inches='tight', pad_inches=0.1)\\n\\n # save the cut image\\n plt.matshow(cut_img, cmap=plt.get_cmap('Spectral'))\\n plt.colorbar(shrink=0.75, ticks=np.linspace(0, 1, 11).tolist())\\n plt.axis('off')\\n plt.title(label_name, fontdict={'fontsize': 18})\\n plt.savefig('{}/{}/{}_{}.png'.format(path_to_explainable, 'cut', self.model_name, label_name), bbox_inches='tight', pad_inches=0.1)\\n\\n # save the superimposed gradcam image\\n plt.matshow(superimposed_img, cmap=plt.get_cmap('Spectral'))\\n plt.colorbar(shrink=0.75, ticks=np.linspace(0, 1, 11).tolist())\\n plt.axis('off')\\n plt.title(label_name, fontdict={'fontsize': 18})\\n plt.savefig('{}/{}/{}_{}.png'.format(path_to_explainable, 'gradcam', self.model_name, label_name), bbox_inches='tight', pad_inches=0.1)\",\n \"def __init__(self, \\n inputs, \\n outputs, \\n hiddenUnits, \\n learningRate=0.3, \\n momentumRate=0., \\n regression=True,\\n adaptiveLearning=False,\\n adaptiveHistory=5,\\n adaptiveAlpha=0.05,\\n adaptiveBeta=2.0):\\n \\n if inputs < 1:\\n raise ValueError, 'Network must have at least one input'\\n \\n if outputs < 1:\\n raise ValueError, 'Network must have at least one output'\\n \\n if hiddenUnits < 1:\\n raise ValueError, 'Network must have at least one hidden unit'\\n \\n if learningRate <= 0:\\n raise ValueError, 'Learning rate must be above 0'\\n \\n if momentumRate < 0:\\n raise ValueError, 'Momentum rate must be at least 0'\\n \\n \\n self.H = hiddenUnits + 1 #need to have plus 1 for 1 in hidden layer\\n self.K = outputs\\n self.D = inputs + 1 #need to have plus 1 for 1 in input vector\\n self.lRate = learningRate\\n self.mRate = momentumRate\\n self.aLearning = adaptiveLearning\\n self.aHistory = adaptiveHistory\\n self.aAlpha = adaptiveAlpha\\n self.aBeta = adaptiveBeta\\n self.aErrors = []\\n self.regression = regression\\n\\n \\n #Init V(hidden layer to output layer weights) to small random numbers\\n self.V = [[_uniform(-1,1)/100. for h in range(self.H)] \\\\\\n for k in range(self.K)]\\n \\n \\n #Init W(intput layer to hidden layer weights) to small random numbers\\n self.W = [[_uniform(-1,1)/100. for d in range(self.D)] \\\\\\n for h in range(self.H-1)]\\n \\n #Init last step to 0\\n self.lastDeltaW = [[0 for d in range(self.D)] for h in range(self.H)]\",\n \"def main():\\n ###################\\n ## Dataset ##\\n ###################\\n # (X, y) m = 100, n = 1\\n _data_x, data_y = make_regression(n_samples=100, n_features=1, noise=10)\\n\\n # show the dataset\\n plt.subplot(2, 2, 1)\\n plt.title(\\\"dataset\\\")\\n plt.scatter(_data_x, data_y)\\n\\n # Transform the dataset into matrices.\\n # That is used for writing the equations in the matrix form.\\n data_x = np.hstack((_data_x, np.ones(_data_x.shape)))\\n data_y = data_y.reshape(data_y.shape[0], 1)\\n\\n #################\\n ## Model ##\\n #################\\n # initial parameters\\n init_params = np.random.randn(2, 1)\\n\\n # initial model\\n init_model = model(data_x, init_params)\\n\\n # plot initial model\\n plt.subplot(2, 2, 2)\\n plt.title(\\\"initial model\\\")\\n plt.scatter(_data_x, data_y)\\n plt.plot(_data_x, init_model, c='g')\\n\\n #########################\\n ## cost function ##\\n #########################\\n # show cost function for initial parameters\\n print(cost_function(data_x, data_y, init_params))\\n\\n ####################\\n ## training ##\\n ####################\\n # learning rate\\n learn_rate = 0.005\\n # number of iterations\\n number_iterations = 1_000\\n\\n # final parameters for our model\\n final_params, cost_tracking = gradient_descent(\\n data_x, data_y, init_params, learn_rate, number_iterations)\\n\\n # final model\\n final_model = model(data_x, final_params)\\n\\n # show cost function for final parameters\\n print(cost_function(data_x, data_y, final_params))\\n\\n # plot final model\\n plt.subplot(2, 2, 3)\\n plt.title(\\\"final model\\\")\\n plt.scatter(_data_x, data_y)\\n plt.plot(_data_x, final_model, c='r')\\n\\n ##########################\\n ## learning curve ##\\n ##########################\\n # plot Cost history\\n plt.subplot(2, 2, 4)\\n plt.title(\\\"cost tracking\\\")\\n plt.plot(range(number_iterations), cost_tracking)\\n\\n ########################################\\n ## Coefficient of determination ##\\n ########################################\\n print(coefficient_determination(data_y, final_model))\\n\\n plt.show()\",\n \"def nn_cost_function(nn_params, input_layer_size, hidden_layer_size, num_labels, X, y, l):\\n Theta_1 = np.reshape(nn_params[0:(hidden_layer_size * (input_layer_size + 1)), ],\\n (hidden_layer_size, input_layer_size + 1))\\n Theta_2 = np.reshape(nn_params[(hidden_layer_size * (input_layer_size + 1)):, ],\\n (num_labels, hidden_layer_size + 1))\\n\\n m, n = X.shape\\n X = np.hstack((np.ones((m, 1)), X))\\n\\n Z_2 = X.dot(Theta_1.T)\\n A_2 = sigmoid(Z_2)\\n A_2 = np.hstack((np.ones((m, 1)), A_2))\\n\\n Z_3 = A_2.dot(Theta_2.T)\\n A_3 = sigmoid(Z_3)\\n\\n Y = np.zeros((m, num_labels))\\n for i in range(m):\\n Y[i, y[i] - 1] = 1\\n\\n j = 0.0\\n for i in range(m):\\n j += np.log(A_3[i, ]).dot(-Y[i, ].T) - np.log(1 - A_3[i, ]).dot(1 - Y[i, ].T)\\n j /= m\\n\\n Theta_1_square = np.square(Theta_1[:, 1:])\\n Theta_2_square = np.square(Theta_2[:, 1:])\\n reg = 1.0 * l / (2 * m) * (np.sum(Theta_1_square) + np.sum(Theta_2_square))\\n j += reg\\n\\n d_3 = A_3 - Y\\n D_2 = d_3.T.dot(A_2)\\n\\n Z_2 = np.hstack((np.ones((m, 1)), Z_2))\\n d_2 = d_3.dot(Theta_2) * sigmoid_gradient(Z_2)\\n d_2 = d_2[:, 1:]\\n D_1 = d_2.T.dot(X)\\n\\n Theta_1_grad = 1.0 * D_1 / m\\n Theta_1_grad[:, 1:] = Theta_1_grad[:, 1:] + 1.0 * l / m * Theta_1[:, 1:]\\n\\n Theta_2_grad = 1.0 * D_2 / m\\n Theta_2_grad[:, 1:] = Theta_2_grad[:, 1:] + 1.0 * l / m * Theta_2[:, 1:]\\n\\n grad = np.hstack((Theta_1_grad.ravel(), Theta_2_grad.ravel()))\\n\\n return j, grad\",\n \"def disp_net(target_image, is_training=True):\\n batch_norm_params = {'is_training': is_training}\\n h = target_image.get_shape()[1].value\\n w = target_image.get_shape()[2].value\\n inputs = target_image\\n with tf.variable_scope('depth_net') as sc:\\n end_points_collection = sc.original_name_scope + '_end_points'\\n normalizer_fn = slim.batch_norm if FLAGS.use_bn else None\\n normalizer_params = batch_norm_params if FLAGS.use_bn else None\\n with slim.arg_scope([slim.conv2d, slim.conv2d_transpose],\\n normalizer_fn=normalizer_fn,\\n normalizer_params=normalizer_params,\\n weights_regularizer=slim.l2_regularizer(WEIGHT_REG),\\n activation_fn=tf.nn.relu,\\n outputs_collections=end_points_collection):\\n cnv1 = slim.conv2d(inputs, 32, [7, 7], stride=2, scope='cnv1')\\n cnv1b = slim.conv2d(cnv1, 32, [7, 7], stride=1, scope='cnv1b')\\n cnv2 = slim.conv2d(cnv1b, 64, [5, 5], stride=2, scope='cnv2')\\n cnv2b = slim.conv2d(cnv2, 64, [5, 5], stride=1, scope='cnv2b')\\n\\n cnv3 = slim.conv2d(cnv2b, 128, [3, 3], stride=2, scope='cnv3')\\n cnv3b = slim.conv2d(cnv3, 128, [3, 3], stride=1, scope='cnv3b')\\n cnv4 = slim.conv2d(cnv3b, 256, [3, 3], stride=2, scope='cnv4')\\n cnv4b = slim.conv2d(cnv4, 256, [3, 3], stride=1, scope='cnv4b')\\n cnv5 = slim.conv2d(cnv4b, 512, [3, 3], stride=2, scope='cnv5')\\n cnv5b = slim.conv2d(cnv5, 512, [3, 3], stride=1, scope='cnv5b')\\n cnv6 = slim.conv2d(cnv5b, 512, [3, 3], stride=2, scope='cnv6')\\n cnv6b = slim.conv2d(cnv6, 512, [3, 3], stride=1, scope='cnv6b')\\n cnv7 = slim.conv2d(cnv6b, 512, [3, 3], stride=2, scope='cnv7')\\n cnv7b = slim.conv2d(cnv7, 512, [3, 3], stride=1, scope='cnv7b')\\n\\n up7 = slim.conv2d_transpose(cnv7b, 512, [3, 3], stride=2, scope='upcnv7')\\n # There might be dimension mismatch due to uneven down/up-sampling.\\n up7 = _resize_like(up7, cnv6b)\\n i7_in = tf.concat([up7, cnv6b], axis=3)\\n icnv7 = slim.conv2d(i7_in, 512, [3, 3], stride=1, scope='icnv7')\\n\\n up6 = slim.conv2d_transpose(icnv7, 512, [3, 3], stride=2, scope='upcnv6')\\n up6 = _resize_like(up6, cnv5b)\\n i6_in = tf.concat([up6, cnv5b], axis=3)\\n icnv6 = slim.conv2d(i6_in, 512, [3, 3], stride=1, scope='icnv6')\\n\\n up5 = slim.conv2d_transpose(icnv6, 256, [3, 3], stride=2, scope='upcnv5')\\n up5 = _resize_like(up5, cnv4b)\\n i5_in = tf.concat([up5, cnv4b], axis=3)\\n icnv5 = slim.conv2d(i5_in, 256, [3, 3], stride=1, scope='icnv5')\\n\\n up4 = slim.conv2d_transpose(icnv5, 128, [3, 3], stride=2, scope='upcnv4')\\n i4_in = tf.concat([up4, cnv3b], axis=3)\\n icnv4 = slim.conv2d(i4_in, 128, [3, 3], stride=1, scope='icnv4')\\n disp4 = (slim.conv2d(icnv4, 1, [3, 3], stride=1, activation_fn=tf.sigmoid,\\n normalizer_fn=None, scope='disp4')\\n * DISP_SCALING + MIN_DISP)\\n disp4_up = tf.image.resize_bilinear(disp4, [np.int(h / 4), np.int(w / 4)])\\n\\n up3 = slim.conv2d_transpose(icnv4, 64, [3, 3], stride=2, scope='upcnv3')\\n i3_in = tf.concat([up3, cnv2b, disp4_up], axis=3)\\n icnv3 = slim.conv2d(i3_in, 64, [3, 3], stride=1, scope='icnv3')\\n disp3 = (slim.conv2d(icnv3, 1, [3, 3], stride=1, activation_fn=tf.sigmoid,\\n normalizer_fn=None, scope='disp3')\\n * DISP_SCALING + MIN_DISP)\\n disp3_up = tf.image.resize_bilinear(disp3, [np.int(h / 2), np.int(w / 2)])\\n\\n up2 = slim.conv2d_transpose(icnv3, 32, [3, 3], stride=2, scope='upcnv2')\\n i2_in = tf.concat([up2, cnv1b, disp3_up], axis=3)\\n icnv2 = slim.conv2d(i2_in, 32, [3, 3], stride=1, scope='icnv2')\\n disp2 = (slim.conv2d(icnv2, 1, [3, 3], stride=1, activation_fn=tf.sigmoid,\\n normalizer_fn=None, scope='disp2')\\n * DISP_SCALING + MIN_DISP)\\n disp2_up = tf.image.resize_bilinear(disp2, [h, w])\\n\\n up1 = slim.conv2d_transpose(icnv2, 16, [3, 3], stride=2, scope='upcnv1')\\n i1_in = tf.concat([up1, disp2_up], axis=3)\\n icnv1 = slim.conv2d(i1_in, 16, [3, 3], stride=1, scope='icnv1')\\n disp1 = (slim.conv2d(icnv1, 1, [3, 3], stride=1, activation_fn=tf.sigmoid,\\n normalizer_fn=None, scope='disp1')\\n * DISP_SCALING + MIN_DISP)\\n\\n end_points = slim.utils.convert_collection_to_dict(end_points_collection)\\n return [disp1, disp2, disp3, disp4], end_points\",\n \"def neural_network(X, Y, X_test, Y_test, num_layers, activation):\\n \\n X_n = (X - np.mean(X, axis = 0)) / np.std(X, axis = 0)\\n Y_n = (Y - np.mean(Y, axis = 0)) / np.std(Y, axis = 0)\\n \\n if num_layers == 1:\\n num_neurons = 1000\\n elif num_layers == 2:\\n num_neurons = 200\\n elif num_layers == 3:\\n num_neurons = 141\\n elif num_layers == 4:\\n num_neurons = 115\\n\\n if activation == \\\"ReLU\\\":\\n activation = ReLUActivation\\n elif activation == \\\"tanh\\\":\\n activation = TanhActivation\\n else:\\n print('Null activation')\\n\\n model = Model(X_n.shape[1])\\n model.addLayer(DenseLayer(num_neurons,activation()))\\n if num_layers >= 2:\\n model.addLayer(DenseLayer(num_neurons,activation()))\\n if num_layers >= 3:\\n model.addLayer(DenseLayer(num_neurons,activation()))\\n\\n model.addLayer(DenseLayer(Y.shape[1],LinearActivation()))\\n model.initialize(QuadraticCost())\\n \\n Y_pred = model.predict((X_test - np.mean(X, axis = 0)) / np.std(X, axis = 0)) \\n Y_pred = Y_pred * np.std(Y, axis = 0) + np.mean(Y, axis = 0)\\n mse = np.mean(np.sqrt(np.sum((Y_pred - Y_test) ** 2, axis = 1))) \\n return mse\",\n \"def calculate_costs(self):\\n cost_matrix = self.make_cost_matrix()\\n \\n if self.greedy:\\n # Riesen et al., \\\"Greedy Graph Edit Distance\\\"\\n costs = []\\n psi = []\\n \\n for row in range(self.N):\\n phi = self.M\\n row_min = sys.maxint\\n for column in range(self.N+self.M):\\n if column not in psi:\\n if cost_matrix[row, column] < row_min:\\n row_min = cost_matrix[row, column]\\n phi = column\\n \\n costs.append(row_min)\\n if phi < self.M:\\n psi.append(phi)\\n \\n for row in range(self.N, self.N+self.M):\\n if (row - self.N) not in psi:\\n costs.append(cost_matrix[row, row - self.N])\\n else:\\n # Riesen & Bunke, \\\"Approximate graph edit distance computation by means of bipartite graph matching\\\"\\n row_ind, col_ind = optimize.linear_sum_assignment(cost_matrix)\\n \\n if self.verbose:\\n for row, column in (row_ind, col_ind):\\n value = cost_matrix[row, column]\\n print '%d, %d, %.4f' % (row, column, value)\\n \\n return row_ind, col_ind, cost_matrix[row_ind, col_ind]\",\n \"def deepnn(self, x, ind):\\n '''\\n print(x.shape)\\n indices = ind\\n self.ind = ind\\n depth = 18\\n oh = tf.one_hot(indices, depth)\\n self.oh = oh\\n\\n s = tf.matmul(oh, self.scale)\\n self.s = s\\n \\n '''\\n \\n \\n #h_layer1 = tf.layers.dense(inputs=x, units=1, name='h0', activation=tf.nn.relu)\\n #h_layer0 = tf.layers.dense(inputs=x, units=100, name='h0', activation=tf.nn.relu)\\n #h_layer0_drop = tf.nn.dropout(h_layer0, self.keep_prob, name='h0_drop')\\n #h_layer1 = tf.layers.dense(inputs = h_layer0, units = 1, name = 'h1', activation = tf.nn.relu)\\n \\n stop1 = int(self._xdims/3)\\n x1 = x[:,:stop1]\\n x2 = x[:,stop1:2*stop1]\\n x3 = x[:,2*stop1:3*stop1]\\n #x4 = x[:,3*stop1:4*stop1]\\n #x5 = x[:,4*stop1:]\\n d1 = tf.layers.dense(inputs=x1, units=100, name='h0_1', activation=tf.nn.relu)\\n d1_layer0_drop = tf.nn.dropout(d1, self.keep_prob, name='d1_drop')\\n d2 = tf.layers.dense(inputs=x2, units=100, name='h0_2', activation=tf.nn.relu)\\n d2_layer0_drop = tf.nn.dropout(d2, self.keep_prob, name='d2_drop')\\n d3 = tf.layers.dense(inputs=x3, units=100, name='h0_3', activation=tf.nn.relu)\\n d3_layer0_drop = tf.nn.dropout(d3, self.keep_prob, name='d3_drop')\\n #d4 = tf.layers.dense(inputs=x2, units=100, name='h0_4', activation=tf.nn.relu)\\n #d4_layer0_drop = tf.nn.dropout(d4, self.keep_prob, name='d2_drop')\\n #d5 = tf.layers.dense(inputs=x3, units=100, name='h0_5', activation=tf.nn.relu)\\n #d5_layer0_drop = tf.nn.dropout(d5, self.keep_prob, name='d3_drop')\\n \\n layer_2 = tf.concat([d1,d2,d3],1)#,d4,d5], 1)\\n h_layer1 = tf.layers.dense(inputs=layer_2, units=1, name='output', activation=tf.nn.relu)\\n \\n '''\\n out = tf.multiply(s,h_layer1)\\n self.out = out\\n self.h0 = h_layer1\\n return out\\n '''\\n return h_layer1\",\n \"def run_visualization(image):\\n # for image in images:\\n try:\\n with tf.gfile.FastGFile(image, 'rb') as f:\\n jpeg_str = f.read()\\n original_im = Image.open(BytesIO(jpeg_str))\\n except IOError:\\n print('Cannot retrieve image')\\n return\\n\\n # print('running deeplab on image {0}'.format(image))\\n resized_im, seg_map = MODEL.run(original_im)\\n seg_map = seg_map.astype(np.uint8) * 255\\n resized_im = np.array(resized_im, dtype=np.uint8)\\n resized_im = cv2.cvtColor(resized_im, cv2.COLOR_BGR2RGB)\\n # vis_segmentation(resized_im, seg_map,FULL_COLOR_MAP ,LABEL_NAMES)\\n overlay_image = cv2.addWeighted(resized_im, 0.8, cv2.merge((seg_map * 0, seg_map, seg_map * 0)), 0.2, 0)\\n # time.sleep(params.SEC_BETWEEN_PREDICTION)\\n\\n return resized_im, seg_map, overlay_image.astype(np.uint8)\",\n \"def make_neural_net_challenging():\\n i0 = Input('i0', -1.0) # this input is immutable\\n i1 = Input('i1', 0.0)\\n i2 = Input('i2', 0.0)\\n seed_random()\\n wt1 = random_weight()\\n wt2 = random_weight()\\n wt3 = random_weight()\\n wt4 = random_weight()\\n wt5 = random_weight()\\n wt6 = random_weight()\\n wt7 = random_weight()\\n wt8 = random_weight()\\n wt9 = random_weight()\\n wt10 = random_weight()\\n\\t\\n w1A = Weight('w1A', wt1)\\n w2A = Weight('w2A', wt2)\\n w1B = Weight('w1B', wt3)\\n w2B = Weight('w2B', wt4)\\n wA = Weight('wA', -1)\\n wB = Weight('wB', -1)\\n wAC = Weight('wAC', wt5)\\n wBC = Weight('wBC', wt6)\\n wC = Weight('wC', -1)\\n wAD = Weight('wAD', wt7)\\n wBD = Weight('wBD', wt8)\\n wD = Weight('wD', -1)\\n wCE = Weight('wCE', wt9)\\n wDE = Weight('wDE', wt10)\\n wE = Weight('wE', -1)\\n\\n # Inputs must be in the same order as their associated weights\\n A = Neuron('A', [i1,i2,i0], [w1A,w2A,wA])\\n B = Neuron('B', [i1,i2,i0], [w1B,w2B,wB])\\n C = Neuron('C', [A,B,i0], [wAC,wBC,wC])\\n D = Neuron('D', [A,B,i0], [wAD,wBD,wD])\\n E = Neuron('D', [C,D,i0], [wCE,wDE,wE])\\n P = PerformanceElem(E, 0.0)\\n\\n net = Network(P,[A, B, C, D, E])\\n return net\",\n \"def add_objective(self): \\n \\n if \\\"CSS\\\" in self.algorithm:\\n \\n if self.num_hidden == 0:\\n \\n data_term = self.compute_energy(self.x, self.batch_size)\\n \\n else:\\n \\n data_term = self.compute_free_energy(self.x)\\n \\n normalizer_term = self.add_css_approximation(data_term)\\n \\n if \\\"CD\\\" in self.algorithm and self.num_hidden ==0:\\n \\n data_term = self.compute_energy(self.x, self.batch_size)\\n \\n normalizer_term = self.compute_energy(self.x_gibbs, \\n self.batch_size)\\n \\n normalizer_term = -T.mean(normalizer_term)\\n \\n if \\\"CD\\\" in self.algorithm and self.num_hidden > 0:\\n \\n data_term = self.compute_free_energy(self.x)\\n \\n normalizer_term = self.compute_free_energy(self.rbm_cd_samples)\\n \\n normalizer_term = -T.mean(normalizer_term)\\n \\n # cost is negative log likelihood \\n self.cost = T.mean(data_term) + normalizer_term\",\n \"def compute_visuals(self):\\n pass\",\n \"def run():\\n cons_in, soln_in, disc = make_discriminator()\\n target, loss, accuracy, optimiser = make_training_nodes(disc)\\n training_set_sampler = make_sampler(cons_in, soln_in, target)\\n test_set_sampler = make_sampler(cons_in, soln_in, target)\\n\\n disc.get_session().run(tf.global_variables_initializer())\\n\\n fit(\\n disc.get_session(),\\n optimiser,\\n training_set_sampler,\\n 250,\\n 2000,\\n 32,\\n [(\\\"Loss\\\", loss), (\\\"Accuracy\\\", accuracy)],\\n )\\n\\n print(\\n \\\"Validation accuracy: {}\\\".format(\\n disc.feed(accuracy, test_set_sampler.batch(1024))\\n )\\n )\\n\\n plot_surface(\\n evaluate_surface(\\n lambda x, y: Circles.solve([0, 0, 0.25], [x, y, 0.25]),\\n (-1, 1, 0.08),\\n (-1, 1, 0.08),\\n ),\\n x_label=\\\"Solution x\\\",\\n y_label=\\\"Solution y\\\",\\n z_label=\\\"p(satisfied | x, y)\\\",\\n )\\n\\n plot_surface(\\n evaluate_surface(\\n lambda x, y: disc.feed(\\n disc.output_node, {cons_in: [[0, 0, 0.25]], soln_in: [[x, y, 0.25]]}\\n )[0],\\n (-1, 1, 0.08),\\n (-1, 1, 0.08),\\n ),\\n x_label=\\\"Solution x\\\",\\n y_label=\\\"Solution y\\\",\\n z_label=\\\"p(satisfied | x, y)\\\",\\n )\",\n \"def negSamplingCostAndGradient(predicted, target, outputVectors, dataset,\\n K=10):\\n\\n # Sampling of indices is done for you. Do not modify this if you\\n # wish to match the autograder and receive points!\\n indices = [target]\\n indices.extend(getNegativeSamples(target, dataset, K))\\n\\n ### YOUR CODE HERE\\n # Similar to softmax, we find the target matrix\\n # v_c structured as 1xD matrix\\n # u_o assume to be 1xD matrix\\n # u_k assume to be K x D matrix\\n # we pull the data assuming that each row represent one vector\\n v_c = predicted\\n u_o = outputVectors[target]\\n u_k = outputVectors[indices]\\n\\n\\n # The intermediary matrix outputs\\n # z_o, h_o: single scalar number\\n # z_k, h_k: K x 1 vector, wich each number associated with a neg sample\\n z_o = np.dot(u_o, v_c)\\n h_o = sigmoid(z_o)\\n z_k = np.dot(u_k, v_c)\\n h_k = sigmoid( - z_k)\\n\\n J_1 = - np.log(h_o)\\n J_2 = - np.sum( np.log(h_k) )\\n cost = J_1+ J_2\\n\\n # Return the gradient for the prediction function\\n # the prediction vector interacts with both the predicted vector\\n # the negative sample vectors so below are both parts of the gradient\\n # here we are trying to increase the prediction matrix to maximize\\n # the similarity with the predicted vector\\n # output is a 1 x D matrix\\n grad_pred_o = - (1 - h_o)*u_o\\n\\n # the second part is tyring to decrease\\n # similarity with the negative sample vectors\\n # K x 1 multiply be input is a k x D matrix, we will need to sum all negative samples\\n # along the rows. output is a 1 x D matrix\\n # reshape h_k so that it can multiple\\n grad_pred_k = np.dot(( 1 - h_k).T, u_k)\\n # find the predicted matrix gradient\\n # output is a 1 x D matrix\\n gradPred = grad_pred_o + grad_pred_k\\n\\n\\n # Return the gradient of the output vector\\n # create a matrix the same shape as outputVector\\n grad = np.zeros(outputVectors.shape)\\n # first find the gradient wrt to the target output vector\\n # here we want to increase the similarity between\\n # the target output vector and the center vector\\n # outputs is a 1 x D matrix\\n grad_u_o = - (1-h_o)*v_c\\n\\n # print('***************grad_u_o************')\\n # print(grad_u_o)\\n # print(grad_u_o.shape)\\n # replace the target row in output vector gradient\\n grad[target, ] = grad_u_o\\n # then find the gradient descent of all the u_k matrices\\n # K x 1 matrix multiply by 1 x 3\\n # K x D\\n grad_uk = - np.outer((h_k - 1), v_c)\\n # print('***************grad_uk************')\\n # print(grad_uk)\\n # for each token (row) replace gradient\\n for k in xrange(u_k.shape[0]):\\n index = indices[k]\\n grad[index] += grad_uk[k]\\n\\n ### END YOUR CODE\\n return cost, gradPred, grad\",\n \"def neural_net_ex4_ng():\\n # ==================\\n # read data\\n dataset = loadmat('data/ex4data1.mat')\\n print(dataset.keys())\\n\\n y = dataset['y'] # 5000 x 1\\n print('dims y: ', y.shape)\\n # print('y[0]: ', y[0])\\n\\n X = dataset['X'] # 5000 x 400\\n print('dims X: ', X.shape)\\n # print('X[0]: ', X[0])\\n\\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)\\n\\n num_samples_test = X_test.shape[0]\\n\\n # ==================\\n # display data\\n\\n # pick 20 examples and visualize them\\n fig = plt.figure(figsize=(10, 8), facecolor='white')\\n fig.add_subplot(651)\\n samples = np.random.choice(num_samples_test, 10)\\n print('samples:', samples)\\n plt.imshow(X_test[samples, :].reshape(-1, 20).T, cmap=\\\"Greys\\\")\\n plt.axis('off')\\n\\n # ==================\\n # run neural net\\n hidden_layer_size = 25\\n\\n mlp = MLPClassifier(hidden_layer_sizes=(25,), max_iter=20, alpha=1e-4,\\n solver='sgd', verbose=False, tol=1e-4, random_state=1,\\n learning_rate_init=.1)\\n mlp.fit(X_train, y_train.ravel())\\n\\n predictions = mlp.predict(X_test)\\n print('Test set accuracy: {} %'.format(np.mean(predictions == y_test.ravel())*100))\\n\\n # print(confusion_matrix(y_test, predictions))\\n # print(classification_report(y_test, predictions))\\n print(\\\"Training set score: %f\\\" % mlp.score(X_train, y_train))\\n print(\\\"Test set score: %f\\\" % mlp.score(X_test, y_test))\\n print('coeffs shape', (mlp.coefs_[0]).shape)\\n\\n # ==================\\n # display coefficients of hidden layer\\n fig.add_subplot(652)\\n plt.imshow(mlp.coefs_[0][:, 0].reshape(20, 20))\\n plt.axis('off')\\n\\n gs = gridspec.GridSpec(6, 5)\\n cur_img_idx = 5\\n\\n # use global min / max to ensure all weights are shown on the same scale\\n vmin, vmax = mlp.coefs_[0].min(), mlp.coefs_[0].max()\\n for coef, ax in zip(mlp.coefs_[0].T, range(hidden_layer_size)):\\n fig.add_subplot(gs[cur_img_idx])\\n plt.imshow(coef.reshape(20, 20), cmap=plt.cm.gray, vmin=.5 * vmin, vmax=.5 * vmax)\\n plt.axis('off')\\n cur_img_idx += 1\\n\\n plt.show()\",\n \"def __init__(self, input_nodes, hidden_nodes, hidden_layers, output_nodes):\\n # Class members:\\n # num_input_nodes\\n # num_hidden_nodes\\n # num_hidden_layers\\n # num_output_nodes\\n # weights = [[num_hidden_nodes, num_input_nodes],[num_hidden_nodes, num_hidden_nodes],[]<- for each hl,\\n # [num_output_nodes, num_hidden_nodes]]\\n # biases\\n\\n self.num_input_nodes = input_nodes\\n self.num_hidden_nodes = hidden_nodes\\n self.num_hidden_layers = hidden_layers\\n self.num_output_nodes = output_nodes\\n\\n self.weights = []\\n for i in range(self.num_hidden_layers + 1):\\n if i is 0:\\n # first weights array is input to hidden\\n self.weights.append(.5 * np.random.rand(self.num_hidden_nodes, self.num_input_nodes) - .25)\\n\\n elif i < self.num_hidden_layers:\\n # next weight array is hidden nodes to hidden nodes\\n self.weights.append(.5 * np.random.rand(self.num_hidden_nodes, self.num_hidden_nodes) - .25)\\n else:\\n # last weight array is hidden nodes to output nodes\\n self.weights.append(.5 * np.random.rand(self.num_output_nodes, self.num_hidden_nodes) - .25)\\n\\n self.biases = []\\n for i in range(self.num_hidden_layers + 1):\\n if i < self.num_hidden_layers:\\n # for every hidden node there is a bias\\n self.biases.append(0.5 * np.random.rand(self.num_hidden_nodes) - .25)\\n else:\\n # for the output node there is a bias as well\\n self.biases.append(0.5 * np.random.rand(self.num_output_nodes) - .25)\\n\\n self.activation = np.vectorize(self.tanh, otypes=[float])\",\n \"def optimize(self):\\n self.output = self.net.forward(Variable(self.source))\\n self.optimizer.zero_grad()\\n self.loss = self.loss_function(self.output, Variable(self.target))\\n self.loss.backward()\\n self.optimizer.step()\",\n \"def neural_network(X, Y, X_test, Y_test, num_neurons, activation):\\n \\n X_n = (X - np.mean(X, axis = 0)) / np.std(X, axis = 0)\\n Y_n = (Y - np.mean(Y, axis = 0)) / np.std(Y, axis = 0)\\n \\n if activation == \\\"ReLU\\\":\\n activation = ReLUActivation\\n elif activation == \\\"tanh\\\":\\n activation = TanhActivation\\n else:\\n print('Null activation')\\n \\n model = Model(X_n.shape[1])\\n model.addLayer(DenseLayer(num_neurons, activation()))\\n model.addLayer(DenseLayer(num_neurons, activation()))\\n model.addLayer(DenseLayer(Y.shape[1],LinearActivation()))\\n model.initialize(QuadraticCost())\\n\\n Y_pred = model.predict((X_test - np.mean(X, axis = 0)) / np.std(X, axis = 0)) \\n Y_pred = Y_pred * np.std(Y, axis = 0) + np.mean(Y, axis = 0)\\n mse = np.mean(np.sqrt(np.sum((Y_pred - Y_test) ** 2, axis = 1))) \\n\\n return mse\",\n \"def runNN(selectables_interests=[[0.0, 0.1, 0.6, 0.7], [0.0, 0.5, 0.6, 1]], profile_interests = [0.0, 0.1, 0.2, 0.3]):\\n #Intialise a single neuron neural network.\\n # Apply vertical normalisation for the pageobject interests\\n if len(selectables_interests)>0:\\n selectables_interests = normalize(selectables_interests, axis=0, norm='l1')\\n else:\\n # If there is nothing to compare it to, return the current profile.\\n return profile_interests\\n # For the given size of the first element in the array (number of interests) add a dimension of such size\\n Interest_Array_Inputs = [[] for i in range(len(selectables_interests[0]))]\\n Interest_Array_Outputs = [[] for i in range(len(selectables_interests[0]))]\\n # Creating instances of 3 dimensional Inputs/Outputs sets\\n for ida, ll in enumerate(selectables_interests):\\n # For the number of permutations\\n current_fuzzy_element_permutation = fuzzy_permutation(ll)\\n for index in range(len(current_fuzzy_element_permutation[0])):\\n # Insert array inside column Interest for the input, output.\\n Interest_Array_Inputs[current_fuzzy_element_permutation[0][index][0]].append(current_fuzzy_element_permutation[0][index][1][:])\\n Interest_Array_Outputs[current_fuzzy_element_permutation[1][index][0]].append([current_fuzzy_element_permutation[1][index][1]])\\n profile_Interest_Inputs = []\\n # Creating the list of inputs (Leaving out an interest to be predicted)\\n for index, inputList in enumerate(fuzzy_permutation(profile_interests)[0]):\\n profile_Interest_Inputs.append(inputList[1])\\n\\n collected_interests = []\\n # Training on each individual interest\\n for i in range(len(profile_interests)):\\n collected_interests.append(initialise_train_result(Interest_Array_Inputs[i], Interest_Array_Outputs[i], profile_Interest_Inputs[i]))\\n well_ordered_interests = collected_interests[::-1]\\n # Returns the outcoming interests.\\n return well_ordered_interests\",\n \"def nnCostFunction2(nn_params, input_layer_size, hidden_layer_size, num_labels, X, y, lambda_):\\n # Reshape nn_params back into the parameters Theta1 and Theta2, the weight matrices\\n # for our 2 layer neural network\\n Theta1 = nn_params[:hidden_layer_size * (input_layer_size + 1)].reshape(\\n (hidden_layer_size, input_layer_size + 1))\\n Theta2 = nn_params[hidden_layer_size *\\n (input_layer_size + 1):].reshape((num_labels, hidden_layer_size + 1))\\n\\n # Setup some useful variables\\n m = X.shape[0]\\n\\n # Add ones to the X data matrix\\n X = np.insert(X, 0, 1, axis=1)\\n\\n # Perform forward propagation for layer 2\\n z2 = np.matmul(X, Theta1.transpose())\\n a2 = sigmoid(z2)\\n a2 = np.insert(a2, 0, 1, axis=1)\\n z3 = np.matmul(a2, Theta2.transpose())\\n a3 = sigmoid(z3)\\n\\n # turn Y into a matrix with a new column for each category and marked with 1\\n y_one_hot = np.zeros_like(a3)\\n for i in range(m):\\n y_one_hot[i, y[i] - 1] = 1\\n\\n # Calculate the cost of our forward prop\\n ones = np.ones_like(a3)\\n A = np.matmul(y_one_hot.transpose(), np.log(a3)) + \\\\\\n np.matmul((ones - y_one_hot).transpose(), np.log(ones - a3))\\n J = -1 / m * A.trace()\\n J += lambda_ / (2 * m) * \\\\\\n (np.sum(Theta1[:, 1:] ** 2) + np.sum(Theta2[:, 1:] ** 2))\\n\\n # Perform backward propagation to calculate deltas & gradients\\n delta3 = a3 - y_one_hot\\n delta2 = np.matmul(delta3, Theta2[:, 1:]) * sigmoidGradient(z2)\\n Theta2_grad = np.matmul(a2.transpose(), delta3).transpose()\\n Theta1_grad = np.matmul(X.transpose(), delta2).transpose()\\n\\n Theta1_grad[:, 1:] += lambda_ * Theta1[:, 1:]\\n Theta2_grad[:, 1:] += lambda_ * Theta2[:, 1:]\\n Theta1_grad /= m\\n Theta2_grad /= m\\n grad = np.concatenate([Theta1_grad.reshape(-1), Theta2_grad.reshape(-1)])\\n return J, grad\",\n \"def optimize(self):\\n\\n self.logger.info(\\\"Solving with Dynamic Slope Scaling Procedure in Julia :\\\")\\n optimization_start = time.time()\\n\\n # 1. Preprocess for old network graph\\n if self.old_network_graph is not None:\\n\\n # DSSP on old network\\n old_network_obj = sum(list(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).values()))-1e-5\\n try:\\n self.check_infeasibility(self.old_network_graph, old_network_obj)\\n except DHCOptimizerException as e:\\n e.data = \\\"Invalid existing network: \\\" + e.data\\n raise e\\n\\n flows, obj_val = self.optimize_with_dssp_julia(self.old_network_graph, old_network_obj, set())\\n self.logger.info(\\\"Optimization phase time: %.2fs\\\" % (time.time() - optimization_start))\\n solution_old_graph = self.build_solution_graph(self.old_network_graph, flows)\\n\\n if self.modify_old_network:\\n\\n # Add max capacity on old edges\\n self.old_capacity = deepcopy(flows)\\n old_buildings = list(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).values())\\n for key in flows:\\n if (key[1],key[0],0) not in self.old_capacity and key[1] not in old_buildings:\\n self.old_capacity[(key[1],key[0],0)] = self.old_capacity[key]\\n\\n # Add Imaginary edges\\n for edge in self.old_capacity:\\n if self.optimization_graph.has_edge(*edge):\\n\\n # add nodes\\n if not self.optimization_graph.has_node(config.IM_PREFIX+edge[0]):\\n self.optimization_graph.add_node(config.IM_PREFIX+edge[0])\\n self.optimization_graph.nodes[config.IM_PREFIX+edge[0]][config.GPD_GEO_KEY] = \\\\\\n self.optimization_graph.nodes[edge[0]][config.GPD_GEO_KEY]\\n if not self.optimization_graph.has_node(config.IM_PREFIX+edge[1]):\\n self.optimization_graph.add_node(config.IM_PREFIX+edge[1])\\n self.optimization_graph.nodes[config.IM_PREFIX+edge[1]][config.GPD_GEO_KEY] = \\\\\\n self.optimization_graph.nodes[edge[1]][config.GPD_GEO_KEY]\\n # add edges\\n if not self.optimization_graph.has_edge(edge[0],config.IM_PREFIX+edge[0]):\\n self.optimization_graph.add_edge(edge[0],config.IM_PREFIX+edge[0])\\n if not self.optimization_graph.has_edge(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1]):\\n self.optimization_graph.add_edge(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1])\\n if not self.optimization_graph.has_edge(config.IM_PREFIX+edge[1],edge[1]):\\n self.optimization_graph.add_edge(config.IM_PREFIX+edge[1],edge[1])\\n\\n # put cost\\n self.optimization_graph.edges[(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1],0)][config.EDGE_COST_KEY] = \\\\\\n self.optimization_graph.edges[(edge[0],edge[1],0)][config.EDGE_COST_KEY]\\n self.optimization_graph.edges[(edge[0],edge[1],0)][config.EDGE_COST_KEY] = 1e-5\\n self.optimization_graph.edges[(edge[0],config.IM_PREFIX+edge[0],0)][config.EDGE_COST_KEY] = 1e-5\\n self.optimization_graph.edges[(config.IM_PREFIX+edge[1],edge[1],0)][config.EDGE_COST_KEY] = 1e-5\\n\\n else:\\n # if we don't modify the old network, we have to change the capacity of the supplies\\n already_consummed = {}\\n for edge in solution_old_graph.edges():\\n if solution_old_graph.nodes[edge[0]].get(config.NODE_TYPE_KEY) == config.SUPPLY_NODE_TYPE:\\n already_consummed[edge[0]] = already_consummed.get(edge[0], 0) + \\\\\\n solution_old_graph.edges[edge][config.SOLUTION_POWER_FLOW_KEY]\\n for source in already_consummed:\\n if already_consummed[source] <= self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY]:\\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] -= already_consummed[source]\\n self.network_objective -= already_consummed[source]\\n else:\\n self.network_objective -= self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY]\\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] = 0\\n\\n # Remove edges from old network\\n edges_to_remove = set()\\n for e in self.optimization_graph.edges():\\n if self.old_network_graph.has_edge(*e) or self.old_network_graph.has_edge(e[1],e[0]):\\n edges_to_remove.add(e)\\n self.optimization_graph.remove_edges_from(edges_to_remove)\\n\\n # Remove isolated buildings of optimization graph\\n isolated_to_remove = set()\\n for e in self.old_network_graph.edges():\\n if e[0] in self.old_network_graph.nodes() and \\\\\\n self.optimization_graph.nodes[e[1]].get(config.NODE_TYPE_KEY) == config.BUILDING_NODE_TYPE:\\n isolated_to_remove.add(e)\\n self.optimization_graph.remove_edges_from(isolated_to_remove)\\n\\n # Remove buildings from old network\\n for n, data in self.old_network_graph.nodes(data=True):\\n if data.get(config.NODE_TYPE_KEY) == config.BUILDING_NODE_TYPE:\\n self.optimization_graph.remove_node(n)\\n\\n # Re-link sources\\n sources = set()\\n for n, data in self.optimization_graph.nodes(data=True):\\n if data.get(config.NODE_TYPE_KEY) == config.SUPPLY_NODE_TYPE:\\n sources.add(n)\\n source_graph = self.optimization_graph.subgraph(sources).copy()\\n self.optimization_graph.remove_nodes_from(sources)\\n gnx.remove_isolates(self.optimization_graph)\\n node_filter = lambda n: self.optimization_graph.nodes.get(n,{}).get(config.NODE_TYPE_KEY) != config.BUILDING_NODE_TYPE\\n gnx.spatial_points_merge(self.optimization_graph, source_graph.nodes_to_gdf(), node_filter=node_filter, inplace=True)\\n\\n # fill missing information\\n gnx.fill_edges_missing_geometry_attributes(self.optimization_graph)\\n gnx.fill_length_attribute(self.optimization_graph, config.EDGE_LENGTH_KEY, only_missing=True)\\n gnx.fill_length_attribute(self.optimization_graph, config.EDGE_COST_KEY, only_missing=True)\\n for e in self.optimization_graph.edges(keys=True):\\n self.optimization_graph.edges[e][config.LEASTCOST_COEF_KEY] = \\\\\\n self.optimization_graph.edges[e].get(config.LEASTCOST_COEF_KEY,0)\\n\\n\\n\\n # 2. Process the DSSP on optimization graph\\n self.check_is_ready()\\n self.check_infeasibility(self.optimization_graph, self.network_objective)\\n\\n if self.old_network_graph is not None and self.modify_old_network:\\n old_buildings = set(nx.get_node_attributes(self.old_network_graph, config.BUILDING_CONSUMPTION_KEY).keys())\\n else:\\n old_buildings = set()\\n flows, obj_val = self.optimize_with_dssp_julia(self.optimization_graph, self.network_objective, old_buildings,postprocess= (not self.modify_old_network))\\n self.logger.info(\\\"Optimization phase time: %.2fs\\\" % (time.time() - optimization_start))\\n self.solution_graph = self.build_solution_graph(self.optimization_graph, flows, self.connected)\\n\\n # 3. Postprocess for old network graph\\n if self.old_network_graph is not None:\\n \\n if self.modify_old_network:\\n # Put the right supply capacity and cost\\n for edge in self.old_capacity:\\n if self.solution_graph.has_edge(edge[0],edge[1]):\\n self.solution_graph.edges[(edge[0],edge[1])][config.EDGE_COST_KEY] = \\\\\\n self.optimization_graph.edges[(config.IM_PREFIX+edge[0],config.IM_PREFIX+edge[1],0)][config.EDGE_COST_KEY]\\n \\n # Remove imaginary edges\\n imaginary_nodes_to_remove = set()\\n nodes_to_relabel = {}\\n for edge in self.solution_graph.edges():\\n if str(edge[0]).startswith(config.IM_PREFIX) and str(edge[1]).startswith(config.IM_PREFIX):\\n real_edge = edge[0][len(config.IM_PREFIX):],edge[1][len(config.IM_PREFIX):]\\n self.old_capacity[(real_edge[0], real_edge[1], 0)] = pd.np.inf\\n self.old_capacity[(real_edge[1], real_edge[0], 0)] = pd.np.inf\\n if not self.solution_graph.has_edge(*real_edge):\\n for i in range(2):\\n nodes_to_relabel[edge[i]] = real_edge[i]\\n else:\\n self.solution_graph.edges[real_edge[0],real_edge[1]][config.SOLUTION_POWER_FLOW_KEY] += \\\\\\n self.solution_graph.edges[edge].get(config.SOLUTION_POWER_FLOW_KEY,0)\\n imaginary_nodes_to_remove.add(edge[0])\\n imaginary_nodes_to_remove.add(edge[1])\\n elif str(edge[0]).startswith(config.IM_PREFIX):\\n imaginary_nodes_to_remove.add(edge[0])\\n elif str(edge[1]).startswith(config.IM_PREFIX):\\n imaginary_nodes_to_remove.add(edge[1])\\n\\n nx.relabel_nodes(self.solution_graph, nodes_to_relabel, copy=False)\\n self.solution_graph.remove_nodes_from(list(imaginary_nodes_to_remove))\\n for node in nodes_to_relabel.values():\\n if self.solution_graph.has_edge(node, node):\\n self.solution_graph.remove_edge(node, node)\\n\\n else:\\n for source in nx.get_node_attributes(self.solution_graph, config.SUPPLY_POWER_CAPACITY_KEY):\\n self.solution_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] += already_consummed.get(source,0)\\n self.optimization_graph.nodes[source][config.SUPPLY_POWER_CAPACITY_KEY] += already_consummed.get(source,0)\\n\\n return flows, obj_val\",\n \"def negSamplingCostAndGradient(predicted, target, outputVectors, dataset,\\n K=10):\\n\\n # Sampling of indices is done for you. Do not modify this if you\\n # wish to match the autograder and receive points!\\n indices = [target]\\n indices.extend(getNegativeSamples(target, dataset, K))\\n\\n ### YOUR CODE HERE\\n #The cost now is maximize the predicted and target pair,\\n #minimizing the predicted and the sampled pairs\\n cost = 0\\n gradPred = np.zeros(predicted.shape[0])\\n grad = np.zeros(outputVectors.shape)\\n\\n for indice in indices:\\n target_vector = outputVectors[indice]\\n vector_product = np.dot(target_vector,predicted)\\n if indice != target:\\n cost += -np.log(sigmoid(-vector_product))\\n gradPred += sigmoid(vector_product)*target_vector\\n # use += in case of repeatance\\n grad[indice,:] += sigmoid(vector_product)*predicted\\n else:\\n cost += -np.log(sigmoid(vector_product))\\n gradPred += (sigmoid(vector_product) - 1)*target_vector\\n grad[indice,:] += (sigmoid(vector_product)-1)*predicted\\n ### END YOUR CODE\\n #print indices\\n\\n return cost, gradPred, grad\",\n \"def sim_average_cost(self, dictionary):\\n\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\tprint \\\"Running: sim_average_cost\\\"\\n\\t\\tf = open(toggles.OUTPUT_PATH + toggles.RUN_NAME + '_estimated_costs.csv', 'a')\\n\\n\\t\\tfor p in toggles.CHOSEN_PREDS:\\n\\t\\t\\tpred_cost = 0.0\\n\\t\\t\\tpred = Predicate.objects.all().get(pk=p+1)\\n\\t\\t\\tf.write(pred.question.question_text + '\\\\n')\\n\\n\\t\\t\\t#iterate through to find each ip cost\\n\\t\\t\\tfor ip in IP_Pair.objects.filter(predicate=pred):\\n\\t\\t\\t\\titem_cost = 0.0\\n\\t\\t\\t\\t# sample toggles.COST_SAMPLES times\\n\\t\\t\\t\\tfor x in range(toggles.COST_SAMPLES):\\n\\t\\t\\t\\t\\t# running one sampling\\n\\t\\t\\t\\t\\twhile ip.status_votes < toggles.NUM_CERTAIN_VOTES:\\n\\t\\t\\t\\t\\t\\t# get the vote\\n\\t\\t\\t\\t\\t\\tvalue = choice(dictionary[ip])\\n\\t\\t\\t\\t\\t\\tif value == True:\\n\\t\\t\\t\\t\\t\\t\\tip.value += 1\\n\\t\\t\\t\\t\\t\\t\\tip.num_yes += 1\\n\\t\\t\\t\\t\\t\\telif value == False:\\n\\t\\t\\t\\t\\t\\t\\tip.value -= 1\\n\\t\\t\\t\\t\\t\\t\\tip.num_no +=1\\n\\n\\t\\t\\t\\t\\t\\tip.status_votes += 1\\n\\n\\t\\t\\t\\t\\t\\t# check if ip is done\\n\\t\\t\\t\\t\\t\\tif ip.status_votes == toggles.NUM_CERTAIN_VOTES:\\n\\t\\t\\t\\t\\t\\t\\t\\tif ip.value > 0:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tuncertaintyLevel = btdtr(ip.num_yes+1, ip.num_no+1, toggles.DECISION_THRESHOLD)\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tuncertaintyLevel = btdtr(ip.num_no+1, ip.num_yes+1, toggles.DECISION_THRESHOLD)\\n\\t\\t\\t\\t\\t\\t\\t\\tif uncertaintyLevel < toggles.UNCERTAINTY_THRESHOLD:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\titem_cost += (ip.num_yes + ip.num_no)\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tip.status_votes -= 2\\n\\n\\t\\t\\t\\t\\t# reset values\\n\\t\\t\\t\\t\\tip.value = 0\\n\\t\\t\\t\\t\\tip.num_yes = 0\\n\\t\\t\\t\\t\\tip.num_no = 0\\n\\t\\t\\t\\t\\tip.status_votes = 0\\n\\n\\t\\t\\t\\titem_cost = item_cost/float(toggles.COST_SAMPLES)\\n\\t\\t\\t\\tpred_cost += item_cost\\n\\t\\t\\t\\tf.write(ip.item.name + ': ' + str(item_cost) + \\\" \\\")\\n\\n\\t\\t\\tpred_cost = float(pred_cost)/IP_Pair.objects.filter(predicate=pred).count()\\n\\t\\t\\tf.write('\\\\npredicate average cost: ' + str(pred_cost) + '\\\\n \\\\n')\\n\\t\\tf.close()\\n\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\tprint \\\"Wrote File: \\\" + toggles.OUTPUT_PATH + toggles.RUN_NAME + '_estimated_costs.csv'\",\n \"def build_and_display_network():\\n bpn = NeuralNetwork.BackPropagationNetwork((input_nodes, hidden_nodes, output_nodes),[None, sigmoid, linear])\\n DisplayNetwork.displayLayers(bpn.matrixDimension)\\n\\n return bpn\",\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 neural_network(z, dim_out):\\n hidden_dim = 15\\n net1 = slim.fully_connected(z, hidden_dim, activation_fn=None)\\n net2 = slim.fully_connected(net1, dim_out, activation_fn=tf.tanh)\\n return net2\",\n \"def model(training_images, training_labels, validation_images, validation_labels, iteration_count, learning_rate, show_cost):\\n\\n\\t# init weight and bias arrays\\n\\tw, b = init_zero(training_images.shape[0]) \\n\\n\\t# train model and obtain weight and bias \\n\\tparameters, gradients, costs = gradient_descent(w=w, b=b, image_matrix=training_images, true_labels=training_labels,\\n\\t iteration_count=iteration_count, learning_rate=learning_rate, show_cost=show_cost)\\n\\n\\tw = parameters[\\\"w\\\"]\\n\\tb = parameters[\\\"b\\\"]\\n\\n\\tprediction_training_labels = predict(w, b, training_images)\\n\\tprediction_validation_labels = predict(w, b, validation_images)\\n\\n\\t# Calculates the average proximity of each prediction to the true (normalized)\\n\\ttraining_accuracy = (1 - np.mean(np.abs(prediction_training_labels - training_labels)))\\n\\tvalidation_accuracy = (1 - np.mean(np.abs(prediction_validation_labels - validation_labels)))\\n\\n\\tprint(\\\"training accuracy: %s\\\" % str(training_accuracy))\\n\\tprint(\\\"validation accuracy: %s\\\" % str(validation_accuracy))\\n\\n\\tdata = {\\n\\t\\\"costs\\\": costs,\\n\\t\\\"prediction_training_labels\\\": prediction_training_labels,\\n\\t\\\"prediction_validation_labels\\\": prediction_validation_labels,\\n\\t\\\"original_training_labels\\\": training_class_set,\\n\\t\\\"original_validation_labels\\\": validation_class_set,\\n\\t\\\"w\\\": w,\\n\\t\\\"b\\\": b,\\n\\t\\\"learning_rate\\\": learning_rate,\\n\\t\\\"interation_count\\\": iteration_count\\n\\t}\\n\\n\\treturn data\",\n \"def model(X_train, Y_train, X_dev, Y_dev, numOutputNodes, learning_rate = 0.003,\\n iterations = 2000, minibatch_size = 16, layer1 = 25, beta = 0, dropout = 1.0, istanh1 = False, batchnorm = True, print_cost = True, is_charge = False):\\n \\n # reset all variables to allow the network to be trained multiple times with different hyperparameters\\n sess = tf.Session()\\n tf.reset_default_graph()\\n\\n tf.set_random_seed(1) # to keep consistent results\\n seed = 1 # to keep consistent results\\n (n_x, m) = X_train.shape # n_x : input size (the other dimension is the number of examples in the train set)\\n n_y = Y_train.shape[0] # n_y : output size\\n costs = [] # holds data for graphing\\n dev_costs = []\\n \\n # Create Placeholders of shape (n_x, n_y)\\n X, Y = create_placeholders(n_x, n_y)\\n parameters = initialize_parameters(layer1, 1, regression = True) # Initialize parameters, with one hidden layer\\n training = tf.placeholder_with_default(False, shape=(), name='training') # Create a boolean to use for implementing batch norm and dropout correctly\\n\\n # Forward propagation: Build the forward propagation in the tensorflow graph\\n Z3 = forward_propagation(X, parameters, training, istanh1, False, batchnorm, dropout, regression = True)\\n\\n # Cost function: Add cost function to tensorflow graph\\n cost = compute_reg_cost(Z3, Y, parameters, beta)\\n\\n update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) # allows for prediction at test time to work with batch normalization; allows for updating of global mean and variance\\n with tf.control_dependencies(update_ops):\\n # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer.\\n optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)\\n\\n # Initialize all the variables\\n init = tf.global_variables_initializer()\\n saver = tf.train.Saver()\\n\\n # Calculate the correct predictions\\n correct_prediction = tf.less_equal(tf.abs(tf.divide(tf.subtract(Z3, Y), Y)), tf.fill([1,1], 0.05)) \\n # define one measure of accuracy by counting a prediction as correct if it's within 5% of the true value\\n \\n # Calculate the mean absolute percentage error of the predictions\\n MAPE = tf.scalar_mul(100, tf.reduce_mean(tf.abs(tf.divide(tf.subtract(Z3, Y), Y))))\\n\\n # Calculate accuracy on the test set\\n accuracy = tf.reduce_mean(tf.cast(correct_prediction, \\\"float\\\"))\\n\\n # Start the session to compute the tensorflow graph\\n with tf.Session() as sess:\\n sess.run(init)\\n\\n # Print the hyperparameters for this particular model\\n print('Learning Rate: %s, Mini-Batch Size: %d, Beta: %s, %d Nodes in Hidden Layer, %d Output Nodes, %d Iterations, %s Dropout Prob, Hidden Layer Tanh: %s, Batch Norm: %s' \\\\\\n % (str(learning_rate).rstrip('0'), minibatch_size, str(beta).rstrip('0'), layer1, numOutputNodes, iterations, str(dropout).rstrip('0'), istanh1, batchnorm))\\n \\n for epoch in range(iterations):\\n epoch_cost = 0. # Defines a cost related to an epoch\\n seed = seed + 1\\n minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)\\n num_minibatches = len(minibatches) \\n\\n for minibatch in minibatches:\\n # Select a minibatch\\n (minibatch_X, minibatch_Y) = minibatch\\n \\n # Run the session on one minibatch, and add the cost to the epoch cost\\n _ , minibatch_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y, training: True})\\n epoch_cost += minibatch_cost / num_minibatches\\n \\n # save the training and cross-validation cost every 5 epochs\\n if print_cost == True and epoch % 5 == 0:\\n costs.append(epoch_cost)\\n dev_cost = sess.run(cost, feed_dict = {X: X_dev, Y: Y_dev, training: False})\\n dev_costs.append(dev_cost)\\n\\n # print the cost after every 200 epochs\\n if print_cost == True and epoch % 200 == 0: # used during testing to ensure gradient descent is working properly\\n train_accuracy = accuracy.eval({X: X_train, Y: Y_train, training: False})\\n train_mape = MAPE.eval({X: X_train, Y: Y_train, training: False})\\n print(\\\"Training cost after iteration %i: %f, accuracy: %f, MAPE: %f %%\\\" % (epoch, epoch_cost, train_accuracy, train_mape))\\n \\n dev_cost = sess.run(cost, feed_dict={X:X_dev, Y: Y_dev, training: False})\\n dev_accuracy = accuracy.eval({X: X_dev, Y: Y_dev, training: False})\\n dev_mape = MAPE.eval({X: X_dev, Y: Y_dev, training: False})\\n print(\\\"Dev cost after iteration %i: %f, accuracy: %f, MAPE: %f %%\\\" % (epoch, dev_cost, dev_accuracy, dev_mape))\\n\\n # # Plot the cost\\n # if print_cost:\\n # iter_num = np.arange(iterations / 5) * 5\\n # plt.plot(iter_num, np.squeeze(costs), label = 'training')\\n # plt.plot(iter_num, np.squeeze(dev_costs), label = 'cross-validation')\\n # plt.ylabel('cost')\\n # plt.xlabel('iterations')\\n # # plt.ylim(top = 0.01, bottom = 0.002) # y range used to plot for averaged spectra\\n # plt.ylim(top = 0.0075, bottom = 0.001) # y range used to plot for training on charges\\n # plt.title('Cost vs. Iterations')\\n # plt.legend()\\n # plt.show()\\n\\n # Save the parameters in a variable\\n parameters = sess.run(parameters)\\n if is_charge:\\n saver.save(sess, \\\"./charge_reg_models/charge_regression_model_{}_{}_{}_{}.ckpt\\\".format(learning_rate, iterations, layer1, beta))\\n else:\\n saver.save(sess, \\\"./reg_models/regression_model_{}_{}_{}_{}.ckpt\\\".format(learning_rate, iterations, layer1, beta))\\n\\n train_acc = accuracy.eval({X: X_train, Y: Y_train, training: False})\\n dev_acc = accuracy.eval({X: X_dev, Y: Y_dev, training: False})\\n \\n mape_train = MAPE.eval({X: X_train, Y: Y_train, training: False})\\n mape_dev = MAPE.eval({X: X_dev, Y: Y_dev, training: False})\\n\\n accs = [train_acc, dev_acc, mape_train, mape_dev]\\n\\n print(\\\"Train Accuracy:\\\", train_acc, \\\"; MAPE:\\\", mape_train)\\n print(\\\"Dev Accuracy:\\\", dev_acc, \\\"; MAPE:\\\", mape_dev)\\n\\n return accs, parameters\",\n \"def ComputeGradients(self, input_data: list, target_output_data: list):\\n delta = 1e-6\\n normal_cost = self.Cost(input_data, target_output_data)\\n\\n # Evaluate Gradient for Hidden Layer Biases\\n for i in range(self.hidden_layer_biases.shape[0]):\\n original_bias_value = self.hidden_layer_biases[i]\\n self.hidden_layer_biases[i] += delta\\n plusdelta_cost = self.Cost(input_data, target_output_data)\\n self.hidden_layer_biases[i] = original_bias_value\\n self.hidden_biases_gradient[i] = (plusdelta_cost - normal_cost) / delta\\n\\n # Evaluate Gradient for Output Layer Biases\\n for i in range(self.output_layer_biases.shape[0]):\\n original_bias_value = self.output_layer_biases[i]\\n self.output_layer_biases[i] += delta\\n plusdelta_cost = self.Cost(input_data, target_output_data)\\n self.output_layer_biases[i] = original_bias_value\\n self.output_biases_gradient[i] = (plusdelta_cost - normal_cost) / delta\\n\\n # Evaluate Gradient for Input Layer to Hidden Layer Weights\\n for i in range(self.input_to_hidden_weights.shape[0]):\\n for h in range(self.input_to_hidden_weights.shape[1]):\\n original_bias_value = self.input_to_hidden_weights[i, h]\\n self.input_to_hidden_weights[i, h] += delta\\n plusdelta_cost = self.Cost(input_data, target_output_data)\\n self.input_to_hidden_weights[i, h] = original_bias_value\\n self.input_to_hidden_weights_gradient[i, h] = (plusdelta_cost - normal_cost) / delta\\n\\n # Evaluate Gradient for Input Layer to Hidden Layer Weights\\n for h in range(self.hidden_to_output_weights.shape[0]):\\n for o in range(self.hidden_to_output_weights.shape[1]):\\n original_bias_value = self.hidden_to_output_weights[h, o]\\n self.hidden_to_output_weights[h, o] += delta\\n plusdelta_cost = self.Cost(input_data, target_output_data)\\n self.hidden_to_output_weights[h, o] = original_bias_value\\n self.hidden_to_output_weights_gradient[h, o] = (plusdelta_cost - normal_cost) / delta\",\n \"def nn(data):\\n training_set = SupervisedDataSet*\\n\\n\\n input_nodes = 3\\n hidden_layer_1 = 10\\n hidden_layer_2 = 10\\n output_layer = 5\\n\\n net = buildNetwork(input_nodes, hidden_layer_1, hidden_layer_2, output_layer, bias=True, hiddenclass=TanhLayer)\",\n \"def Solve(self, cost, termination=None, ExtraArgs=(), **kwds):\\n # process and activate input settings\\n sigint_callback = kwds.pop('sigint_callback', None)\\n settings = self._process_inputs(kwds)\\n disp = settings['disp'] if 'disp' in settings else False\\n echo = settings['callback'] if 'callback' in settings else None\\n# for key in settings:\\n# exec \\\"%s = settings['%s']\\\" % (key,key)\\n if disp in ['verbose', 'all']: verbose = True\\n else: verbose = False\\n #-------------------------------------------------------------\\n\\n from python_map import python_map\\n if self._map != python_map:\\n #FIXME: EvaluationMonitor fails for MPI, throws error for 'pp'\\n from mystic.monitors import Null\\n evalmon = Null()\\n else: evalmon = self._evalmon\\n fcalls, cost = wrap_function(cost, ExtraArgs, evalmon)\\n\\n # set up signal handler\\n #self._EARLYEXIT = False\\n self._generateHandler(sigint_callback) \\n\\n # activate signal_handler\\n #import threading as thread\\n #mainthread = isinstance(thread.current_thread(), thread._MainThread)\\n #if mainthread: #XXX: if not mainthread, signal will raise ValueError\\n import signal\\n if self._handle_sigint:\\n signal.signal(signal.SIGINT,self.signal_handler)\\n\\n # register termination function\\n if termination is not None: self.SetTermination(termination)\\n\\n # get the nested solver instance\\n solver = self._AbstractEnsembleSolver__get_solver_instance()\\n #-------------------------------------------------------------\\n\\n # generate starting points\\n initial_values = self._InitialPoints()\\n\\n # run optimizer for each grid point\\n from copy import deepcopy as _copy\\n op = [_copy(solver) for i in range(len(initial_values))]\\n #cf = [cost for i in range(len(initial_values))]\\n vb = [verbose for i in range(len(initial_values))]\\n cb = [echo for i in range(len(initial_values))] #XXX: remove?\\n at = self.id if self.id else 0 # start at self.id\\n id = range(at,at+len(initial_values))\\n\\n # generate the local_optimize function\\n def local_optimize(solver, x0, rank=None, disp=False, callback=None):\\n from copy import deepcopy as _copy\\n from mystic.tools import isNull\\n solver.id = rank\\n solver.SetInitialPoints(x0)\\n if solver._useStrictRange: #XXX: always, settable, or sync'd ?\\n solver.SetStrictRanges(min=solver._strictMin, \\\\\\n max=solver._strictMax) # or lower,upper ?\\n solver.Solve(cost, disp=disp, callback=callback)\\n sm = solver._stepmon\\n em = solver._evalmon\\n if isNull(sm): sm = ([],[],[],[])\\n else: sm = (_copy(sm._x),_copy(sm._y),_copy(sm._id),_copy(sm._info))\\n if isNull(em): em = ([],[],[],[])\\n else: em = (_copy(em._x),_copy(em._y),_copy(em._id),_copy(em._info))\\n return solver, sm, em\\n\\n # map:: solver = local_optimize(solver, x0, id, verbose)\\n results = self._map(local_optimize, op, initial_values, id, \\\\\\n vb, cb, **self._mapconfig)\\n\\n # save initial state\\n self._AbstractSolver__save_state()\\n #XXX: HACK TO GET CONTENT OF ALL MONITORS\\n # reconnect monitors; save all solvers\\n from mystic.monitors import Monitor\\n while results: #XXX: option to not save allSolvers? skip this and _copy\\n _solver, _stepmon, _evalmon = results.pop()\\n sm = Monitor()\\n sm._x,sm._y,sm._id,sm._info = _stepmon\\n _solver._stepmon.extend(sm)\\n del sm\\n em = Monitor()\\n em._x,em._y,em._id,em._info = _evalmon\\n _solver._evalmon.extend(em)\\n del em\\n self._allSolvers[len(results)] = _solver\\n del results, _solver, _stepmon, _evalmon\\n #XXX: END HACK\\n\\n # get the results with the lowest energy\\n self._bestSolver = self._allSolvers[0]\\n bestpath = self._bestSolver._stepmon\\n besteval = self._bestSolver._evalmon\\n self._total_evals = self._bestSolver.evaluations\\n for solver in self._allSolvers[1:]:\\n self._total_evals += solver.evaluations # add func evals\\n if solver.bestEnergy < self._bestSolver.bestEnergy:\\n self._bestSolver = solver\\n bestpath = solver._stepmon\\n besteval = solver._evalmon\\n\\n # return results to internals\\n self.population = self._bestSolver.population #XXX: pointer? copy?\\n self.popEnergy = self._bestSolver.popEnergy #XXX: pointer? copy?\\n self.bestSolution = self._bestSolver.bestSolution #XXX: pointer? copy?\\n self.bestEnergy = self._bestSolver.bestEnergy\\n self.trialSolution = self._bestSolver.trialSolution #XXX: pointer? copy?\\n self._fcalls = self._bestSolver._fcalls #XXX: pointer? copy?\\n self._maxiter = self._bestSolver._maxiter\\n self._maxfun = self._bestSolver._maxfun\\n\\n # write 'bests' to monitors #XXX: non-best monitors may be useful too\\n self._stepmon = bestpath #XXX: pointer? copy?\\n self._evalmon = besteval #XXX: pointer? copy?\\n self.energy_history = None\\n self.solution_history = None\\n #from mystic.tools import isNull\\n #if isNull(bestpath):\\n # self._stepmon = bestpath\\n #else:\\n # for i in range(len(bestpath.y)):\\n # self._stepmon(bestpath.x[i], bestpath.y[i], self.id)\\n # #XXX: could apply callback here, or in exec'd code\\n #if isNull(besteval):\\n # self._evalmon = besteval\\n #else:\\n # for i in range(len(besteval.y)):\\n # self._evalmon(besteval.x[i], besteval.y[i])\\n #-------------------------------------------------------------\\n\\n # restore default handler for signal interrupts\\n if self._handle_sigint:\\n signal.signal(signal.SIGINT,signal.default_int_handler)\\n\\n # log any termination messages\\n msg = self.Terminated(disp=disp, info=True)\\n if msg: self._stepmon.info('STOP(\\\"%s\\\")' % msg)\\n # save final state\\n self._AbstractSolver__save_state(force=True)\\n return\",\n \"def main():\\n inputs = tf.placeholder(tf.float32, shape=[3, None])\\n targets = tf.placeholder(tf.float32, shape=[1, None])\\n outputs = apply_network(inputs)\\n loss = tf.reduce_mean(tf.square(outputs - targets))\\n\\n opt = tf.train.AdamOptimizer()\\n minimize = opt.minimize(loss)\\n\\n with tf.Session() as sess:\\n sess.run(tf.global_variables_initializer())\\n train_x, train_y = make_data(5000)\\n test_x, test_y = make_data(2000)\\n train_dict = {inputs: train_x, targets: train_y}\\n test_dict = {inputs: test_x, targets: test_y}\\n for i in range(0, 5000):\\n if i % 100 == 0:\\n print('epoch %d: cost=%f val_cost=%f' %\\n (i, sess.run(loss, feed_dict=train_dict),\\n sess.run(loss, feed_dict=test_dict)))\\n sess.run(minimize, feed_dict=train_dict)\",\n \"def explain(self, validation_data, model, class_index, **extra):\\n images, _ = validation_data\\n\\n gradients = self.compute_gradients(images, model, class_index, **extra)\\n\\n grayscale_gradients = transform_to_normalized_grayscale(\\n tf.abs(gradients)\\n ).numpy()\\n\\n grid = grid_display(grayscale_gradients)\\n\\n return grid\",\n \"def main():\\n\\n dataset = ConvMNIST(64)\\n print(dataset.get_train().x.shape)\\n\\n\\n inputs = Value(type=tf.float32, shape=(None, 28, 28, 1), cls = None)\\n targets = Value(type=tf.int64, shape=(None), cls = 10)\\n learning_rate = 0.0001\\n\\n fc_hidden = [1024, 500]\\n c_h = [\\n (3, 3, 1, 32),\\n (3, 3, 32, 64)\\n ]\\n conv_hidden = ConvHidden(conv_weights=c_h, fc_weights=fc_hidden)\\n\\n config = Config(inputs, targets, conv_hidden, learning_rate)\\n\\n network = ConvNetworkBuilder(config)\\n hidden = FFConvHiddenBuilder()\\n _ = network.build_network(hidden)\\n\\n\\n train_config = TrainerConfig(\\n epochs = EPOCHS, display_after = DISPLAY_STEP, \\n keep_prob = KEEP_PROB,checkpoint_path=None, \\n summary_path=None\\n )\\n\\n trainer = Trainer(network, train_config)\\n trainer.train(dataset)\",\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 negSamplingCostAndGradient(predicted, target, outputVectors, dataset,\\n K=10):\\n\\n # Sampling of indices is done for you. Do not modify this if you\\n # wish to match the autograder and receive points!\\n indices = [target]\\n indices.extend(getNegativeSamples(target, dataset, K))\\n\\n ### YOUR CODE HERE\\n grad = np.zeros_like(outputVectors)\\n gradPred = np.zeros_like(predicted)\\n cost = 0.0\\n probability = 0.0\\n for sample_idx in indices:\\n similarity = outputVectors[sample_idx].dot(predicted.T)\\n probability = sigmoid(similarity) # squash to 0 ~ 1\\n if sample_idx == target: # positive sample\\n #p = sigmoid(outputVectors[sample_idx].dot(predicted.T))\\n cost += -np.log(sigmoid(similarity))\\n else: # negative sample\\n #p = sigmoid(-outputVectors[sample_idx].dot(predicted.T))\\n cost += -np.log(sigmoid(-similarity)) # deduction from reference 2.\\n \\n if sample_idx == target:\\n grad[sample_idx, :] += (probability - 1) * predicted\\n gradPred += (probability - 1) * outputVectors[sample_idx]\\n else:\\n grad[sample_idx, :] += probability * predicted\\n gradPred += probability * outputVectors[sample_idx]\\n '''\\n V, D = outputVectors.shape\\n one_hot_target = np.zeros(V)\\n one_hot_target[target] = 1\\n cost = 0\\n gradPred = np.zeros_like(predicted)\\n grad = np.zeros_like(outputVectors)\\n \\n for idx in indices:\\n context_vector = outputVectors[idx] # embedding vector (1, D)\\n cosine_similarity = normalizeRows(predicted).dot(normalizeRows(context_vector).T)\\n print('neg sample, consine_similarity={0}'.format(cosine_similarity))\\n binary_class = sigmoid(cosine_similarity)\\n print('neg sample, binary_class={0}'.format(binary_class))\\n \\n if idx == target:\\n cost += binary_class - 1\\n else:\\n cost += binary_class\\n \\n dlogits = sigmoid_grad(cosine_similarity)\\n #gradPred += dlogits * normalizeRows(context_vector)\\n #grad += np.outer(one_hot_target, dlogits * normalizeRows(predicted))\\n gradPred += dlogits\\n grad += np.outer(one_hot_target, dlogits)\\n '''\\n ### END YOUR CODE\\n\\n return cost, gradPred, grad\",\n \"def run_negative():\\n\\tdef cy1(x, y): return y[:,0] - 2.5 # y < 2.5\\n\\tdef cy2(x, y): return 3 - y[:,0] # y > 3\\n\\tdef cx1(x, y): return -0.3 - x[:,0] # x > -0.3\\n\\tdef cx2(x, y): return x[:,0] - 0.3 # x < 0.3\\n\\n\\tdef addons():\\n\\t\\tdom = np.arange(-0.3, 0.3, 0.05)\\n\\t\\tplt.fill_between(dom, 3.0, plt.ylim()[1], facecolor='#E41A1C', alpha=0.5, zorder=101)\\n\\t\\tplt.fill_between(dom, plt.ylim()[0], 2.5, facecolor='#E41A1C', alpha=0.5, zorder=101)\\n\\n\\tbnn = BNNSVGDRegressor(uid=\\\"bnn-negative-eg\\\", configfile=\\\"configs/bnn-negative-eg.json\\\")\\n\\tbnn.load(**toy1())\\n\\tbnn.add_negative_constraint((-5.0, 5.0), [cy1, cx1, cx2])\\n\\tbnn.add_negative_constraint((-5.0, 5.0), [cy2, cx1, cx2])\\n\\tbnn.infer()\\n\\tbnn.plot_pp(plot_title=\\\"Predictive Posterior Plot\\\", domain=np.arange(-5, 5, 0.05), ylims=(-9, 7), addons=addons)\",\n \"def hidden_layers(self):\\n\\t\\tif self.hidden is None:\\n\\t\\t\\tself.hidden, self.inputs, self.weights_all, self.biases_all = [], [], [], []\\n\\t\\t\\tlast_hidden = self.x\\n\\t\\t\\tif self.covnet == 1:\\n\\t\\t\\t\\ty_conv, self._drouput, self.hidden, self.inputs = deepnn(self.x)\\n\\t\\t\\telif self.covnet == 2:\\n\\t\\t\\t\\ty_c, self.hidden, self.inputs = multi_layer_perceptron(self.x, self.input_size, self.num_of_classes,\\n\\t\\t\\t\\t self.layerSize[0], self.layerSize[1])\\n\\t\\t\\telse:\\n\\n\\t\\t\\t\\tself._drouput = 'dr'\\n\\t\\t\\t\\t# self.hidden.append(self.x)\\n\\t\\t\\t\\tfor i in range(1, len(self.all_layer_sizes)):\\n\\t\\t\\t\\t\\tname_scope = 'hidden' + str(i - 1)\\n\\t\\t\\t\\t\\trow_size, col_size = self.all_layer_sizes[i - 1], self.all_layer_sizes[i]\\n\\t\\t\\t\\t\\tactivation_function = self.activation_function\\n\\t\\t\\t\\t\\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function,\\n\\t\\t\\t\\t\\t last_hidden)\\n\\t\\t\\t\\tname_scope = 'final_layer'\\n\\t\\t\\t\\trow_size, col_size = self.layerSize[-1], self.num_of_classes\\n\\t\\t\\t\\tactivation_function = None\\n\\t\\t\\t\\tlast_hidden = self.initilizae_layer(name_scope, row_size, col_size, activation_function, last_hidden)\\n\\t\\treturn self.hidden\",\n \"def __init__(self, calcGrad, calcCost, input, alpha = 0.01, gamma = 0.1):\\n\\tVisualizer.__init__(self, calcGrad, calcCost, input)\\n\\tself.alpha = alpha\\n\\tself.gamma = gamma\",\n \"def visualize_manipulation_training(flow, epoch, save_dir=None):\\n\\n # Basic figure setup\\n images_x = 3\\n images_y = 3 if isinstance(flow.codec, DCN) else 2\\n fig = Figure(figsize=(18, 10 / images_x * images_y))\\n conf = np.array(flow.fan.performance['confusion'])\\n \\n # Draw the plots\\n ax = fig.add_subplot(images_y, images_x, 1)\\n ax.plot(flow.nip.performance['loss']['training'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['loss']['training'], 0))\\n ax.set_ylabel('{} NIP loss'.format(flow.nip.class_name))\\n ax.set_title('Loss')\\n\\n ax = fig.add_subplot(images_y, images_x, 2)\\n ax.plot(flow.nip.performance['psnr']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['psnr']['validation'], 0))\\n ax.set_ylabel('{} NIP psnr'.format(flow.nip.class_name))\\n ax.set_title('PSNR')\\n ax.set_ylim([30, 50])\\n\\n ax = fig.add_subplot(images_y, images_x, 3)\\n ax.plot(flow.nip.performance['ssim']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.nip.performance['ssim']['validation'], 0))\\n ax.set_ylabel('{} NIP ssim'.format(flow.nip.class_name))\\n ax.set_title('SSIM')\\n ax.set_ylim([0.8, 1])\\n \\n ax = fig.add_subplot(images_y, images_x, 4)\\n ax.plot(flow.fan.performance['loss']['training'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.fan.performance['loss']['training'], 0))\\n ax.set_ylabel('FAN loss')\\n\\n ax = fig.add_subplot(images_y, images_x, 5)\\n ax.plot(flow.fan.performance['accuracy']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.fan.performance['accuracy']['validation'], 0))\\n ax.set_ylabel('FAN accuracy')\\n ax.set_ylim([0, 1])\\n\\n # The confusion matrix\\n ax = fig.add_subplot(images_y, images_x, 6)\\n ax.imshow(conf, vmin=0, vmax=1)\\n\\n ax.set_xticks(range(flow.n_classes))\\n ax.set_xticklabels(flow._forensics_classes, rotation='vertical')\\n ax.set_yticks(range(flow.n_classes))\\n ax.set_yticklabels(flow._forensics_classes)\\n\\n for r in range(flow.n_classes):\\n ax.text(r, r, '{:.2f}'.format(conf[r, r]), horizontalalignment='center', color='b' if conf[r, r] > 0.5 else 'w')\\n\\n ax.set_xlabel('PREDICTED class')\\n ax.set_ylabel('TRUE class')\\n ax.set_title('Accuracy: {:.2f}'.format(np.mean(np.diag(conf))))\\n\\n # If the compression model is a trainable DCN, include it's validation metrics\\n if images_y == 3:\\n ax = fig.add_subplot(images_y, images_x, 7)\\n ax.plot(flow.codec.performance['loss']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['loss']['validation'], 0))\\n ax.set_ylabel('DCN loss')\\n\\n ax = fig.add_subplot(images_y, images_x, 8)\\n ax.plot(flow.codec.performance['ssim']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['ssim']['validation'], 0))\\n ax.set_ylabel('DCN ssim')\\n ax.set_ylim([0.8, 1])\\n\\n ax = fig.add_subplot(images_y, images_x, 9)\\n ax.plot(flow.codec.performance['entropy']['validation'], '.', alpha=0.25)\\n ax.plot(helpers.stats.ma_conv(flow.codec.performance['entropy']['validation'], 0))\\n ax.set_ylabel('DCN entropy')\\n\\n if save_dir is not None:\\n if not os.path.exists(save_dir):\\n os.makedirs(save_dir)\\n fig.savefig('{}/manip_validation_{:05d}.jpg'.format(save_dir, epoch), bbox_inches='tight', dpi=100)\\n del fig\\n\\n else:\\n return fig\",\n \"def nnObjFunction(params, *args):\\n \\n n_input, n_hidden, n_class, training_data, training_label, lambdaval = args\\n \\n w1 = params[0:n_hidden * (n_input + 1)].reshape( (n_hidden, (n_input + 1)))\\n w2 = params[(n_hidden * (n_input + 1)):].reshape((n_class, (n_hidden + 1)))\\n obj_val = 0\\n obj_grad = np.array([])\\n \\n \\n \\n # initialize a gradient vector matrix with w1\\n gradient_matrix_w1 = np.zeros(w1.shape) \\n \\n # initialize a gradient vector matrix with w2\\n gradient_matrix_w2 = np.zeros(w2.shape) \\n \\n #transpose of input matrix\\n input_mat = training_data.transpose() \\n \\n #transpose of label matrix(expected output)\\n label_expected_mat = training_label.transpose() \\n \\n #get number of coulumns in matrix a1 which is equal to the total number of inputs\\n number_of_input_columns = input_mat.shape[1] \\n \\n #Calculate the bias as input from hiddenlayer\\n input_bias = np.tile(1,(1,np.size(input_mat,1)))\\n \\n #adding bias column in matrix\\n input_mat=np.concatenate((input_mat,input_bias), axis=0) \\n \\n # multipy input with the corresponding wieght vector\\n input_hidden_layer = np.dot(w1,input_mat)\\n \\n # output of hidden layer \\n output_hidden_layer = sigmoid(input_hidden_layer) \\n \\n # calculate bias for hidden layer\\n hidden_layer_bias = np.tile(1,(1,np.size(output_hidden_layer,1)))\\n \\n #adding bias column in hidden layer\\n output_hidden_layer = np.concatenate((output_hidden_layer,hidden_layer_bias), axis=0) \\n \\n # multipy output of hidden layer with the corresponding wieght vector\\n input_output_layer = np.dot(w2,output_hidden_layer) \\n \\n # output of output layer\\n output_output_layer = sigmoid(input_output_layer) \\n \\n # Regularization of neural network\\n error_function_mat=label_expected_mat*np.log(output_output_layer)+(1-label_expected_mat)*np.log(1-output_output_layer) \\n obj_val= - np.sum(error_function_mat[:])/number_of_input_columns\\n \\n #ew1=w1**2\\n #ew2=w2**2\\n error_function = ((np.sum(pow(w1[:],2)) + np.sum(pow(w2[:],2)))/(2*number_of_input_columns))*lambdaval\\n obj_val=obj_val+error_function\\n \\n print obj_val\\n # claculate delta for hidden and output layer \\n delta_output_layer = (output_output_layer - label_expected_mat) \\n delta_hidden_layer = np.dot(w2.transpose(), delta_output_layer)*(output_hidden_layer*(1-output_hidden_layer))\\n change_in_W1 = np.dot(delta_hidden_layer , input_mat.transpose())\\n change_in_W2 = np.dot(delta_output_layer , output_hidden_layer.transpose())\\n \\n #remove the bias row\\n change_in_W1 = change_in_W1[:-1,:]\\n \\n \\n #update weight matrix\\n gradient_matrix_w1 = gradient_matrix_w1 + change_in_W1\\n gradient_matrix_w2 = gradient_matrix_w2 + change_in_W2\\n \\n #regularization of updated weight matrix\\n gradient_matrix_w1 = (gradient_matrix_w1 + lambdaval*w1)/number_of_input_columns\\n gradient_matrix_w2 = (gradient_matrix_w2 + lambdaval*w2)/number_of_input_columns\\n obj_grad = np.concatenate((gradient_matrix_w1.flatten(),gradient_matrix_w2.flatten()), axis=0) \\n \\n print obj_grad\\n return (obj_val,obj_grad)\",\n \"def optimize(self,max_iter=100):\\n\\n\\n for itr in range(max_iter):\\n opt_logs = self.opt.minimize(self.tot_neg_elbo,sum([expert.trainable_variables for expert in self.experts],())) \\n print(self.neg_elbo)\",\n \"def optimize(self):\\n self.check_is_ready()\\n self.check_infeasibility()\\n solution_graph, obj_val = self.find_shortest_network_with_ADH((self.old_network_graph is not None))\\n self.solution_graph = gnx.GeoMultiGraph(solution_graph, crs=self.optimization_graph.crs)\",\n \"def plot_cost(self):\\n steps = np.arange(len(self.cost_values))\\n plt.plot(steps, self.cost_values, '-o')\\n plt.xlabel(\\\"Steps\\\")\\n plt.ylabel(\\\"Cost value\\\")\\n plt.title(\\\"Cost value per step using Gradient Descent\\\")\\n plt.show()\",\n \"def train(self, X, Y, num_iterations = 1000, learning_rate = 0.01, print_cost = False, plot_cost = False):\\n costs = []\\n \\n for i in range(num_iterations + 1):\\n grads, cost = self.propagate(X,Y)\\n \\n # Retrieve derivatives from grads\\n dw = grads[\\\"dw\\\"]\\n db = grads[\\\"db\\\"]\\n \\n # Update rule\\n self.weight = self.weight - learning_rate * dw\\n self.bias = self.bias - learning_rate * db\\n \\n # Record the costs\\n if i % 100 == 0:\\n costs.append(cost)\\n \\n # Print the cost every 100 training examples\\n if print_cost and i % 100 == 0:\\n print(f\\\"cost after iteration: {i} is {np.round(cost, 4)}\\\")\\n \\n grads = {\\\"dw\\\": dw,\\n \\\"db\\\": db}\\n\\n if plot_cost:\\n plt.plot(np.arange(len(costs)) * 100, costs)\\n plt.xlabel(\\\"epoch\\\")\\n plt.ylabel(\\\"cost\\\")\\n plt.title(f\\\"Logistic curve fitting loss function (learning rate={learning_rate})\\\")\\n plt.show()\\n \\n return grads, costs\",\n \"def main():\\n # Load and preprocess the data.\\n ((x_train, y_train), (x_test, y_test)) = (\\n preprocess_dataset(x, y) for (x, y) in datasets.mnist.load_data()\\n )\\n (_, n_classes) = y_train.shape\\n\\n # Create and fit the original model.\\n model = create_model(\\n LAYER_SIZES,\\n n_classes,\\n layer_fn=functools.partial(layers.Dense, use_bias=False),\\n layer_kwargs_fn=dense_kwargs,\\n )\\n model.fit(x_train, y_train, batch_size=BATCH_SIZE, epochs=N_EPOCHS)\\n\\n # Evaluate the pruning methods.\\n pruning_methods = [(\\\"weight\\\", prune_weights), (\\\"neuron\\\", prune_neurons)]\\n for (method_name, pruning_fn) in pruning_methods:\\n # Compute the evaluation curves.\\n (accuracy_curve, time_curve) = zip(\\n *[\\n evaluate_fraction(pruning_fn, model, (x_test, y_test), fraction)\\n for fraction in PRUNING_FRACTIONS\\n ]\\n )\\n # Plot them.\\n for (subplot, curve) in [(211, accuracy_curve), (212, time_curve)]:\\n plt.subplot(subplot)\\n plt.plot(PRUNING_FRACTIONS, curve, label=method_name)\\n\\n if method_name == \\\"neuron\\\":\\n # The first evaluated model in neuron pruning is the unpruned\\n # one. Use it as a baseline.\\n (baseline, *_) = curve\\n plt.plot((0, 1), (baseline, baseline), \\\"--\\\", label=\\\"unpruned\\\")\\n\\n # Add some labels to the plots.\\n for (subplot, y_label) in [(211, \\\"accuracy\\\"), (212, \\\"inference time\\\")]:\\n plt.subplot(subplot)\\n plt.xlabel(\\\"pruning fraction\\\")\\n plt.ylabel(y_label)\\n plt.legend()\\n plt.show()\",\n \"def model(X_train, Y_train, X_test, Y_test, test_imgs, learning_rate=.0003,\\n num_epochs=100, minibatch_size=64, print_cost=True):\\n ops.reset_default_graph\\n tf.set_random_seed(1)\\n seed = 3\\n (m, n_H0, n_W0, n_C0) = X_train.shape\\n n_y = Y_train.shape[1]\\n costs = []\\n\\n X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y)\\n\\n parameters = initialize_parameters()\\n\\n Z6 = forward_propogation(X, parameters)\\n\\n cost = compute_cost(Z6, Y)\\n\\n optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)\\n\\n init = tf.global_variables_initializer()\\n\\n with tf.Session() as sess:\\n sess.run(init)\\n for epoch in range(num_epochs):\\n minibatch_cost =0.\\n num_minibatches = int(m/minibatch_size)\\n seed = seed + 1\\n minibatches = random_mini_batches(X_train, Y_train,\\n minibatch_size, seed)\\n\\n print('USING ONLY FIRST MINIBATCH. DELETE AfTER TETING!')\\n\\n #for minibatch in minibatches:\\n minibatch = minibatches[1]\\n (minibatch_X, minibatch_Y) = minibatch\\n _, temp_cost = sess.run([optimizer, cost],\\n feed_dict={X:minibatch_X, Y:minibatch_Y})\\n minibatch_cost += temp_cost / num_minibatches\\n\\n if print_cost == True:\\n print (\\\"Cost after epoch %i: %f\\\" % (epoch, minibatch_cost))\\n if print_cost == True:\\n costs.append(minibatch_cost)\\n\\n\\n # plot the cost\\n plt.plot(np.squeeze(costs))\\n plt.ylabel('cost')\\n plt.xlabel('iterations (per tens)')\\n plt.title(\\\"Learning rate =\\\" + str(learning_rate))\\n plt.show()\\n\\n # Calculate the correct predictions\\n predict_op = tf.argmax(Z6, 1)\\n correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1))\\n\\n # Calculate accuracy on the test set\\n# accuracy = tf.reduce_mean(tf.cast(correct_prediction, \\\"float\\\"))\\n# print(accuracy)\\n# train_accuracy = accuracy.eval({X: X_train, Y: Y_train})\\n# test_accuracy = accuracy.eval({X: X_test, Y: Y_test})\\n# print(\\\"Train Accuracy:\\\", train_accuracy)\\n# print(\\\"Test Accuracy:\\\", test_accuracy)\\n\\n # Predict on REAL test set\\n print('using test set')\\n predicted_lables = np.zeros(test_imgs.shape[0])\\n predicted_lables[0:3999] = predict_op.eval(feed_dict={X: test_imgs[0:3999]})\\n\\n\\n return train_accuracy, test_accuracy, parameters, predicted_lables\",\n \"def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\\n\\n ### YOUR CODE HERE\\n y_hat = softmax(np.dot(outputVectors,predicted))\\n y = np.zeros(outputVectors.shape[0])\\n y[target] = 1.0\\n\\n cost = -np.log(y_hat[target])\\n gradPred = np.dot(outputVectors.T,y_hat - y)\\n grad = np.outer(y_hat - y,predicted)\\n ### END YOUR CODE\\n\\n return cost, gradPred, grad\",\n \"def build_dense_network(data, hidden_layers, **kwargs):\\n # Input layer\\n with tf.variable_scope(\\\"layer_1\\\"): \\n weights = tf.get_variable(\\\"weights\\\", shape = [input_shape[-1] + 1\\n , hidden_layers[0]], initializer = tf.variance_scaling_initializer())\\n\\n output = tf.nn.leaky_relu(tf.matmul(tf.concat([data, tf.ones(dtype = tf.float32\\n , shape = (tf.shape(data)[0], 1))], axis = 1) # concat\\n , weights, name = \\\"multiply\\\") # matmul\\n , α, name = \\\"output\\\") # leaky relu\\n\\n # DROP-OUT after the activation func\\n output = tf.nn.dropout(output, keep_prob=δ, name = \\\"output\\\") \\n\\n # Hidden layers 1 to len(hidden_layers) - 1\\n for i in range(2, len(hidden_layers)-1+2):\\n\\n with tf.variable_scope(f\\\"layer_{i}\\\"):\\n n_nodes = hidden_layers[i-1]\\n\\n weights = tf.get_variable(\\\"weights\\\", shape = [hidden_layers[i-2]+1, hidden_layers[i-1]], initializer = tf.variance_scaling_initializer())\\n output = tf.nn.leaky_relu(tf.matmul(tf.concat([output, tf.ones(dtype = tf.float32, shape = (tf.shape(data)[0], 1))], axis = 1), weights, name = \\\"multiply\\\"), α, name = \\\"output\\\")\\n\\n # DROP-OUT after the activation func\\n output = tf.nn.dropout(output, keep_prob=δ, name = \\\"output\\\") \\n\\n # Output layer\\n with tf.variable_scope(f\\\"layer_{len(hidden_layers)+1}\\\"):\\n\\n weights = tf.get_variable(\\\"weights\\\", shape = (hidden_layers[1]+1, n_summaries), initializer = tf.variance_scaling_initializer())\\n output = tf.identity(tf.matmul(tf.concat([output, tf.ones(dtype = tf.float32, shape = (tf.shape(data)[0], 1))], axis = 1), weights, name = \\\"multiply\\\"), name = \\\"output\\\")\\n # NO DROP-OUT in the last layer\\n\\n\\n return output\",\n \"def get_network(encoded, is_training, scale=1., weight_decay=0.00004):\\n with tf.variable_scope(\\\"Dense\\\"):\\n batch_size = encoded.get_shape()[0].value\\n end_points = {}\\n bn_params = {\\\"is_training\\\": is_training,\\n 'epsilon': 1e-3\\n }\\n pc = tf.reshape(encoded, [batch_size, 1, 1, -1])\\n net = slim.conv2d(pc,\\n # 400,\\n max(int(round(400 * scale)), 32),\\n [1, 1],\\n padding='SAME',\\n stride=1,\\n normalizer_fn=slim.batch_norm,\\n normalizer_params=bn_params,\\n biases_initializer=tf.zeros_initializer(),\\n weights_regularizer=slim.l2_regularizer(weight_decay),\\n scope='fc1',\\n activation_fn=tf.nn.relu6)\\n net = slim.dropout(net, keep_prob=0.8, is_training=is_training, scope='dp1')\\n net = slim.conv2d(net,\\n # 400,\\n max(int(round(400 * scale)), 32),\\n [1, 1],\\n padding='SAME',\\n stride=1,\\n normalizer_fn=slim.batch_norm,\\n normalizer_params=bn_params,\\n biases_initializer=tf.zeros_initializer(),\\n weights_regularizer=slim.l2_regularizer(weight_decay),\\n scope='fc2',\\n activation_fn=tf.nn.relu6)\\n net = slim.dropout(net, keep_prob=0.4, is_training=is_training, scope='dp2')\\n net = slim.conv2d(net,\\n 40, [1, 1],\\n padding='SAME',\\n stride=1,\\n # normalizer_fn=slim.batch_norm,\\n # normalizer_params=bn_params,\\n biases_initializer=tf.zeros_initializer(),\\n weights_regularizer=slim.l2_regularizer(weight_decay),\\n scope='fc3',\\n # activation_fn=tf.nn.relu6,\\n activation_fn=None,\\n )\\n # print(net)\\n net = tf.reshape(net, [batch_size, -1])\\n return net, end_points\",\n \"def visualize(self):\\n\\n self.check_model()\\n show(prepare(self.model, self.vectorized_data, self.vectorizer, mds='tsne'))\",\n \"def model(self, img, label, bias, filters):\\n prediction, z, flat, layers = self.predict(bias, img, filters)\\n\\n loss = self.categorical_crossentropy(prediction, label)\\n\\n # backpropagation\\n dout = prediction - np.asarray(label).reshape((15, 1))\\n dflat, dw8, db8, dw7, db7 = self.dense_layer_backprop(dout, flat, filters[6:8], bias[6:8], z)\\n\\n dconv6 = dflat.reshape(layers[-1].shape)\\n dconv6[layers[-1] <= 0] = 0\\n dconv5, df6, db6 = self.conv_layer_backprop(dconv6, layers[-2], filters[5])\\n dconv5[layers[-2] <= 0] = 0\\n dpool2, df5, db5 = self.conv_layer_backprop(dconv5, layers[-3], filters[4])\\n dconv4 = self.pooling_layer_backprop(dpool2, layers[-4])\\n dconv4[layers[-4] <= 0] = 0\\n dconv3, df4, db4 = self.conv_layer_backprop(dconv4, layers[-5], filters[3])\\n dconv3[layers[-5] <= 0] = 0\\n dpool1, df3, db3 = self.conv_layer_backprop(dconv3, layers[-6], filters[2])\\n dconv2 = self.pooling_layer_backprop(dpool1, layers[-7])\\n dconv2[layers[-7] <= 0] = 0\\n dconv1, df2, db2 = self.conv_layer_backprop(dconv2, layers[-8], filters[1])\\n dconv1[layers[-8] <= 0] = 0\\n dimg, df1, db1 = self.conv_layer_backprop(dconv1, img[0], filters[0])\\n\\n weight_gradients = [df1, df2, df3, df4, df5, df6, dw7, dw8]\\n bias_gradients = [db1, db2, db3, db4, db5, db6, db7, db8]\\n\\n return weight_gradients, bias_gradients, loss\",\n \"def loss_graph(self, training_costs, test_costs, learning_rate, training_accuracy, test_accuracy, val_accuracy,\\n layers, data_size, n_neighbours, dropout_layer, dropout_rate):\\n\\n plt.plot(training_costs, label=\\\"Training loss\\\")\\n plt.plot(test_costs, label=\\\"Test loss\\\")\\n plt.xlabel(\\\"Iterations\\\", size='medium')\\n plt.ylabel(\\\"Cost function (%)\\\", size='medium')\\n plt.suptitle(\\\"Cost function while training the neural network\\\", size='medium', ha='center')\\n if True in dropout_layer:\\n plt.title(\\\"layers: {}, dropout rate: {}, learning rate: {}\\\".format(layers, dropout_rate, learning_rate),\\n size='small', ha='center')\\n else:\\n plt.title(\\\"layers: {}, learning rate: {}\\\".format(layers, learning_rate), size='small', ha='center')\\n plt.figtext(0.77, 0.35, \\\"Training accuracy\\\\n{0:.2f}%\\\".format(training_accuracy), size='medium')\\n plt.figtext(0.77, 0.25, \\\"Test accuracy\\\\n{0:.2f}%\\\".format(test_accuracy), size='medium')\\n plt.figtext(0.77, 0.15, \\\"Validation accuracy\\\\n{0:.2f}%\\\".format(val_accuracy), size='medium')\\n if n_neighbours == 0:\\n plt.figtext(0.77, 0.80, \\\"Neighbours\\\\nexcluded\\\", size='medium')\\n else:\\n plt.figtext(0.77, 0.80, \\\"{} neighbours\\\\nincluded\\\".format(n_neighbours), size='medium')\\n plt.figtext(0.77, 0.70, \\\"{}\\\\nsamples\\\".format(data_size))\\n plt.legend(loc='right', bbox_to_anchor=(1.39, 0.5))\\n plt.subplots_adjust(right=0.75)\\n working_dir = os.path.dirname(os.path.abspath(__file__))\\n saving(working_dir + \\\"/output_ANN/loss_plots/{}_error_{}\\\".format(n_neighbours, data_size))\",\n \"def learning_viz(self) :\\n self.train\\n history = self.history\\n plot_loss(history)\",\n \"def __init__(self, rate, sigmoid, hidden, examples, variables, layers, rule, dropout):\\n self.rate = rate\\n self.sigmoid = sigmoid\\n self.inputs = variables \\n self.vis_layer = []\\n self.hidden_layers = []\\n self.hidden = hidden\\n self.variables = variables\\n self.data = BOOLEAN(examples, self.variables)\\n self.layers = layers-1\\n self.rule = rule\\n self.dropout = dropout\\n self.length = int(math.pow(2, self.variables))\\n for _ in xrange(self.hidden):\\n self.vis_layer.append(Neuron(self.rate, self.sigmoid, self.inputs+1, dropout))\\n for layer in xrange(self.layers):\\n self.hidden_layers.append([])\\n for _ in xrange(self.hidden):\\n self.hidden_layers[layer].append(Neuron(self.rate, self.sigmoid, self.hidden+1, dropout))\\n if self.hidden > 0:\\n self.output_neuron = Neuron(self.rate, self.sigmoid, self.hidden+1, dropout)\\n else:\\n self.output_neuron = Neuron(self.rate, self.sigmoid, self.inputs+1, dropout)\",\n \"def main() -> None:\\n\\n # Load pickled (adj, feat) tuple\\n with open(os.path.join(NETWORK_DIR, PICKLE_FILE), \\\"rb\\\") as file:\\n adj, features = pickle.load(file)\\n\\n g = nx.Graph(adj) # Recreate graph using node indices (0 to num_nodes-1)\\n\\n # Draw the network\\n # nx.draw_networkx(g, with_labels=False, node_size=50, node_color=\\\"r\\\")\\n # plt.show()\\n\\n # Preprocessing (train/test split)\\n np.random.seed(0) # make sure train-test split is consistent\\n adj_sparse = nx.to_scipy_sparse_matrix(g)\\n\\n # Perform train-test split\\n (\\n adj_train,\\n train_edges,\\n train_edges_false,\\n val_edges,\\n val_edges_false,\\n test_edges,\\n test_edges_false,\\n ) = mask_test_edges(adj_sparse, test_frac=0.3, val_frac=0.1)\\n\\n # new graph object with only non-hidden edges\\n g_train = nx.from_scipy_sparse_matrix(adj_train)\\n\\n # Inspect train/test split\\n print(\\\"Total nodes:\\\", adj_sparse.shape[0])\\n\\n # adj is symmetric, so nnz (num non-zero) = 2 * num_edges\\n print(\\\"Total edges:\\\", int(adj_sparse.nnz / 2))\\n print(\\\"Training edges (positive):\\\", len(train_edges))\\n print(\\\"Training edges (negative):\\\", len(train_edges_false))\\n print(\\\"Validation edges (positive):\\\", len(val_edges))\\n print(\\\"Validation edges (negative):\\\", len(val_edges_false))\\n print(\\\"Test edges (positive):\\\", len(test_edges))\\n print(\\\"Test edges (negative):\\\", len(test_edges_false))\\n\\n # Train node2vec (Learn Node Embeddings)\\n\\n # node2vec settings\\n # NOTE: When p = q = 1, this is equivalent to DeepWalk\\n\\n P = 1 # Return hyperparameter\\n Q = 1 # In-out hyperparameter\\n WINDOW_SIZE = 10 # Context size for optimization\\n NUM_WALKS = 10 # Number of walks per source\\n WALK_LENGTH = 80 # Length of walk per source\\n DIMENSIONS = 128 # Embedding dimension\\n DIRECTED = False # Graph directed/undirected\\n WORKERS = 8 # Num. parallel workers\\n ITER = 1 # SGD epochs\\n\\n # Preprocessing, generate walks\\n\\n # create node2vec graph instance\\n g_n2v = node2vec.Graph(g_train, DIRECTED, P, Q)\\n g_n2v.preprocess_transition_probs()\\n walks = g_n2v.simulate_walks(NUM_WALKS, WALK_LENGTH)\\n walks = [list(map(str, walk)) for walk in walks]\\n\\n # Train skip-gram model\\n model = Word2Vec(\\n walks,\\n size=DIMENSIONS,\\n window=WINDOW_SIZE,\\n min_count=0,\\n sg=1,\\n workers=WORKERS,\\n iter=ITER,\\n )\\n\\n # Store embeddings mapping\\n emb_mappings = model.wv\\n\\n print(emb_mappings)\\n\\n # Create node embeddings matrix (rows = nodes, columns = embedding features)\\n emb_list = []\\n for node_index in range(0, adj_sparse.shape[0]):\\n node_str = str(node_index)\\n node_emb = emb_mappings[node_str]\\n emb_list.append(node_emb)\\n emb_matrix = np.vstack(emb_list)\\n\\n def get_edge_embeddings(edge_list):\\n \\\"\\\"\\\"\\n Generate bootstrapped edge embeddings (as is done in node2vec paper)\\n Edge embedding for (v1, v2) = hadamard product of node embeddings for\\n v1, v2.\\n \\\"\\\"\\\"\\n embs = []\\n for edge in edge_list:\\n node1 = edge[0]\\n node2 = edge[1]\\n emb1 = emb_matrix[node1]\\n emb2 = emb_matrix[node2]\\n edge_emb = np.multiply(emb1, emb2)\\n embs.append(edge_emb)\\n embs = np.array(embs)\\n return embs\\n\\n # Train-set edge embeddings\\n pos_train_edge_embs = get_edge_embeddings(train_edges)\\n neg_train_edge_embs = get_edge_embeddings(train_edges_false)\\n train_edge_embs = np.concatenate(\\n [pos_train_edge_embs, neg_train_edge_embs]\\n )\\n\\n # Create train-set edge labels: 1 = real edge, 0 = false edge\\n train_edge_labels = np.concatenate(\\n [np.ones(len(train_edges)), np.zeros(len(train_edges_false))]\\n )\\n\\n # Val-set edge embeddings, labels\\n pos_val_edge_embs = get_edge_embeddings(val_edges)\\n neg_val_edge_embs = get_edge_embeddings(val_edges_false)\\n val_edge_embs = np.concatenate([pos_val_edge_embs, neg_val_edge_embs])\\n val_edge_labels = np.concatenate(\\n [np.ones(len(val_edges)), np.zeros(len(val_edges_false))]\\n )\\n\\n # Test-set edge embeddings, labels\\n pos_test_edge_embs = get_edge_embeddings(test_edges)\\n neg_test_edge_embs = get_edge_embeddings(test_edges_false)\\n test_edge_embs = np.concatenate([pos_test_edge_embs, neg_test_edge_embs])\\n\\n # Create val-set edge labels: 1 = real edge, 0 = false edge\\n test_edge_labels = np.concatenate(\\n [np.ones(len(test_edges)), np.zeros(len(test_edges_false))]\\n )\\n\\n # Train logistic regression classifier on train-set edge embeddings\\n edge_classifier = LogisticRegression(random_state=0)\\n edge_classifier.fit(train_edge_embs, train_edge_labels)\\n\\n # Predicted edge scores: probability of being of class \\\"1\\\" (real edge)\\n val_preds = edge_classifier.predict_proba(val_edge_embs)[:, 1]\\n val_roc = roc_auc_score(val_edge_labels, val_preds)\\n val_ap = average_precision_score(val_edge_labels, val_preds)\\n\\n # Predicted edge scores: probability of being of class \\\"1\\\" (real edge)\\n test_preds = edge_classifier.predict_proba(test_edge_embs)[:, 1]\\n test_roc = roc_auc_score(test_edge_labels, test_preds)\\n test_ap = average_precision_score(test_edge_labels, test_preds)\\n\\n print(\\\"node2vec Validation ROC score: \\\", str(val_roc))\\n print(\\\"node2vec Validation AP score: \\\", str(val_ap))\\n print(\\\"node2vec Test ROC score: \\\", str(test_roc))\\n print(\\\"node2vec Test AP score: \\\", str(test_ap))\",\n \"def model(X_train, Y_train, X_test, Y_test, num_iterations, learning_rate, print_cost):\\n\\n\\n # initialize parameters with zeros\\n w, b = initialize_with_zeros(X_train.shape[0]);\\n\\n print(\\\"w.shape() = \\\" +str(w.shape)+ \\\", b = \\\" +str(b));\\n\\n # Gradient descent\\n parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost);\\n \\n # Retrieve parameters w and b from dictionary \\\"parameters\\\"\\n w = parameters[\\\"w\\\"]\\n b = parameters[\\\"b\\\"]\\n \\n # Predict test/train set examples \\n Y_prediction_test = predict(w, b, X_test)\\n Y_prediction_train = predict(w, b, X_train)\\n\\n # Print train/test Errors\\n print(\\\"train accuracy: {} %\\\".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))\\n print(\\\"test accuracy: {} %\\\".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))\\n \\n d = {\\\"costs\\\": costs,\\n \\\"Y_prediction_test\\\": Y_prediction_test, \\n \\\"Y_prediction_train\\\" : Y_prediction_train, \\n \\\"w\\\" : w,\\n \\\"b\\\" : b,\\n \\\"learning_rate\\\" : learning_rate,\\n \\\"num_iterations\\\": num_iterations}\\n \\n return d\",\n \"def main():\\n # Initializing learning rate\\n learning_rate = 0.0005\\n # Initializing stopping criteria\\n stopping_criteria = 0.01\\n # load the data training data from a csv file with an url\\n training_x,testing_x, training_y, testing_y,mean,sd= ai.store_data(\\\"https://github.com/santiagocantu98/K-Nearest-Neightbours/raw/master/diabetes.csv\\\",\\\"training\\\")\\n normal_testing = np.copy(testing_x)\\n\\n # scalates the features of the testing data\\n testing_data_scaled,mean,sd = ai.scale_features(testing_x,mean,sd)\\n ai.print_scaled_data(testing_data_scaled,\\\"testing\\\")\\n ai.calculate_euclidean_distance(training_x, training_y , testing_data_scaled, testing_y,normal_testing)\",\n \"def testvis(layers='first'):\\n\\n\\tfrom scipy.io import loadmat\\n\\tfrom setup import NeuralNetwork as nnsetup\\n\\n\\tresult = loadmat(\\\"goodmatx.mat\\\")\\n\\tw1 = result['v1']\\n\\tw0 = result['v0']\\n\\tx,y = result['train_x'], result['train_y']\\n\\n\\t# result = loadmat(\\\"ducky.mat\\\")\\n\\t# x = result['train_x']\\n\\t# y = result['train_y']\\n\\n\\tsize = [x.shape[1], 1000, y.shape[1]]\\n\\n\\tnn = nnsetup([size[0],size[1],size[0]],output='sigm')\\n\\n\\tnn.W[0] = w0\\n\\tnn.W[1] = w1\\n\\t\\n\\tfor i in range(50):\\n\\t\\tvisualize( nn, x, k = 3000+i*4, layers=layers, mode='save' )\",\n \"def gradient_descent(w, b, image_matrix, true_labels, iteration_count, learning_rate, show_cost):\\n\\n\\tcosts = []\\n\\n\\tfor i in range(iteration_count):\\n\\t\\tgradients, cost = propagate(w, b, image_matrix, true_labels)\\n\\t\\t# if math.isnan(cost):\\n\\t\\t# \\tA = sigmoid(np.dot(w.T, image_matrix) + b)\\n\\t\\t# \\tprint(np.squeeze(A))\\n\\t\\t# \\tprint(cross_entropy_cost(image_matrix.shape[1], A, true_labels))\\n\\n\\t\\tdw = gradients['dw'] # obtaining weight gradient from back propagation\\n\\t\\tdb = gradients['db'] # obtaining bias gradient from back propagation\\n\\n\\t\\tw = w - learning_rate * dw # w array stepping towards local minimum with steps of length: learning_rate\\n\\t\\tb = b - learning_rate * db # b value stepping\\n\\n\\t\\t# appends cost value at given iteration increments to costs array for analystics\\n\\t\\tcollection_rate = 1\\n\\t\\tif i % collection_rate == 0:\\n\\t\\t\\tcosts.append(cost)\\n\\n\\t\\t# Shows cost value every 100 iterations if True\\n\\t\\tif show_cost and i % 100 == 0 and i != 0:\\n\\t\\t\\tprint('Iteration: %i, Cost: %f' % (i, cost))\\n\\n\\tparameters = {\\n\\t\\\"w\\\": w,\\n\\t\\\"b\\\": b\\n\\t}\\n\\n\\tgradients = {\\n\\t\\\"dw\\\": dw,\\n\\t\\\"db\\\": db,\\n\\t}\\n\\n\\treturn parameters, gradients, costs\",\n \"def train():\\n\\n ### DO NOT CHANGE SEEDS!\\n # Set the random seeds for reproducibility\\n np.random.seed(42)\\n\\n ## Prepare all functions\\n # Get number of units in each hidden layer specified in the string such as 100,100\\n if FLAGS.dnn_hidden_units:\\n dnn_hidden_units = FLAGS.dnn_hidden_units.split(\\\",\\\")\\n dnn_hidden_units = [int(dnn_hidden_unit_) for dnn_hidden_unit_ in dnn_hidden_units]\\n else:\\n dnn_hidden_units = []\\n\\n # Get negative slope parameter for LeakyReLU\\n neg_slope = FLAGS.neg_slope\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n import matplotlib.pyplot as plt\\n\\n data = cifar10_utils.get_cifar10(FLAGS.data_dir)\\n train = data['train']\\n test = data['test']\\n dim_x = train.images.shape[1]*train.images.shape[2]*train.images.shape[3]\\n\\n mlp = MLP(dim_x, dnn_hidden_units, train.labels.shape[1], neg_slope)\\n loss_module = CrossEntropyModule()\\n\\n loss_train = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n loss_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n accuracy_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n\\n images_test = test.images\\n labels_test = test.labels\\n images_test = np.reshape(images_test, (images_test.shape[0], dim_x))\\n\\n for i in range(0, FLAGS.max_steps):\\n if PRINTS:\\n print('iter', i+1, end='\\\\r')\\n images, labels = train.next_batch(FLAGS.batch_size) \\n images = np.reshape(images, (images.shape[0], dim_x))\\n\\n pred = mlp.forward(images)\\n loss = loss_module.forward(pred, labels)\\n loss_grad = loss_module.backward(pred, labels)\\n mlp.backward(loss_grad)\\n\\n for module in reversed(mlp.modules):\\n if isinstance(module, LinearModule):\\n module.params['weight'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['weight']\\n module.params['bias'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['bias']\\n if (i+1) % FLAGS.eval_freq == 0:\\n pred_test = mlp.forward(images_test)\\n loss_train[i // FLAGS.eval_freq] = loss\\n accuracy_test[i // FLAGS.eval_freq] = accuracy(pred_test, labels_test)\\n loss_test[i // FLAGS.eval_freq] = loss_module.forward(pred_test, labels_test)\\n if PRINTS:\\n print()\\n print('test_loss:', loss_test[i // FLAGS.eval_freq])\\n print('test_accuracy:', accuracy_test[i // FLAGS.eval_freq])\\n print('train_loss:', loss_train[i // FLAGS.eval_freq])\\n\\n if PLOTS:\\n fig, ax = plt.subplots(1, 2, figsize=(10,5))\\n fig.suptitle('Training curves for Numpy MLP\\\\nFinal test accuracy: {:0.4f}, default configuration'.format(accuracy_test[i // FLAGS.eval_freq]))\\n\\n ax[0].set_title('Loss')\\n ax[0].set_ylabel('Loss value')\\n ax[0].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\\n ax[0].plot(loss_train, label='Train')\\n ax[0].plot(loss_test, label='Test')\\n ax[0].legend()\\n\\n ax[1].set_title('Accuracy')\\n ax[1].set_ylabel('Accuracy value')\\n ax[1].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\\n ax[1].plot(accuracy_test, label='Test')\\n ax[1].legend()\\n plt.show()\\n\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def trainNet():\",\n \"def build_graph(self):\\n # place holders for inputs here \\n HIDDEN_LAYER = self.FLAGS.feature_layer_size\\n \\n self.x_i = tf.placeholder(dtype=tf.float32, shape = (None, self.INPUT_DIM), name=\\\"x_i\\\")\\n self.a_i = tf.placeholder(dtype=tf.float32, shape = (None, self.ACTION_DIM), name = \\\"a_i\\\")\\n self.q_opc = tf.placeholder(dtype=tf.float32, shape = (None, 1), name = \\\"q_opc\\\")\\n self.q_ret = tf.placeholder(dtype=tf.float32, shape = (None, 1), name = \\\"q_ret\\\" )\\n self.c = self.FLAGS.c # truncation threshold constant\\n \\n self.actor_net = PolicyNet(HIDDEN_LAYER, self.ACTION_DIM, name= self.name + \\\"_actor\\\", co_var = self.co_var)\\n self.critic_net = AdvantageValueNet(HIDDEN_LAYER , name= self.name + \\\"_critic\\\")\\n \\n self.policy_xi_stats, self.policy_xi_dist = self.actor_net(self.x_i)\\n \\n self.val_xi, self.adv_xi_ai = self.critic_net(self.x_i, self.a_i, self.policy_xi_dist)\\n \\n #sample a' now\\n self.a_i_ = tf.reshape(self.policy_xi_dist.sample(1), shape=[-1,self.ACTION_DIM])\\n self.a_i_ = tf.clip_by_value(self.a_i_, self.env.action_space.low[0], self.env.action_space.high[0]) #20190828 add clipping\\n \\n _, self.adv_xi_ai_ = self.critic_net(self.x_i, self.a_i_, self.policy_xi_dist) # val will be the same for \\n \\n _, self.average_policy_xi_dist = self.average_actor_net(self.x_i) # can this be done better ?\\n \\n self.prob_a_i = tf.reshape(self.policy_xi_dist.prob(self.a_i),shape=[-1,1]) + 1e-8\\n self.prob_a_i_ = tf.reshape(self.policy_xi_dist.prob(self.a_i_),shape=[-1,1]) + 1e-8\\n \\n self.log_prob_a_i = tf.log(self.prob_a_i)\\n self.log_prob_a_i_ = tf.log(self.prob_a_i_)\\n \\n # for predicting 1-step a_i', p_i, p_i',\\n self.u_i = tf.placeholder(dtype=tf.float32, shape = (None, 2*self.ACTION_DIM))\\n \\n #self.u_i_dist = tf.contrib.distributions.MultivariateNormalDiag(loc= self.u_i, \\n # scale_diag = tf.ones_like(self.u_i) * self.co_var)\\n self.u_i_dist = tf.contrib.distributions.MultivariateNormalDiag(loc= self.u_i[:,0], scale_diag=self.u_i[:,1])\\n \\n self.u_i_prob_a_i = tf.reshape(self.u_i_dist.prob(self.a_i),shape=[-1,1]) + 1e-8\\n self.u_i_prob_a_i_ = tf.reshape(self.u_i_dist.prob(self.a_i_),shape=[-1,1]) + 1e-8\\n \\n self.p_i = tf.divide(self.prob_a_i, self.u_i_prob_a_i)\\n self.p_i_ = tf.divide(self.prob_a_i_ , self.u_i_prob_a_i_)\\n \\n\\n # take care of NaNs here, for importance sampling weights (might be an extra step)\\n self.p_i = tf.where(tf.is_nan(self.p_i), tf.zeros_like(self.p_i), self.p_i)\\n self.p_i_ = tf.where(tf.is_nan(self.p_i_), tf.zeros_like(self.p_i_), self.p_i_)\\n\\n self.c_i = tf.minimum(1. , tf.pow(self.p_i, 1.0/self.ACTION_DIM))\\n \\n \\n # for verification about checking if params are getting synched\\n self.local_actor_vars = self.actor_net.local_params()\\n self.global_actor_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'global_actor')\\n \\n self.local_critic_vars = self.critic_net.local_params()\\n self.global_critic_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'global_critic')\\n \\n \\n # Sync ops from global\\n self.sync_local_actor_op = self.actor_net.update_local_params_op('global_actor') # global actor\\n self.sync_local_critic_op = self.critic_net.update_local_params_op('global_critic')\\n \\n # soft update the average network\\n self.soft_update_average_actor_op = self.average_actor_net.soft_update_from_target_params('global_actor',\\n self.FLAGS.tau)\\n \\n #Get gradients from local network using local losses\\n \\n g1 = tf.reshape(tf.gradients((self.log_prob_a_i * (self.q_opc - self.val_xi)),self.policy_xi_stats,\\n name=self.name+\\\"g1_grads\\\", unconnected_gradients='zero'), shape = [-1,2*self.ACTION_DIM])\\n g2 = (self.adv_xi_ai_ - self.val_xi) * tf.reshape(tf.gradients((self.log_prob_a_i_), \\n self.policy_xi_stats, name=self.name+\\\"g2_grads\\\", unconnected_gradients='zero'), shape = [-1,2*self.ACTION_DIM])\\n \\n \\n self.g = tf.minimum(self.c, self.p_i) * g1 + tf.nn.relu(1 - tf.divide(self.c , self.p_i_)) * g2\\n \\n \\n self.k = tf.reshape(tf.gradients(tf.contrib.distributions.kl_divergence(self.average_policy_xi_dist, \\n self.policy_xi_dist), self.policy_xi_stats, unconnected_gradients='zero'), shape = [-1,2*self.ACTION_DIM])\\n \\n \\n \\n self.kg = tf.reduce_sum( tf.multiply(self.g, self.k), 1, keep_dims=True)\\n \\n #print \\\"kg\\\", self.kg\\n \\n self.k2 = tf.reduce_sum( tf.multiply(self.k, self.k), 1, keep_dims=True)\\n \\n self.reg_g = self.g - tf.maximum(tf.zeros_like(self.g), tf.divide((self.kg - self.FLAGS.delta), self.k2) ) * self.k\\n \\n # take gradients wrt to the local params\\n self.actor_grads = tf.gradients(self.policy_xi_stats, self.local_actor_vars, \\n grad_ys= -self.reg_g, name=\\\"actor_grads\\\", unconnected_gradients='zero')\\n \\n \\n #for ti,tj in zip(self.actor_grads, self.global_actor_vars):\\n # print ti, \\\"\\\\n\\\", tj , \\\"\\\\n\\\", \\\"===========\\\"\\n \\n # apply local gradients to the global network\\n self.actor_train_op = self.optimizer.apply_gradients(zip(self.actor_grads, self.global_actor_vars),\\n global_step=tf.train.get_global_step())\\n \\n \\n # critic loss function and updates\\n \\n # take gradient wrt to local variables\\n self.critic_loss_1 = ((self.q_ret - self.adv_xi_ai) ** 2.0) / 2.0\\n \\n # for predicting 1-step a_i', p_i, p_i',\\n self.v_target = tf.placeholder(dtype=tf.float32, shape = (None, 1))\\n \\n #self.v_trunc = tf.minimum(self.p_i, 1.0) * (self.q_ret - self.adv_xi_ai) + self.val_xi\\n self.critic_loss_2 = ((self.v_target - self.val_xi) ** 2.0) / 2.0\\n \\n self.critic_loss = self.critic_loss_1 + self.critic_loss_2\\n \\n #Apply local gradients to global network\\n \\n self.critic_grads = tf.gradients(self.critic_loss, self.local_critic_vars)\\n \\n self.critic_train_op = self.optimizer.apply_gradients(zip(self.critic_grads, self.global_critic_vars),\\n global_step=tf.train.get_global_step())\\n \\n # critic_summaries op\\n critic_grads_summary = []\\n print('-----------------------------------------------------------------')\\n print('Create critic_grads_summary histogram ')\\n for grad,var in zip(self.critic_grads, self.local_critic_vars):\\n print('{} - {}'.format(var.name, grad))\\n critic_grads_summary.append(tf.summary.histogram(var.name + '/gradient', grad))\\n critic_grads_summary.append(tf.summary.histogram(var.name + '/weight', var))\\n \\n self.critic_summary_op = tf.summary.merge([\\n tf.summary.scalar(self.name + \\\"_critc_mean_loss_Q\\\", tf.reduce_mean(self.critic_loss_1)),\\n tf.summary.scalar(self.name + \\\"_critc_mean_loss_V\\\", tf.reduce_mean(self.critic_loss_2)),\\n tf.summary.scalar(self.name + \\\"_critc_sum_loss_Q\\\", tf.reduce_sum(self.critic_loss_1)),\\n tf.summary.scalar(self.name + \\\"_critc_sum_loss_V\\\", tf.reduce_sum(self.critic_loss_2)),\\n tf.summary.scalar(self.name + \\\"_critc_mean_loss\\\", tf.reduce_mean(self.critic_loss)),\\n tf.summary.scalar(self.name + \\\"_critc_sum_loss\\\", tf.reduce_sum(self.critic_loss)),\\n tf.summary.histogram(self.name + \\\"_val_target\\\", self.v_target),\\n tf.summary.histogram(self.name + \\\"_val_pred\\\", self.val_xi),\\n tf.summary.histogram(self.name + \\\"_Q_pred\\\", self.adv_xi_ai),\\n tf.summary.histogram(self.name + \\\"_Q_ret\\\", self.q_ret),\\n tf.summary.histogram(self.name + \\\"_Q_opc\\\", self.q_opc),\\n ] + critic_grads_summary)\\n \\n \\n # actor summaries op\\n\\n actor_grads_summary = []\\n print('-----------------------------------------------------------------')\\n print('Create actor_grads_summary histogram ')\\n for grad,var in zip(self.actor_grads, self.local_actor_vars):\\n print('{} - {}'.format(var.name, grad))\\n actor_grads_summary.append(tf.summary.histogram(var.name + '/gradient', grad))\\n actor_grads_summary.append(tf.summary.histogram(var.name + '/weight', var))\\n \\n\\n self.actor_summary_op = tf.summary.merge([\\n tf.summary.scalar(self.name + \\\"_actor_mean_loss_reg_g\\\", tf.reduce_mean(self.reg_g)),\\n tf.summary.scalar(self.name + \\\"_actor_neg_mean_loss_reg_g\\\", tf.reduce_mean(-self.reg_g)),\\n tf.summary.scalar(self.name + \\\"_actor_sum_loss_reg_g\\\", tf.reduce_sum(self.reg_g)),\\n tf.summary.scalar(self.name + \\\"_actor_neg_sum_reg_g\\\", tf.reduce_sum(-self.reg_g)),\\n tf.summary.scalar(self.name + \\\"_actor_sum_g\\\", tf.reduce_sum(self.g)),\\n tf.summary.scalar(self.name + \\\"_actor_neg_sum_g\\\", tf.reduce_sum(-self.g)),\\n tf.summary.scalar(self.name + \\\"_actor_mean_kl\\\", tf.reduce_mean(self.k)),\\n tf.summary.scalar(self.name + \\\"_actor_sum_kl\\\", tf.reduce_sum(self.k)),\\n tf.summary.histogram(self.name + \\\"_policy_stats\\\", self.policy_xi_stats),\\n ] + actor_grads_summary )\",\n \"def linear_eval(train_ds, model, task, epochs=10, eval_ds=None):\\n\\n print('==========LINEAR EVAL==========')\\n\\n # Filter out undesired examples with excluded_label\\n ds = train_ds.filter(lambda x: x['label'] != task['excluded_label'])\\n ds = ds.map(data_utils.finetune_preprocess)\\n ds = ds.shuffle(1000)\\n ds = ds.batch(FLAGS.lineareval_bs)\\n\\n # loss, metrics, optimizers\\n train_loss= tf.keras.metrics.Mean(name='train_loss')\\n train_sup_acc = tf.keras.metrics.Accuracy(name='train_supervised_accuracy')\\n criterion_sup = tf.nn.softmax_cross_entropy_with_logits \\n optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)\\n\\n # Base network and projection head layers are not trainable in linear_eval\\n model.resnet.trainable = False\\n model.ph.trainable = False \\n\\n for epoch in range(epochs): \\n model.resnet.trainable = False\\n train_loss.reset_states()\\n train_sup_acc.reset_states()\\n for x in ds:\\n with tf.GradientTape() as tape:\\n image = x['image']\\n labels = x[task['name']]\\n out = model(image, mode='supervised', sup_layers=1, training=True)\\n metrics.update_supervised_accuracy(train_sup_acc, labels, out)\\n\\n loss = criterion_sup(tf.one_hot(labels, depth=task['num_classes']), out)\\n loss = tf.math.reduce_mean(loss)\\n gradients = tape.gradient(loss, model.trainable_variables)\\n optimizer.apply_gradients(\\n filter(lambda gv: gv[0] is not None, zip(gradients, model.trainable_variables))\\n )\\n train_loss.update_state(loss)\\n print('supervised (linear eval) loss')\\n print(train_loss.result())\\n print('supervised (linear eval) accuracy')\\n print(train_sup_acc.result())\\n\\n # Evaluate results on eval_ds if possible\\n if eval_ds is not None:\\n evaluate(eval_ds, model, task)\\n \\n model.resnet.trainable = True\\n model.ph.trainable = True\",\n \"def find_results(data,weight_matrix,params):\\r\\n \\r\\n data = data.astype(np.float32)\\r\\n weight_matrix = weight_matrix.astype(np.float32)\\r\\n \\r\\n rank = params['rank']\\r\\n lamb = params['lambda']\\r\\n lr = params['lr']\\r\\n hidden_pairs = params['hidden_pairs']\\r\\n cost_functions.lamb = lamb\\r\\n\\r\\n f = cost_functions.frobenius \\r\\n V_masked = create_mask(data,hidden_pairs)\\r\\n bool_mask = V_masked.notnull().values\\r\\n tf_mask = tf.Variable(bool_mask)\\r\\n \\r\\n V = tf.constant(V_masked.values)\\r\\n laplacian_matrix = laplacian(weight_matrix).astype(np.float32)\\r\\n W, H = init_W_H(V.shape, rank=rank)\\r\\n WH = tf.matmul(W, H)\\r\\n L = tf.constant(laplacian_matrix)\\r\\n WTLW = tf.matmul(tf.matmul(tf.transpose(W), L), W)\\r\\n\\r\\n cost = f(V, tf_mask, WH, WTLW)\\r\\n train_step = tf.train.ProximalGradientDescentOptimizer(lr).minimize(cost)\\r\\n init = tf.global_variables_initializer()\\r\\n clip = get_clip(W, H)\\r\\n\\r\\n sess = tf.Session()\\r\\n sess.run(init)\\r\\n\\r\\n previous_cost = sess.run(cost)\\r\\n sess.run(train_step)\\r\\n sess.run(clip)\\r\\n initial_difference = previous_cost - sess.run(cost)\\r\\n\\r\\n matrix_errors = []\\r\\n graph_errors = []\\r\\n imputation_error = []\\r\\n\\r\\n learnt_W = sess.run(W).astype(np.float32)\\r\\n learnt_H = sess.run(H).astype(np.float32)\\r\\n imputation_norm = np.linalg.norm((data - learnt_W.dot(learnt_H))[~bool_mask])\\r\\n \\r\\n i = 0\\r\\n while np.isfinite(sess.run(cost)) and previous_cost-sess.run(cost) > TARGET_DIFFERENCE * initial_difference and i<=max_iterations:\\r\\n previous_cost = sess.run(cost)\\r\\n sess.run(train_step)\\r\\n sess.run(clip)\\r\\n matrix_errors.append(sess.run(cost_functions.matrix_cost))\\r\\n graph_errors.append(sess.run(cost_functions.graph_cost))\\r\\n i+=1\\r\\n\\r\\n learnt_W = sess.run(W).astype(np.float32)\\r\\n learnt_H = sess.run(H).astype(np.float32)\\r\\n\\r\\n imputation_norm = np.linalg.norm((data - learnt_W.dot(learnt_H))[~bool_mask])\\r\\n imputation_error.append(imputation_norm)\\r\\n\\r\\n return {'imputation_error':imputation_norm,'W':sess.run(W),'H':sess.run(H),\\r\\n 'graph_error':graph_errors,'matrix_error':matrix_errors,'imputation_error_list':imputation_error}\",\n \"def test_cost(self):\\n # Get components for the network\\n data = array([[1, 0], [0, 1]])\\n cdata = LabeledCData(data, labels=array([0, 1]))\\n encoder = BinaryEncoding(cdata)\\n ansatz = ProductAnsatz(2)\\n measure = Measurement(2, [0, 1])\\n\\n # Define a basic predictor (function which inputs a measurement outcome and returns a label)\\n def predictor(outcome):\\n return 0\\n\\n # Build the network\\n qnn = Network(layers=[encoder, ansatz, measure], computer=\\\"2q-qvm\\\", predictor=predictor)\\n\\n # Compute the cost of the network\\n cost = qnn.cost(angles={0: [0.0], 1: [0.0]})\\n\\n self.assertAlmostEqual(cost, 0.5)\",\n \"def mini_model(self):\\n with tf.variable_scope(name_or_scope='human2d_network'):\\n # down-sampling\\n resi_0 = res_layer(self._input, filters=16, strides=2, kernel_size=7, training=self.training, name='resi_0')\\n resi_1 = res_layer(resi_0, filters=32, strides=1, kernel_size=3, training=self.training, name='resi_1')\\n pool_0 = max_pool_layer(resi_1, name='pool_0')\\n resi_2 = res_layer(pool_0, filters=32, strides=1, kernel_size=3, training=self.training, name='resi_2')\\n # hourglass module\\n resi_3 = res_layer(resi_2, filters=64, strides=1, kernel_size=3, training=self.training, name='resi_3')\\n hrgs_0 = hourglass_layer(resi_3, training=True, name='hrgs_0')\\n # keypoint output\\n keypoint_pre_0 = res_layer(hrgs_0, filters=64, strides=1, kernel_size=3, training=self.training,\\n name='keypoint_pre_0')\\n keypoint_pre_1 = res_layer(keypoint_pre_0, filters=64, strides=1, kernel_size=3, training=self.training,\\n name='keypoint_pre_1')\\n keypoint_pre_2 = res_layer(keypoint_pre_1, filters=64, strides=1, kernel_size=3, training=self.training,\\n name='keypoint_pre_2')\\n keypoint_output_raw = res_layer(keypoint_pre_2, filters=14, strides=1, kernel_size=1,\\n training=self.training, bottleneck=False, name='keypoint_output_raw')\\n keypoint_output = tf.nn.sigmoid(x=keypoint_output_raw, name='keypoint_output')\\n # silhouette output\\n silhouette_pre_0 = res_layer(hrgs_0, filters=64, strides=1, kernel_size=3, training=self.training,\\n name='silhouette_pre_0')\\n silhouette_pre_1 = res_layer(silhouette_pre_0, filters=64, strides=1, kernel_size=3, training=self.training,\\n name='silhouette_pre_1')\\n silhouette_pre_2 = res_layer(silhouette_pre_1, filters=64, strides=1, kernel_size=3, training=self.training,\\n name='silhouette_pre_2')\\n silhouette_output_raw = res_layer(silhouette_pre_2, filters=2, strides=1, kernel_size=1,\\n training=self.training, bottleneck=False, name='silhouette_output_raw')\\n silhouette_output = tf.nn.softmax(logits=silhouette_output_raw, name='silhouette_output')\\n # return\\n return None, None, keypoint_output, silhouette_output\",\n \"def main():\\n # construct the argument parse and parse the arguments\\n args = argparse.ArgumentParser()\\n args.add_argument(\\\"-o\\\", \\\"--output\\\", required=True, help=\\\"path to the output loss/accuracy plot\\\")\\n args = vars(args.parse_args())\\n\\n # grab the MNIST dataset (if this is your first time using this\\n # dataset then the 11MB download may take a minute)\\n print(\\\"[INFO] accessing MNIST...\\\")\\n ((train_x, train_y), (test_x, test_y)) = mnist.load_data()\\n\\n # each image in the MNIST dataset is represented as a 28x28x1\\n # image, but in order to apply a standard neural network we must\\n # first \\\"flatten\\\" the image to be simple list of 28x28=784 pixels\\n train_x = train_x.reshape((train_x.shape[0], 28 * 28 * 1))\\n test_x = test_x.reshape((test_x.shape[0], 28 * 28 * 1))\\n # scale data to the range of [0, 1]\\n train_x = train_x.astype(\\\"float32\\\") / 255.0\\n test_x = test_x.astype(\\\"float32\\\") / 255.0\\n\\n # convert the labels from integers to vectors\\n label_binarizer = LabelBinarizer()\\n train_y = label_binarizer.fit_transform(train_y)\\n test_y = label_binarizer.transform(test_y)\\n\\n # define the 784-256-128-10 architecture using Keras\\n model = Sequential()\\n model.add(Dense(256, input_shape=(784,), activation=\\\"sigmoid\\\"))\\n model.add(Dense(128, activation=\\\"sigmoid\\\"))\\n model.add(Dense(10, activation=\\\"softmax\\\"))\\n\\n # train the model using SGD\\n print(\\\"[INFO] training network...\\\")\\n sgd = SGD(0.01)\\n model.compile(loss=\\\"categorical_crossentropy\\\", optimizer=sgd, metrics=[\\\"accuracy\\\"])\\n model_fit = model.fit(train_x, train_y, validation_data=(test_x, test_y), epochs=100, batch_size=128)\\n\\n # evaluate the network\\n print(\\\"[INFO] evaluating network...\\\")\\n predictions = model.predict(test_x, batch_size=128)\\n print(\\n classification_report(\\n test_y.argmax(axis=1), predictions.argmax(axis=1), target_names=[str(x) for x in label_binarizer.classes_]\\n )\\n )\\n\\n # plot the training loss and accuracy\\n plt.style.use(\\\"ggplot\\\")\\n plt.figure()\\n plt.plot(np.arange(0, 100), model_fit.history[\\\"loss\\\"], label=\\\"train_loss\\\")\\n plt.plot(np.arange(0, 100), model_fit.history[\\\"val_loss\\\"], label=\\\"val_loss\\\")\\n plt.plot(np.arange(0, 100), model_fit.history[\\\"acc\\\"], label=\\\"train_acc\\\")\\n plt.plot(np.arange(0, 100), model_fit.history[\\\"val_acc\\\"], label=\\\"val_acc\\\")\\n plt.title(\\\"Training Loss and Accuracy\\\")\\n plt.xlabel(\\\"Epoch #\\\")\\n plt.ylabel(\\\"Loss/Accuracy\\\")\\n plt.legend()\\n plt.savefig(args[\\\"output\\\"])\",\n \"def build_graph(self):\\n if self.model == 'dense':\\n # ForecastNet with two densely connected hidden layers in a cell and Mixture Density Network outputs\\n self.outputs, self.mu, self.sigma, self.cost = forecastnet_graph(self.X,\\n self.Y,\\n self.hidden_dim,\\n self.out_seq_length,\\n self.is_training)\\n elif self.model == 'conv':\\n # ForecastNet with a convlutional neural network in a cell and Mixture Density Network outputs\\n self.outputs, self.mu, self.sigma, self.cost = forecastnet_conv_graph(self.X,\\n self.Y,\\n self.hidden_dim,\\n self.out_seq_length,\\n self.is_training)\\n elif self.model == 'dense2':\\n # ForecastNet with two densely connected hidden layers in a cell and linear outputs\\n self.outputs, self.cost = forecastnet_graph2(self.X,\\n self.Y,\\n self.hidden_dim,\\n self.out_seq_length,\\n self.is_training)\\n elif self.model == 'conv2':\\n # ForecastNet with a convolutional neural network in a cell and linear outputs\\n self.outputs, self.cost = forecastnet_conv_graph2(self.X,\\n self.Y,\\n self.hidden_dim,\\n self.out_seq_length,\\n self.is_training)\",\n \"def cost_derivative(self,output_results,y):\\r\\n\\t\\treturn (output_results-y)\",\n \"def dev_network(self):\\n freeze_model(self.eval_net)\\n for data_set_name, data_set in self.data_to_dev.items():\\n #print(data_set_name)\\n valid_iter = make_data_iter(\\n dataset=data_set, batch_size=1, batch_type=self.batch_type,\\n shuffle=False, train=False)\\n valid_sources_raw = data_set.src\\n\\n \\n # don't track gradients during validation\\n r_total = 0\\n roptimal_total = 0\\n all_outputs = []\\n i_sample = 0\\n\\n for valid_batch in iter(valid_iter):\\n # run as during training to get validation loss (e.g. xent)\\n\\n batch = Batch(valid_batch, self.pad_index, use_cuda=self.use_cuda)\\n\\n encoder_output, encoder_hidden = self.model.encode(\\n batch.src, batch.src_lengths,\\n batch.src_mask)\\n\\n # if maximum output length is \\n # not globally specified, adapt to src len\\n if self.max_output_length is None:\\n self.max_output_length = int(max(batch.src_lengths.cpu().numpy()) * 1.5)\\n\\n batch_size = batch.src_mask.size(0)\\n prev_y = batch.src_mask.new_full(size=[batch_size, 1], fill_value=self.bos_index,\\n dtype=torch.long)\\n output = []\\n hidden = self.model.decoder._init_hidden(encoder_hidden)\\n prev_att_vector = None\\n finished = batch.src_mask.new_zeros((batch_size, 1)).byte()\\n\\n # pylint: disable=unused-variable\\n for t in range(self.max_output_length):\\n \\n\\n # if i_sample == 0 or i_sample == 3 or i_sample == 6:\\n # print(\\\"state on t = \\\", t, \\\" : \\\" , state)\\n\\n # decode one single step\\n logits, hidden, att_probs, prev_att_vector = self.model.decoder(\\n encoder_output=encoder_output,\\n encoder_hidden=encoder_hidden,\\n src_mask=batch.src_mask,\\n trg_embed=self.model.trg_embed(prev_y),\\n hidden=hidden,\\n prev_att_vector=prev_att_vector,\\n unroll_steps=1)\\n # greedy decoding: choose arg max over vocabulary in each step with egreedy porbability\\n \\n if self.state_type == 'hidden':\\n state = torch.cat(hidden, dim=2).squeeze(1).detach().cpu()[0]\\n else:\\n state = torch.FloatTensor(prev_att_vector.squeeze(1).detach().cpu().numpy()[0])\\n\\n logits = self.eval_net(state)\\n logits = logits.reshape([1,1,-1]) \\n #print(type(logits), logits.shape, logits)\\n next_word = torch.argmax(logits, dim=-1) \\n a = next_word.squeeze(1).detach().cpu().numpy()[0]\\n prev_y = next_word\\n \\n output.append(next_word.squeeze(1).detach().cpu().numpy())\\n prev_y = next_word\\n \\n # check if previous symbol was <eos>\\n is_eos = torch.eq(next_word, self.eos_index)\\n finished += is_eos\\n # stop predicting if <eos> reached for all elements in batch\\n if (finished >= 1).sum() == batch_size:\\n break\\n stacked_output = np.stack(output, axis=1) # batch, time\\n\\n #decode back to symbols\\n decoded_valid_in = self.model.trg_vocab.arrays_to_sentences(arrays=batch.src,\\n cut_at_eos=True)\\n decoded_valid_out_trg = self.model.trg_vocab.arrays_to_sentences(arrays=batch.trg,\\n cut_at_eos=True)\\n decoded_valid_out = self.model.trg_vocab.arrays_to_sentences(arrays=stacked_output,\\n cut_at_eos=True)\\n \\n \\n\\n hyp = stacked_output\\n\\n r = self.Reward(batch.trg, hyp , show = False)\\n \\n if i_sample == 0 or i_sample == 3 or i_sample == 6:\\n print(\\\"\\\\n Sample \\\", i_sample, \\\"-------------Target vs Eval_net prediction:--Raw---and---Decoded-----\\\")\\n print(\\\"Target: \\\", batch.trg, decoded_valid_out_trg)\\n print(\\\"Eval : \\\", stacked_output, decoded_valid_out, \\\"\\\\n\\\")\\n print(\\\"Reward: \\\", r)\\n\\n #r = self.Reward1(batch.trg, hyp , show = False)\\n r_total += sum(r[np.where(r > 0)])\\n if i_sample ==0:\\n roptimal = self.Reward(batch.trg, batch.trg , show = False)\\n roptimal_total += sum(roptimal[np.where(roptimal > 0)])\\n \\n all_outputs.extend(stacked_output)\\n i_sample += 1\\n\\n assert len(all_outputs) == len(data_set)\\n\\n # decode back to symbols\\n decoded_valid = self.model.trg_vocab.arrays_to_sentences(arrays=all_outputs,\\n cut_at_eos=True)\\n\\n # evaluate with metric on full dataset\\n join_char = \\\" \\\" if self.level in [\\\"word\\\", \\\"bpe\\\"] else \\\"\\\"\\n valid_sources = [join_char.join(s) for s in data_set.src]\\n valid_references = [join_char.join(t) for t in data_set.trg]\\n valid_hypotheses = [join_char.join(t) for t in decoded_valid]\\n\\n # post-process\\n if self.level == \\\"bpe\\\":\\n valid_sources = [bpe_postprocess(s) for s in valid_sources]\\n valid_references = [bpe_postprocess(v)\\n for v in valid_references]\\n valid_hypotheses = [bpe_postprocess(v) for\\n v in valid_hypotheses]\\n\\n # if references are given, evaluate against them\\n if valid_references:\\n assert len(valid_hypotheses) == len(valid_references)\\n\\n current_valid_score = 0\\n if self.eval_metric.lower() == 'bleu':\\n # this version does not use any tokenization\\n current_valid_score = bleu(valid_hypotheses, valid_references)\\n elif self.eval_metric.lower() == 'chrf':\\n current_valid_score = chrf(valid_hypotheses, valid_references)\\n elif self.eval_metric.lower() == 'token_accuracy':\\n current_valid_score = token_accuracy(\\n valid_hypotheses, valid_references, level=self.level)\\n elif self.eval_metric.lower() == 'sequence_accuracy':\\n current_valid_score = sequence_accuracy(\\n valid_hypotheses, valid_references)\\n else:\\n current_valid_score = -1\\n\\n self.dev_network_count += 1\\n self.tb_writer.add_scalar(\\\"dev/dev_reward\\\",\\n r_total, self.dev_network_count)\\n self.tb_writer.add_scalar(\\\"dev/dev_bleu\\\",\\n current_valid_score, self.dev_network_count)\\n \\n print(self.dev_network_count ,' r_total and score: ', r_total , current_valid_score)\\n\\n \\n unfreeze_model(self.eval_net)\\n return current_valid_score\",\n \"def __init__(self, input_dim, output_dim, hidden_dim=100, num_layers=2,\\r\\n num_epochs=100, learning_rate=0.001, threshold=0.1):\\r\\n super(ReluNet, self).__init__()\\r\\n\\r\\n self.input_dim = input_dim\\r\\n self.output_dim = output_dim\\r\\n self.hidden_dim = hidden_dim\\r\\n self.num_layers = num_layers\\r\\n self.num_epochs = num_epochs\\r\\n self.threshold = threshold\\r\\n self.learning_rate = learning_rate\\r\\n\\r\\n\\r\\n \\r\\n self.layers = nn.ModuleList()\\r\\n self.layers.append(nn.Linear(input_dim, hidden_dim))\\r\\n self.layers.append(nn.ReLU())\\r\\n for i in range(num_layers-1):\\r\\n self.layers.append(nn.Linear(hidden_dim, hidden_dim))\\r\\n self.layers.append(nn.ReLU())\\r\\n # output layer\\r\\n self.layers.append(nn.Linear(hidden_dim, output_dim))\",\n \"def neural_network(X, Y, Xs_test, Ys_test,\\n lr=0.1, iterations=2000, num_neurons=1000, num_layers=1, activation='ReLU'):\\n ## YOUR CODE HERE\\n #################\\n # Copied from backprop_sol\\n meanX = np.mean(X, axis=0)\\n stdX = np.std(X, axis=0)\\n meanY = np.mean(Y, axis=0)\\n stdY = np.std(Y, axis=0)\\n X = (X - meanX) / stdX\\n Y = (Y - meanY) / stdY\\n activations = dict(ReLU=ReLUActivation,\\n tanh=TanhActivation,\\n linear=LinearActivation)\\n\\n #### PART G ####\\n activation_func = activations[activation]\\n model = Model(X.shape[1])\\n for iLayer in range(num_layers):\\n model.addLayer(DenseLayer(num_neurons, activation_func()))\\n model.addLayer(DenseLayer(Y.shape[1], LinearActivation()))\\n model.initialize(QuadraticCost())\\n\\n # Train the model and display the results\\n # model.trainBatch(X, Y, int(iterations / 10), iterations, GDOptimizer(eta=lr))\\n model.train(X, Y, iterations, GDOptimizer(eta=lr))\\n mses = []\\n for i, X_test in enumerate(Xs_test):\\n Y_test = Ys_test[i]\\n Y_pred = model.predict((X_test - meanX) / stdX) * stdY + meanY\\n mse = np.mean(np.sqrt(np.sum((Y_pred - Y_test) ** 2, axis=1)))\\n mses.append(mse)\\n return mses\",\n \"def makeOptimizationStep(modelNet, targetNet, gameMemory, optimizer):\\n statesBatch, actionsBatch, nextStatesBatch, rewardsBatch, terminalMask = gameMemory.getBatch()\\n currentQValues = modelNet(statesBatch).gather(1, actionsBatch.unsqueeze(1))\\n nextQValues = targetNet(nextStatesBatch).max(1)[0].detach()\\n nextQValues[terminalMask == 1] = 0\\n expectedQValues = rewardsBatch + nextQValues * DISCOUNT_FACTOR\\n expectedQValues = torch.tensor(expectedQValues).unsqueeze(1).to(DEVICE)\\n loss = F.smooth_l1_loss(currentQValues, expectedQValues)\\n optimizer.zero_grad()\\n loss.backward()\\n for param in modelNet.parameters():\\n param.grad.data.clamp_(-1, 1)\\n optimizer.step()\",\n \"def neural_network(X, Y, Xs_test, Ys_test):\\n ## YOUR CODE HERE\\n #################\\n return 0\",\n \"def nnObjFunction(params, *args):\\r\\n \\r\\n\\r\\n \\r\\n n_input, n_hidden, n_class, training_data, training_label, lambdaval = args\\r\\n w1 = params[0:n_hidden * (n_input + 1)].reshape( (n_hidden, (n_input + 1)))\\r\\n w2 = params[(n_hidden * (n_input + 1)):].reshape((n_class, (n_hidden + 1)))\\r\\n\\r\\n\\r\\n rowsToChange=xrange(len(training_label))\\r\\n \\r\\n oneKEncoding = np.zeros((len(training_label),10))\\r\\n \\r\\n for x,y in izip(rowsToChange,training_label):\\r\\n oneKEncoding[x,int(y)]=1\\r\\n \\r\\n training_label=oneKEncoding\\r\\n\\r\\n trans_w1=w1.T\\r\\n trans_w2=w2.T\\r\\n \\r\\n #add bias 1\\r\\n x=np.column_stack((training_data,np.ones(len(training_data))))\\r\\n #equation1\\r\\n eq1=np.dot(x,trans_w1)\\r\\n #equation 2\\r\\n z=sigmoid(eq1)\\r\\n #add bias 1\\r\\n z=np.column_stack((z,np.ones(len(z))))\\r\\n #equation 3\\r\\n eq3=np.dot(z,trans_w2)\\r\\n #equation 4\\r\\n o=sigmoid(eq3)\\r\\n\\r\\n #-----------------------------------------Calculations for gradient weight vector 2---------------------------------------------\\r\\n \\r\\n delta=np.subtract(o,training_label)\\r\\n eq5=np.sum(np.square(delta))\\r\\n\\r\\n dabba=(training_label-o)*(1-o)*o\\r\\n \\r\\n grad_w2=np.multiply(-1,np.dot(dabba.T,z)) \\r\\n \\r\\n\\r\\n #-----------------------------------------Calculations for gradient weight vector 1---------------------------------------------\\r\\n\\r\\n one_minus_z_into_z = (1-z)*z\\r\\n \\r\\n \\r\\n multiply_by_summation = one_minus_z_into_z*np.dot(dabba,w2)\\r\\n \\r\\n grad_w1_without_minus_one = np.dot(np.transpose(multiply_by_summation),x)\\r\\n \\r\\n\\r\\n grad_w1=np.multiply(-1,grad_w1_without_minus_one)\\r\\n \\r\\n grad_w1 = np.delete(grad_w1, n_hidden,0) \\r\\n \\r\\n\\r\\n #-----------------------------------------Calculations for gradient object value----------------------------------------\\r\\n\\r\\n \\r\\n obj_val=eq5/len(training_data)\\r\\n \\r\\n #-----------------------------------------Regularization of gradient val and weight vector-------------------------------\\r\\n \\r\\n obj_val = obj_val+ (lambdaval/(2*len(training_data)))*( np.sum(np.square(w1)) + np.sum(np.square(w2)))\\r\\n grad_w2 = (grad_w2 + lambdaval*w2 )/ len(training_data) \\r\\n grad_w1 = (grad_w1 + lambdaval*w1 )/ len(training_data) \\r\\n \\r\\n \\r\\n\\r\\n #-----------------------------------------Concatenate both the weight vectors---------------------------------------------\\r\\n\\r\\n obj_grad = np.array([])\\r\\n obj_grad = np.concatenate((grad_w1.flatten(), grad_w2.flatten()),0)\\r\\n return (obj_val,obj_grad)\",\n \"def compute_cost_derivative(AL, Y):\\n pass\",\n \"def softmaxCostAndGradient(predicted, target, outputVectors, dataset):\\n\\n ### YOUR CODE HERE\\n scores = outputVectors.dot(predicted.T) # shape = (V, 1)\\n y_hat = softmax(scores)\\n cost = -scores[target] + np.log(np.sum(np.exp(scores)))\\n one_hot_target = np.zeros_like(y_hat)\\n one_hot_target[target] = 1\\n grad = np.outer((y_hat - one_hot_target), predicted)\\n gradPred = outputVectors.T.dot(y_hat - one_hot_target)\\n \\n '''\\n final_predicted = predicted.dot(outputVectors.T)\\n probability = softmax(final_predicted)\\n cost = -np.log(probability[target])\\n \\n one_hot_target = np.zeros_like(probability)\\n one_hot_target[target] += 1\\n dlogits = probability - one_hot_target\\n grad = np.outer(predicted, dlogits).T\\n gradPred = outputVectors.T.dot(dlogits)\\n '''\\n ### END YOUR CODE\\n\\n return cost, gradPred, grad\",\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 get_reconstruction_cost(self, updates, pre_sigmoid_nv):\\r\\n\\r\\n cross_entropy = T.mean(\\r\\n T.sum(self.input * T.log(T.nnet.sigmoid(pre_sigmoid_nv)) +\\r\\n (1 - self.input) * T.log(1 - T.nnet.sigmoid(pre_sigmoid_nv)),\\r\\n axis=1))\\r\\n\\r\\n return cross_entropy\",\n \"def fit(self):\\n accuracy = 0\\n no_improvement = 0\\n epochs = trange(self.args.epochs, desc=\\\"Accuracy\\\")\\n self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.args.learning_rate)\\n self.model.train()\\n for epoch in epochs:\\n self.optimizer.zero_grad()\\n prediction = self.model(self.propagation_matrix, self.features)\\n loss = torch.nn.functional.nll_loss(prediction[self.train_nodes], self.target[self.train_nodes])\\n loss = loss + self.args.lambd*torch.sum(self.model.page_rank_convolution_1.weight_matrix**2)\\n loss.backward()\\n self.optimizer.step()\\n new_accuracy = self.score(self.validation_nodes)\\n epochs.set_description(\\\"Validation Accuracy: %g\\\" % round(new_accuracy,4))\\n if new_accuracy < accuracy:\\n no_improvement = no_improvement + 1\\n if no_improvement == self.args.early_stopping:\\n epochs.close()\\n break\\n else:\\n no_improvement = 0\\n accuracy = new_accuracy \\n acc = self.score(self.test_nodes)\\n print(\\\"\\\\nTest accuracy: \\\" + str(round(acc,4)) )\",\n \"def direct_solve_least_square(policy, triple_pi_count, grad_log, state_list, tb_illustration):\\n w_approxi = [torch.randn(count_parameters(policy), device= \\\"cuda\\\", requires_grad = True) for i in range(6)]\\n lr = 1e-4\\n if tb_illustration:\\n sum_record = []\\n for time_step in range(50):\\n if time_step % 25 == 0:\\n lr /= 5\\n sum = torch.tensor(0., device= \\\"cuda\\\")\\n for i in range(triple_pi_count[1].shape[0]):\\n s_previous = triple_pi_count[0][i][0]\\n action = triple_pi_count[0][i][1]\\n s_later = triple_pi_count[0][i][2]\\n n = triple_pi_count[1][i]\\n sum = sum.add(n * torch.norm(w_approxi[s_later] - w_approxi[s_previous] - grad_log[s_previous][action])**2)\\n sum.backward()\\n if tb_illustration:\\n sum_record.append(sum.cpu().item())\\n w_approxi = [(j - lr * j.grad).detach().requires_grad_() for j in w_approxi]\\n if tb_illustration:\\n plt.plot(sum_record)\\n tensorboard.add_figure(\\\"least square\\\", plt.gcf())\\n with torch.no_grad():\\n #w_approxi here is correct only on difference between each other, but its value is not fixed\\n w_approxi_r = [(i - w_approxi[0]) for i in w_approxi]\\n\\n # get the distribution from trajectory, sort is for keeping the order\\n state_, count_ = np.unique(np.sort(state_list), return_counts= True)\\n state_count = np.zeros(6)\\n for state, count in zip(state_,count_):\\n state_count[state] = count\\n state_distribution = state_count / np.sum(state_count)\\n\\n w_approxi_0 = - torch.sum(torch.stack([w_approxi_r[i] * state_distribution[i] for i in range(6)]), dim = 0)\\n w_approxi_result = [(i + w_approxi_0).cuda() for i in w_approxi_r]\\n\\n return w_approxi_result\",\n \"def build_network(self, dimList, actType=\\\"Tanh\\\", verbose=True):\\n self.Q_network = Model(dimList, actType, verbose=verbose)\\n self.target_network = Model(dimList, actType)\\n\\n if self.device == torch.device(\\\"cuda\\\"):\\n self.Q_network.cuda()\\n self.target_network.cuda()\\n\\n self.build_optimizer()\",\n \"def vis_d():\\n \\n data_gen = generator(fixed_noise)\\n# loss = d_loss(discriminator(data_gen), discriminator(grid))\\n loss = g_loss(discriminator(grid))\\n loss.backward()\\n \\n grads = - grid.grad.data.numpy()\\n grid.grad.data *= 0 \\n plt.quiver(X_grid, Y_grid, grads[:, 0], grads[:, 1], color='black',alpha=0.9)\",\n \"def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):\\n \\n # initialize parameters with zeros (≈ 1 line of code)\\n w, b = initialize_with_zeros(X_train.shape[0]) # 维度应该是X_train.shape[0] \\n\\n # Gradient descent (≈ 1 line of code)\\n parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)\\n \\n # Retrieve parameters w and b from dictionary \\\"parameters\\\"\\n w = parameters[\\\"w\\\"]\\n b = parameters[\\\"b\\\"]\\n \\n # Predict test/train set examples (≈ 2 lines of code)\\n Y_prediction_test = predict(w, b, X_test)\\n Y_prediction_train = predict(w, b, X_train)\\n\\n ### END CODE HERE ###\\n\\n # Print train/test Errors\\n print(\\\"train accuracy: {} %\\\".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))\\n print(\\\"test accuracy: {} %\\\".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))\\n\\n \\n d = {\\\"costs\\\": costs,\\n \\\"Y_prediction_test\\\": Y_prediction_test, \\n \\\"Y_prediction_train\\\" : Y_prediction_train, \\n \\\"w\\\" : w, \\n \\\"b\\\" : b,\\n \\\"learning_rate\\\" : learning_rate,\\n \\\"num_iterations\\\": num_iterations}\\n \\n return d\",\n \"def cost(self, output, labels, weights):\\n raise NotImplementedError('Must be overridden by concrete subclass')\",\n \"def __init__(self, input_size, output_size, hidden_sizes=[],\\r\\n learning_rate=2.0, weight_scale=0.1, converge=0.01,\\r\\n random_seed=None):\\r\\n if random_seed is not None:\\r\\n seed(random_seed)\\r\\n\\r\\n weight_func = partial(normal, 0, weight_scale)\\r\\n self.converge = converge\\r\\n self.layers = []\\r\\n self.layers.append([InputNode(\\\"in_\\\" + str(i)) for i in range(input_size)])\\r\\n for i,layer_size in enumerate(hidden_sizes):\\r\\n self.layers.append([SigmoidNode(\\\"hidden_\\\"+str(i)+\\\"-\\\"+str(j),\\r\\n learning_rate) for j in range(layer_size)])\\r\\n self.layers.append([SigmoidNode(\\\"out_\\\"+str(i), learning_rate) for i\\r\\n in range(output_size)])\\r\\n\\r\\n # densely connect consecutive layers\\r\\n for source_layer, dest_layer in zip(self.layers, self.layers[1:]):\\r\\n for source, dest in product(source_layer, dest_layer):\\r\\n edge = Edge(source, dest, weight_func)\\r\\n source.out_edges.append(edge)\\r\\n dest.in_edges.append(edge)\\r\\n\\r\\n # connect each node to bias\\r\\n self.bias = BiasNode()\\r\\n for layer in self.layers[1:]:\\r\\n for node in layer:\\r\\n e = Edge(self.bias, node, weight_func)\\r\\n node.in_edges.append(e)\\r\\n self.bias.out_edges.append(e)\",\n \"def solve(num_wizards, num_constraints, wizards, constraints):\\n\\n # print(num_wizards)\\n # print(num_constraints)\\n # print(wizards)\\n # print(constraints)\\n # node_set = set(wizards)\\n \\n\\n\\n def cost(sol,num_constraints,constraints):\\n constraints_satisfied = 0\\n constraints_failed = []\\n output_ordering_map = {k: v for v, k in enumerate(sol)}\\n for c in constraints:\\n\\n m = output_ordering_map # Creating an alias for easy reference\\n\\n wiz_a = m[c[0]]\\n wiz_b = m[c[1]]\\n wiz_mid = m[c[2]]\\n\\n if (wiz_a < wiz_mid < wiz_b) or (wiz_b < wiz_mid < wiz_a):\\n constraints_failed.append(c)\\n else:\\n constraints_satisfied += 1\\n return num_constraints - constraints_satisfied\\n\\n def neighbors(sol):\\n wiz1 = random.randint(0,num_wizards-1)\\n wiz2 = random.randint(0,num_wizards-1)\\n\\n new_sol = copy.copy(sol)\\n temp = new_sol[wiz1]\\n new_sol[wiz1] = new_sol[wiz2]\\n new_sol[wiz2] = temp\\n \\n return new_sol\\n\\n def acceptance_probability(old_cost,new_cost,T):\\n exponent = (old_cost - new_cost) / T\\n \\n try:\\n ans = math.exp(exponent)\\n except OverflowError:\\n ans = float('inf')\\n return ans\\n\\n\\n def anneal(solution, num_constraints, constraints):\\n old_cost = 0\\n new_cost = 0\\n old_cost = cost(solution,num_constraints,constraints)\\n T = 1.0\\n T_min = 0.000001\\n alpha = 0.98\\n while T > T_min:\\n i = 1\\n while i <= 1000:\\n new_solution = neighbors(solution)\\n new_cost = cost(new_solution,num_constraints,constraints)\\n if new_cost == 0:\\n return new_solution,new_cost\\n ap = acceptance_probability(old_cost, new_cost, T)\\n if ap > random.random():\\n solution = new_solution\\n old_cost = new_cost\\n i += 1\\n T = T*alpha\\n return solution, old_cost\\n\\n s = copy.copy(wizards)\\n random.shuffle(s)\\n ret = anneal(s,num_constraints,constraints)\\n \\n for i in range(10):\\n if ret[1] == 0:\\n break\\n random.shuffle(s)\\n new_ret = anneal(s,num_constraints,constraints)\\n print(i)\\n if new_ret[1] < ret[1]:\\n ret = new_ret\\n print(\\\"constraints failed: {0}\\\".format(ret[1]))\\n return ret[0]\",\n \"def get_reconstruction_cost(self, pre_sigmoid_nv):\\n y = self.input\\n a = T.nnet.sigmoid(pre_sigmoid_nv)\\n\\n cross_entropy = -T.mean(\\n T.sum(y * T.log(a) + (1 - y) * T.log(1 - a), axis=1)\\n )\\n\\n return cross_entropy\",\n \"def train(self, epochs = 100, n_input = 10, n_hidden = 40,\\n hidden_learning_rate = 0.1, output_learning_rate = 0.1, momentum_learning_rate = 0.9,\\n test_size=0.2, cv=3):\\n\\n # Initialize variables\\n self.n_input = n_input\\n self.n_hidden = n_hidden\\n self.hidden_learning_rate = hidden_learning_rate\\n self.output_learning_rate = output_learning_rate\\n self.momentum_learning_rate = momentum_learning_rate\\n\\n self.n_output = len(unique(self.targets))\\n self.V_hidden = zeros((self.n_input + 1, self.n_hidden))\\n self.W_hidden = random_sample(self.V_hidden.shape)\\n self.V_output = zeros((self.n_hidden + 1, self.n_output))\\n self.W_output = random_sample(self.V_output.shape)\\n\\n data = self.dataset.data\\n\\n # Split into training and test\\n X_train, X_test, y_train, y_test = train_test_split(data, self.targets, test_size=test_size)\\n\\n # Preprocess the data using PCA\\n self.pca = PCA(n_components = self.n_input, whiten=True, copy=True)\\n X_train = self.pca.fit_transform(X_train)\\n X_test = self.pca.transform(X_test)\\n self.X = self.pca.transform(data)\\n\\n # Start the training\\n rmse=zeros((epochs,2))\\n cerr=zeros((epochs,2))\\n for t in arange(epochs):\\n\\n # Test then Train, since we'll use the training errors\\n for i, (inputs, y) in enumerate([[X_test, y_test], [X_train, y_train]]):\\n outputs, hidden = self.feed_forward(inputs)\\n target=ones(outputs.shape)*(-1.0)\\n target[arange(target.shape[0]),y]=1.0\\n errors = target - outputs\\n rmse[t, i] = sqrt((errors**2).mean()) # RMSE\\n cerr[t, i] = (y != argmax(outputs,axis=1)).mean()\\n\\n yield rmse, cerr, t, epochs\\n\\n # Update weights using backpropagation\\n self.back_propagate(inputs, hidden, outputs, errors)\",\n \"def evaluate_viz_metrics(y_emb, dataset, verbose=1):\\n results = {}\\n\\n # results[\\\"trust\\\"] = trustworthiness(dataset.inputs, y_emb, n_neighbors=5, metric=distance_metric)\\n results[\\\"One NN accuracy\\\"] = nearest_neighbours_generalisation_accuracy(y_emb, dataset.labels, 1)\\n results[\\\"Avg graph distance\\\"], results[\\\"Avg feature distance\\\"] = combined_dist_metric(y_emb, dataset.inputs, dataset.adj_matrix, k=5)\\n results['Total distance'] = results[\\\"Avg graph distance\\\"] + results[\\\"Avg feature distance\\\"]\\n\\n if verbose:\\n for k, v in results.items():\\n print(\\\"{} = {:.4f}\\\".format(k, v))\\n return results\",\n \"def add_pseudo_cost_measure(self): \\n \\n node_index = theano.shared(value=0, name='node_index')\\n\\n x_bin = T.round(self.x)\\n \\n # flip node x_i of matrix x_bin and preserve all other bits x_{\\\\i}\\n # Equivalent to x_bin[:, node_index] = 1-x_bin[:, node_index], but assigns\\n # the result to x_bin_flip_i, instead of working in place on x_bin\\n x_bin_flip_i = T.set_subtensor(x_bin[:, node_index], 1- x_bin[:, node_index])\\n \\n if self.num_hidden ==0:\\n \\n fe_x_bin = self.compute_energy(x_bin, self.batch_size)\\n \\n fe_x_bin_flip_i = self.compute_energy(x_bin_flip_i, self.batch_size)\\n \\n else:\\n \\n fe_x_bin = self.compute_free_energy(x_bin)\\n \\n fe_x_bin_flip_i = self.compute_free_energy(x_bin_flip_i)\\n \\n # mean(input dimension * log P ( xi | {x -i} ):\\n self.pseudo_cost = T.mean(self.num_vars *\\\\\\n T.log(T.nnet.sigmoid(fe_x_bin_flip_i- fe_x_bin)))\\n\\n # increment bit_i_idx % number as part of updates\\n self.updates[node_index] = (node_index + 1) % self.num_vars\",\n \"def main():\\n # Load database\\n (images_train, targets_train), (images_test, targets_test) = tf.keras.datasets.mnist.load_data()\\n\\n # Normalization\\n images_train = images_train.reshape(-1, 784).astype(float)\\n scaler = StandardScaler()\\n images_train = scaler.fit_transform(images_train)\\n images_test = images_test.reshape(-1, 784).astype(float)\\n images_test = scaler.transform(images_test)\\n\\n images_train = images_train.reshape(-1, 28, 28, 1).astype(float)\\n images_test = images_test.reshape(-1, 28, 28, 1).astype(float)\\n\\n # One hot encoding\\n targets_train = tf.keras.utils.to_categorical(targets_train)\\n targets_test = tf.keras.utils.to_categorical(targets_test)\\n\\n # Network architecture\\n model = tf.keras.models.Sequential()\\n model.add(tf.keras.layers.Conv2D(30, (5, 5), input_shape=(28, 28, 1), \\\\\\n activation=\\\"relu\\\", padding='same'))\\n model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))\\n model.add(tf.keras.layers.Conv2D(15, (3, 3), activation=\\\"relu\\\", padding='same'))\\n model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))\\n model.add(tf.keras.layers.Flatten())\\n model.add(tf.keras.layers.Dense(128, activation=\\\"relu\\\"))\\n model.add(tf.keras.layers.Dense(50, activation=\\\"relu\\\"))\\n model.add(tf.keras.layers.Dense(10, activation=\\\"softmax\\\"))\\n\\n # Learn\\n optimizer = tf.keras.optimizers.SGD()\\n\\n @tf.function\\n def train_step(images, targets):\\n \\\"\\\"\\\"\\n Define the training step by step\\n \\\"\\\"\\\"\\n # Save all operations\\n with tf.GradientTape() as tape:\\n # Make prediction\\n predictions = model(images)\\n # Compute loss\\n loss = tf.keras.losses.categorical_crossentropy(targets, predictions)\\n # Compute gradients\\n gradients = tape.gradient(loss, model.trainable_variables)\\n # Update model\\n optimizer.apply_gradients(zip(gradients, model.trainable_variables))\\n\\n batch_size = 32\\n epochs = 10\\n images_per_epoch = len(images_train) // batch_size\\n for _ in range(epochs):\\n for i in range(images_per_epoch):\\n start = i*batch_size\\n train_step(images_train[start:start+batch_size], targets_train[start:start+batch_size])\\n\\n # Compile must be defined to use evaluate method\\n model.compile(\\n loss=\\\"categorical_crossentropy\\\",\\n optimizer=\\\"sgd\\\",\\n metrics=[\\\"accuracy\\\"])\\n\\n # Evaluate on the test database\\n scores = model.evaluate(images_test, targets_test, verbose=0)\\n print(scores)\",\n \"def _generateNetwork(self, n_actions, obs_space):\\r\\n \\r\\n import tensorflow as tf \\r\\n self._ALPHA = 1e-3 # learning rate \\r\\n RESIZED_SCREEN = 84\\r\\n self._STATE_FRAMES = 3 # states/images used for taking a decision\\r\\n \\r\\n # Graph for compressing the input image \\r\\n x, y, z = obs_space\\r\\n self._image_input_layer = tf.placeholder(\\\"float\\\", \\r\\n [None, x, y, z])\\r\\n image_step_size_x = int(np.ceil(float(x / RESIZED_SCREEN)))\\r\\n image_step_size_y = int(np.ceil(float(y / RESIZED_SCREEN)))\\r\\n extra_pad_x = RESIZED_SCREEN - int(x / image_step_size_x)\\r\\n extra_pad_y = RESIZED_SCREEN - int(y / image_step_size_y)\\r\\n self._image_output_layer = tf.nn.max_pool(\\r\\n self._image_input_layer, \\r\\n ksize=[1, image_step_size_x, image_step_size_y, 1],\\r\\n strides=[1, image_step_size_x, image_step_size_y, 1], \\r\\n padding=\\\"VALID\\\") \\r\\n \\r\\n # Function for compressing (and reshaping) the image\\r\\n self._compressImage = lambda obs : np.pad(\\r\\n self._session.run(\\r\\n self._image_output_layer, \\r\\n feed_dict={self._image_input_layer: np.array([obs])})/255.0, \\r\\n ((0,0), (0,extra_pad_x), (0,extra_pad_y), (0,0)),\\r\\n mode='constant') \\r\\n\\r\\n CONVOLUTION_FILTER_VECTOR = [6, 6, 4]\\r\\n CONVOLUTION_STRIDE_VECTOR = [3, 3, 2]\\r\\n CONVOLUTION_KERNEL_VECTOR = [16, 16, 36]\\r\\n CONVOLUTION_INPUT_VECTOR = ([z * self._STATE_FRAMES] + \\r\\n CONVOLUTION_KERNEL_VECTOR[:-1])\\r\\n FEED_FWD_VECTOR = [(3**2) * CONVOLUTION_KERNEL_VECTOR[-1], 64, \\r\\n n_actions] \\r\\n \\r\\n # The chosen activation function is the Leaky ReLU function\\r\\n self._activation = lambda x : tf.maximum(0.01*x, x)\\r\\n\\r\\n \\r\\n # Initialization parameters\\r\\n INITIALIZATION_STDDEV = 0.1\\r\\n INITIALIZATION_MEAN = 0.00\\r\\n INITIALIZATION_BIAS = -0.001\\r\\n\\r\\n # Convolutional layers\\r\\n self._input_layer = tf.placeholder(\\\"float\\\", \\r\\n [None, \\r\\n RESIZED_SCREEN, \\r\\n RESIZED_SCREEN, \\r\\n z * self._STATE_FRAMES])\\r\\n self._convolutional_weights = []\\r\\n self._convolutional_bias = []\\r\\n self._hidden_convolutional_layer = [self._input_layer]\\r\\n\\r\\n for i in range(len(CONVOLUTION_FILTER_VECTOR)):\\r\\n self._convolutional_weights.append(tf.Variable(tf.truncated_normal(\\r\\n [CONVOLUTION_FILTER_VECTOR[i], \\r\\n CONVOLUTION_FILTER_VECTOR[i], \\r\\n CONVOLUTION_INPUT_VECTOR[i], \\r\\n CONVOLUTION_KERNEL_VECTOR[i]], \\r\\n mean=INITIALIZATION_MEAN, \\r\\n stddev=INITIALIZATION_STDDEV)))\\r\\n self._convolutional_bias.append(tf.Variable(tf.constant(\\r\\n INITIALIZATION_BIAS, \\r\\n shape=[CONVOLUTION_KERNEL_VECTOR[i]])))\\r\\n self._hidden_convolutional_layer.append(\\r\\n self._activation(tf.nn.conv2d(\\r\\n self._hidden_convolutional_layer[i], \\r\\n self._convolutional_weights[i], \\r\\n strides=[1, \\r\\n CONVOLUTION_STRIDE_VECTOR[i],\\r\\n CONVOLUTION_STRIDE_VECTOR[i], \\r\\n 1], \\r\\n padding=\\\"VALID\\\") \\r\\n + self._convolutional_bias[i]))\\r\\n \\r\\n # Feed forward layers\\r\\n self._hidden_activation_layer = [tf.reshape(\\r\\n self._hidden_convolutional_layer[-1], \\r\\n [-1, FEED_FWD_VECTOR[0]])]\\r\\n self._feed_forward_weights = []\\r\\n self._feed_forward_bias = []\\r\\n\\r\\n for i in range(len(FEED_FWD_VECTOR) - 2):\\r\\n self._feed_forward_weights.append(tf.Variable(tf.truncated_normal(\\r\\n [FEED_FWD_VECTOR[i], \\r\\n FEED_FWD_VECTOR[i+1]], \\r\\n mean=INITIALIZATION_MEAN, \\r\\n stddev=INITIALIZATION_STDDEV)))\\r\\n self._feed_forward_bias.append(tf.Variable(tf.constant(\\r\\n INITIALIZATION_BIAS, shape=[FEED_FWD_VECTOR[i+1]])))\\r\\n self._hidden_activation_layer.append(self._activation(\\r\\n tf.matmul(self._hidden_activation_layer[i], \\r\\n self._feed_forward_weights[i]) \\r\\n + self._feed_forward_bias[i])\\r\\n )\\r\\n \\r\\n # The calculation of the state-action value function does not \\r\\n # require the neurons' activation function\\r\\n self._feed_forward_weights.append(tf.Variable(tf.truncated_normal(\\r\\n [FEED_FWD_VECTOR[-2], \\r\\n FEED_FWD_VECTOR[-1]], \\r\\n mean=INITIALIZATION_MEAN, \\r\\n stddev=INITIALIZATION_STDDEV)))\\r\\n self._feed_forward_bias.append(tf.Variable(tf.constant(\\r\\n INITIALIZATION_BIAS, \\r\\n shape=[FEED_FWD_VECTOR[-1]])))\\r\\n self._state_value_layer = (tf.matmul(self._hidden_activation_layer[-1], \\r\\n self._feed_forward_weights[-1]) \\r\\n + self._feed_forward_bias[-1])\\r\\n\\r\\n # Define the logic of the optimization\\r\\n self._action = tf.placeholder(\\\"float\\\", [None, n_actions])\\r\\n self._target = tf.placeholder(\\\"float\\\", [None])\\r\\n self._action_value_vector = tf.reduce_sum(tf.mul(\\r\\n self._state_value_layer, self._action), reduction_indices=1)\\r\\n self._cost = tf.reduce_sum(tf.square(\\r\\n self._target - self._action_value_vector))\\r\\n self._alpha = tf.placeholder('float')\\r\\n self._train_operation = tf.train.AdamOptimizer(\\r\\n self._alpha).minimize(self._cost)\\r\\n self._session = tf.Session()\\r\\n\\r\\n operation_intizializer = tf.initialize_all_variables()\\r\\n self._saver = tf.train.Saver()\\r\\n\\r\\n try:\\r\\n self._saver.restore(self._session, self._PARAMETERS_FILE_PATH)\\r\\n print ('Calibrated parameters SUCCESSFULLY LOADED.',\\r\\n flush=True)\\r\\n except:\\r\\n self._session.run(operation_intizializer)\\r\\n print ('It was not possible to load calibrated parameters.',\\r\\n flush=True)\\r\\n \\r\\n # Definition of feed_forward and optimization functions\\r\\n self._feedFwd = lambda state : self._session.run(\\r\\n self._state_value_layer, \\r\\n feed_dict={self._input_layer: state})\\r\\n \\r\\n self._backProp = lambda valueStates, actions, valueTarget : (\\r\\n self._session.run(self._train_operation, \\r\\n feed_dict={self._input_layer: valueStates,\\r\\n self._action: actions,\\r\\n self._target: valueTarget,\\r\\n self._alpha : self._ALPHA}))\",\n \"def optimize(w, b, X, Y, num_iterations=100, learning_rate=0.009, print_cost=False):\\n w = copy.deepcopy(w)\\n b = copy.deepcopy(b)\\n\\n costs = []\\n\\n for i in range(num_iterations):\\n grads, cost = propagate(w, b, X, Y)\\n dw = grads[\\\"dw\\\"]\\n db = grads[\\\"db\\\"]\\n w = w - learning_rate * dw\\n b = b - learning_rate * db\\n\\n if i % 100 == 0:\\n costs.append(cost)\\n if print_cost:\\n print(\\\"Cost after iteration %i: %f\\\" % (i, cost))\\n\\n params = {\\\"w\\\": w, \\\"b\\\": b}\\n\\n grads = {\\\"dw\\\": dw, \\\"db\\\": db}\\n\\n return params, grads, costs\",\n \"def transform(self):\\n self.validate_ports()\\n\\n # TODO: Find a more reusable way of enforcing this behavior.\\n if self.cost_sim.variable.ndim != 1:\\n raise ValueError(\\\"`cost_sim` must be a vector.\\\")\\n\\n if self.cost_diff.variable.ndim != 1:\\n raise ValueError(\\\"`cost_diff` must be a vector.\\\")\\n\\n cost_sim = self.cost_sim.variable\\n cost_diff = self.cost_diff.variable\\n alpha = self.alpha.variable\\n margin = self.margin.variable\\n\\n cost = cost_diff - alpha * cost_sim + margin\\n self.output.variable = T.mean(T.pow(functions.relu(cost), 2.0))\",\n \"def grid_search(verbose):\\n\\n # Load Ising data.\\n Ising_Data = prepare_Ising_DNN()\\n\\n # Perform grid search over learning rate and number of hidden neurons.\\n N_neurons=np.logspace(0,3,4).astype(\\\"int\\\") # Check number of neurons over multiple decades.\\n learning_rates=np.logspace(-6,-1,6)\\n\\n # Pre-allocate variables to store accuracy and loss data.\\n train_loss=np.zeros((len(N_neurons),len(learning_rates)),dtype=np.float64)\\n train_accuracy=np.zeros_like(train_loss)\\n test_loss=np.zeros_like(train_loss)\\n test_accuracy=np.zeros_like(train_loss)\\n critical_loss=np.zeros_like(train_loss)\\n critical_accuracy=np.zeros_like(train_loss)\\n\\n # Grid search.\\n for i, neurons in enumerate(N_neurons):\\n for j, lr in enumerate(learning_rates):\\n\\n print(\\\"training DNN with %4d neurons and SGD lr=%0.6f.\\\" %(neurons,lr) )\\n\\n train_loss[i,j],train_accuracy[i,j],\\\\\\n test_loss[i,j],test_accuracy[i,j],\\\\\\n critical_loss[i,j],critical_accuracy[i,j] = evaluate_model(neurons,lr,Ising_Data,verbose)\\n\\n plot_data(learning_rates,N_neurons,train_accuracy, \\\"training\\\")\\n plot_data(learning_rates,N_neurons,test_accuracy, \\\"testing\\\")\\n plot_data(learning_rates,N_neurons,critical_accuracy, \\\"critical\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5776294","0.5655469","0.5644679","0.5526504","0.5513294","0.55041754","0.54516816","0.5432973","0.5399264","0.5386139","0.5346754","0.5345675","0.5330562","0.53183424","0.5296879","0.5293629","0.52837807","0.52808344","0.52775186","0.52714753","0.52682304","0.5267683","0.52669","0.52438265","0.52404034","0.5238766","0.5236601","0.5236525","0.5235291","0.5233743","0.5231132","0.5227724","0.5222833","0.5220453","0.5202999","0.52012986","0.5199203","0.5198356","0.5189462","0.51731944","0.5171738","0.5164104","0.5152386","0.51499444","0.5149153","0.51463944","0.51451963","0.51441497","0.51302373","0.5127953","0.51238984","0.51182884","0.51121175","0.51089036","0.51019806","0.50998014","0.5086956","0.5082832","0.50804293","0.50730735","0.50699955","0.5065687","0.50629956","0.5061552","0.5053332","0.5052571","0.5048808","0.5044543","0.5040285","0.5039331","0.5027124","0.5015338","0.5014653","0.50141007","0.5006609","0.5003646","0.50032276","0.50010204","0.5000809","0.49960166","0.4995233","0.49941167","0.49910066","0.49892834","0.49889326","0.49886104","0.49873325","0.4985054","0.4984839","0.49827108","0.4982533","0.49804333","0.49797165","0.4978198","0.49756306","0.497361","0.4970631","0.49647433","0.49633154","0.49631032"],"string":"[\n \"0.5776294\",\n \"0.5655469\",\n \"0.5644679\",\n \"0.5526504\",\n \"0.5513294\",\n \"0.55041754\",\n \"0.54516816\",\n \"0.5432973\",\n \"0.5399264\",\n \"0.5386139\",\n \"0.5346754\",\n \"0.5345675\",\n \"0.5330562\",\n \"0.53183424\",\n \"0.5296879\",\n \"0.5293629\",\n \"0.52837807\",\n \"0.52808344\",\n \"0.52775186\",\n \"0.52714753\",\n \"0.52682304\",\n \"0.5267683\",\n \"0.52669\",\n \"0.52438265\",\n \"0.52404034\",\n \"0.5238766\",\n \"0.5236601\",\n \"0.5236525\",\n \"0.5235291\",\n \"0.5233743\",\n \"0.5231132\",\n \"0.5227724\",\n \"0.5222833\",\n \"0.5220453\",\n \"0.5202999\",\n \"0.52012986\",\n \"0.5199203\",\n \"0.5198356\",\n \"0.5189462\",\n \"0.51731944\",\n \"0.5171738\",\n \"0.5164104\",\n \"0.5152386\",\n \"0.51499444\",\n \"0.5149153\",\n \"0.51463944\",\n \"0.51451963\",\n \"0.51441497\",\n \"0.51302373\",\n \"0.5127953\",\n \"0.51238984\",\n \"0.51182884\",\n \"0.51121175\",\n \"0.51089036\",\n \"0.51019806\",\n \"0.50998014\",\n \"0.5086956\",\n \"0.5082832\",\n \"0.50804293\",\n \"0.50730735\",\n \"0.50699955\",\n \"0.5065687\",\n \"0.50629956\",\n \"0.5061552\",\n \"0.5053332\",\n \"0.5052571\",\n \"0.5048808\",\n \"0.5044543\",\n \"0.5040285\",\n \"0.5039331\",\n \"0.5027124\",\n \"0.5015338\",\n \"0.5014653\",\n \"0.50141007\",\n \"0.5006609\",\n \"0.5003646\",\n \"0.50032276\",\n \"0.50010204\",\n \"0.5000809\",\n \"0.49960166\",\n \"0.4995233\",\n \"0.49941167\",\n \"0.49910066\",\n \"0.49892834\",\n \"0.49889326\",\n \"0.49886104\",\n \"0.49873325\",\n \"0.4985054\",\n \"0.4984839\",\n \"0.49827108\",\n \"0.4982533\",\n \"0.49804333\",\n \"0.49797165\",\n \"0.4978198\",\n \"0.49756306\",\n \"0.497361\",\n \"0.4970631\",\n \"0.49647433\",\n \"0.49633154\",\n \"0.49631032\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.54288465"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":84780,"cells":{"query":{"kind":"string","value":"Function that computes the cost value for a given x"},"document":{"kind":"string","value":"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"},"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 costFun(self, S, x):","def cost(self,x):\n Mx = self.generate_vector()\n self.prior.M.mult(x,Mx)\n return .5*Mx.inner(x)","def final_cost(self, x):\n return self.x_M_x(x[-1,:,:],self.R)","def fn(x):\n if x == 0: return 0\n if x < 0: return -inf \n return max(fn(x - c) * 10 + i + 1 for i, c in enumerate(cost))","def cost(self) -> float:","def c(x):\n cost = per_widget_cost * x + fixed_cost\n return cost","def costFunction(self, x, y ):\n self.yEst = self.forward_propagate(x)\n sqErrors = ( self.yEst - y ) ** 2\n J = sqErrors.sum() / 2\n return J","def __compute_cost(self, x, y):\n\n predictions = self.__compute_prediction(x)\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\n\n return cost","def compute_cost(AL, Y):\n pass","def cost_fun(x, problem):\n j = 0\n if problem['use_log_bar']:\n c = ineqconstr(x, problem)\n j += np.sum(logbarrierfunc(0.1, c, problem['use_sigma']))\n\n x, t_final = matrify(x, problem)\n if problem['T']!=0:\n j += np.sum([problem['cost_fun_single'](x[:, :, i], t_final, problem) for i in range(problem['Nv'])])\n else:\n j = t_final\n return j","def compute_cost(AL, Y):\n pass","def calculate_cost(x, y, weights):\r\n predictions = compute_prediction(x, weights)\r\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\r\n return cost","def objective_function(x):\n return x * 1 # change this to our actual function","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 cost_function(self, element):\n return self.maze.cost(element)","def get_cost(self) -> float:\n return math.e / self.fitness","def objective(self, x):\n pass","def objective(self, x):\n pass","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 get_cost(self, action: Action) -> N:\n pass","def calcCostFun(self):\n\n self.start()\n F, K = self.model()\n \n return self.costFunction","def calc_cost(y, x, theta_1, theta_0):\n h = theta_1 * x + theta_0\n d = h - y\n cost = np.dot(d.T, d) / (2*x.shape[0])\n return cost.flat[0]","def _cost(self, X, particle):\n startprob, transmat = self._parse_particle(particle)\n startprob, transmat = self._shape_probs(startprob, transmat)\n return -self._compute_logprob(X, startprob, transmat, **self._params)","def compute_cost(x, y, theta=[[0], [0]]):\n m = y.size\n h = x.dot(theta)\n j = 1 / (2 * m) * np.sum(np.square(h - y))\n return j","def _cost_method(self, *args, **kwargs):\n\n cost_val = 0.5 * np.linalg.norm(self.obs_data - self.op(args[0])) ** 2\n\n if 'verbose' in kwargs and kwargs['verbose']:\n print(' - DATA FIDELITY (X):', cost_val)\n\n return cost_val","def _call(self, x):\n tmp = x.asarray().flatten()\n return self.range.element(self.cost_matrix.dot(tmp))","def evaluate_cost(\n self, x: Dict[str, ArrayType], p: Dict[str, ArrayType]\n ) -> CasADiArrayType:\n x = self.opt.decision_variables.dict2vec(x)\n p = self.opt.parameters.dict2vec(p)\n return self.opt.f(x, p)","def calc_total_cost(self, X):\n return self.sess.run(self.cost, feed_dict={self.x: X, self.scale: self.training_scale})","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 cost_from_X(self, data):\n self.cost_from_X_data_specs()[0].validate(data)\n X, Y = data\n Y_hats= self.fprop(X)\n return self.cost(Y, Y_hats)","def cost_function (model, X, y, lambda_reg=0.):\n\n m = len (y)\n pred = model.predict (X)\n cost = 1. / (2. * m) * ((pred - y)**2).sum () + \\\n lambda_reg / (2. * m) * (model.coef_**2).sum ()\n return (cost)","def cost(self, cost_object, target):\n\n return cost_object.f(self.a[-1], target).mean(axis=0).sum()","def cost_function(self, config_samples):\n cost = self.work_tracker(config_samples)\n return cost","def calculate_total_cost(state):\r\n return state.cost()","def value(self, x):\n f = self._objective(\n time_series=self.observed_data,\n a=x[0],\n b=x[1],\n c=x[2],\n sigma=self.sigma\n )\n return f","def __call__(self, x, u, k):\n first_time_through = True\n for cost, arg, weight in zip(self._costs, self._args, self._weights):\n if arg == \"x\":\n cost_input = x\n else:\n cost_input = u[arg]\n\n current_term = weight * cost(cost_input, k)\n if current_term > 1e8:\n print(\"Warning: cost %s is %f\" % (cost._name, current_term))\n print(\"Input is: \", cost_input)\n\n# if cost._name[:4] == \"bike\":\n# print(cost._name, \": \", current_term)\n\n if first_time_through:\n total_cost = current_term\n else:\n total_cost += current_term\n\n first_time_through = False\n\n return total_cost","def compute_cost(AL,Y,cost_function_name):\n cost_functions = {\n \"cost_func_1\": cf.cost_function_1\n } \n\n activ_func = cost_functions.get(cost_function_name,lambda : \"Invalid Cost Function Name !\")\n\n cost,dAL = activ_func(AL,Y)\n\n return cost, dAL","def cost(self, data_X, data_Y):\n c = self.cost_function(data_Y, self.predict(data_X))\n\n if self.regularizer is not None:\n c += self.regularizer.cost(self.particle_input, self.layers)\n\n return c","def cost(self, X, y) :\n ### ========== TODO : START ========== ###\n # part d: compute J(theta)\n #we know for linear/polynomial regression, the cost is the square of the errors\n X = self.generate_polynomial_features(X)\n y_pred_vector = np.dot(X, self.coef_)\n cost = np.dot((y-y_pred_vector).transpose(),(y-y_pred_vector))#write in the matrix form\n ### ========== TODO : END ========== ###\n return cost","def compute_objective(X, C):\n # similar as mse\n\n acc = 0\n for x in range(len(X)):\n acc += (nearest_distance(X.iloc[x], C)) ** 2\n\n return acc","def compute_cost_function(X, Y, theta, lambda_factor, temp_parameter):\n h = compute_probabilities(X, theta, temp_parameter)\n\n cost = 0\n for i in range(X.shape[0]):\n for j in range(theta.shape[0]):\n if Y[i] == j:\n cost += np.log(h[j,i])\n\n cost = -cost / X.shape[0]\n\n theta = np.power(theta, 2)\n\n cost += lambda_factor / 2 * theta.sum()\n\n return cost","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 get_expected_cost(self):","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 cost(self, X=None, y=None):\n\t\tif X is None:\n\t\t\tX = self.x_data\n\t\telse:\n\t\t\tn_samples = np.size(X, 0)\n\t\t\tX = np.hstack((np.ones((n_samples, 1)), (X - np.mean(X,0)) / np.std(X,0)))\n\n\t\tif y is None:\n\t\t\ty = self.y_data\n\t\telse:\n\t\t\ty = y[:, np.newaxis]\n\n\t\ty_pred = X @ self.weights\n\n\t\t# SSE formula\n\t\tcost = 1 - (((y - y_pred) ** 2 ).sum() / ((y- y.mean())** 2).sum())\n\n\t\treturn cost","def compute_cost(features, values, theta):\n\n npoints = len(values)\n sum_of_square_errors = np.square(np.dot(features, theta) - values).sum()\n cost = sum_of_square_errors / (2*npoints)\n\n return cost","def get_action_cost(state: tuple, action: int) -> float:\n assert len(state) == 3 and state[0] < 5 and state[1] < 4 and state[2] < 3 and action < 3\n if state[0] == 0:\n return 0.0\n if state[0] == 1 and action == 0:\n return -20.0 + 10.0 * 0.5\n return -20.0 # Penalty = 20 due to Team Number = 9","def cost(self):\n\t\treturn self.g + self.h","def calculate_total_cost(state):\n pass","def eval_cost(self, params, **kwargs):\n raise NotImplementedError","def cost_total(X, cost_weights=(1.0, 1.0, 1.0)):\n return cost_weights[0] * cost_distance(X) + \\\n cost_weights[1] * cost_same_team_by_distance(X) + \\\n cost_weights[2] * cost_previous_neighbour_by_distance(X, normalize=True)","def compute_cost(self,X, y):\n \n num_samples = len(X)\n # Do Forward propagation to calculate our predictions\n z1 = X.dot(self.W1) + self.b1\n a1 = np.tanh(z1)\n z2 = a1.dot(self.W2) + self.b2\n exp_z = np.exp(z2)\n a2 = exp_z / np.sum(exp_z, axis=1, keepdims=True)\n softmax_scores = a2\n # Calculate the cross-entropy loss\n cross_ent_err = -np.log(softmax_scores[range(num_samples), y])\n data_loss = np.sum(cross_ent_err)\n return 1./num_samples * data_loss","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 optimize(self, x0):\n (result,f,d) = fmin_l_bfgs_b(lambda x:self.costFun(x), np.ravel(x0),lambda x: self.gradFun(x))\n print(\"optimization completed with cost: \" + str(f))\n return result.reshape(self.inp_shape)","def getCostFunction(self, evalpts, observations, sigma=None, metric=lambda x: sum(x*x)):\n #XXX: better interface for sigma?\n def _(params):\n ind = 0\n for F, n, ofilt, icheck in zip(self._forwardFactories, self._inputs, \\\n self._outputFilters, self._inputCheckers):\n # check input #XXX: is this worthwile to do?\n my_params = params[ind:ind+n]\n checkQ = icheck(my_params, evalpts)\n if checkQ is not None:\n # some parameters are out of range... returns \"cost\"\n return checkQ\n\n Gm = F(params[ind:ind+n])\n if ind == 0:\n x = ofilt(Gm(evalpts)) \n else:\n x = x + ofilt(Gm(evalpts)) \n ind = ind+n\n if sigma is None:\n x = x - observations\n else:\n x = (x - observations) / sigma\n #return sum(real((conjugate(x)*x)))\n #return sum(x*x) \n return metric(x)\n return _","def compute_cost(features, values, theta):\n m = len(values)\n sum_of_square_errors = np.square(np.dot(features, theta) - values).sum()\n cost = sum_of_square_errors / (2 * m)\n\n return cost","def cost_function(data_x, data_y, parameters):\n # Residual sum of squares\n rss = np.sum((data_x @ parameters - data_y) ** 2)\n\n # Number of rows times 2\n nb_rows_x2 = 2 * data_x.shape[0]\n\n return rss / nb_rows_x2","def cost_function(theta, X, y):\n\n l = None\n #######################################################################\n # TODO: #\n # Compute and return the cost l of a particular choice of #\n # theta. #\n # #\n #######################################################################\n thetaX = np.dot(X, theta)\n g = tanh(thetaX)-y\n l = np.sum(g*g) / X.shape[0]\n \n #######################################################################\n # END OF YOUR CODE #\n #######################################################################\n return l","def compute_cost(y, tx, w):\n # ***************************************************\n # INSERT YOUR CODE HERE\n # TODO: compute loss by MSE / MAE\n # ***************************************************\n \n # vector e\n e = compute_e(y, tx, w)\n N = compute_N(e)\n L_MSE = np.dot(np.matrix.transpose(e), e)\n L_MSE = L_MSE / (2 * N)\n \n return L_MSE","def prediction_cost(a, y):\n return np.sum((a - y) ** 2) / 2","def getCost(self, state, action):\n util.raiseNotDefined()","def compute_cost(self, r):\n self.r_max = 1\n return np.exp(1 / (np.power(r, 2) - np.power(self.r_max, 2))) if r < self.r_max else 0","def fn(i, cost):\n if cost >= target or i == len(toppingCosts): return cost\n return min(fn(i+1, cost), fn(i+1, cost+toppingCosts[i]), key=lambda x: (abs(x-target), x))","def calc_cost(y, yhat, cost_matrix):\n return np.mean(cost_matrix[list(y), list(yhat)])","def compute_cost(self,X, y):\r\n num_examples = np.shape(X)[0]\r\n z = np.dot(X,self.theta) + self.bias\r\n exp_z = np.exp(z)\r\n softmax_scores = exp_z / np.sum(exp_z, axis=1, keepdims=True)\r\n \r\n one_hot_y = np.zeros((num_examples,np.max(y)+1))\r\n logloss = np.zeros((num_examples,)) \r\n for i in range(np.shape(X)[0]):\r\n one_hot_y[i,y[i]] = 1\r\n logloss[i] = -np.sum(np.log(softmax_scores[i,:]) * one_hot_y[i,:])\r\n data_loss = np.sum(logloss)\r\n return 1./num_examples * data_loss","def fixed_cost(self):\n return np.einsum('i->', self.c[self.f])","def calculateCost(self,sol,weights):\n\t\treturn sum([x.value*y if x != None else 0 \\\n\t\t\t\t\tfor x,y in zip(sol,weights)])","def cost_derivative(self,output_results,y):\r\n\t\treturn (output_results-y)","def get_cost(self, Y, T):\n return - np.multiply(T, np.log(Y)).sum() / Y.shape[0]","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 total_cost(self):\n return np.einsum('i->', self.c[self.s])","def compute_cost_derivative(AL, Y):\n pass","def fn(self, x):\n\n return math.exp(x*2) - math.exp(x) - 2","def fn(self, x):\n\n return math.exp(x*2) - math.exp(x) - 2","def cost_(self, y_hat, y, eps=1e-15):\n\t\treturn -(1 / y.shape[0]) * np.sum((y * np.log(y_hat + eps)) + (1 - y) * np.log(1 - y_hat + eps))","def cost_h(self, node, xg):\n h = (node.state - xg).T @ self.Q @ (node.state - xg)\n return float(h)","def cost(self, x, y):\n return self.cross_entropy_error(x,y) + self.l2_regularization_penalty()","def _apply_cost_xy(x, y, norm_x, norm_y, vec, cost_fn, cost_pow, fn=None):\n c = _cost(x, y, norm_x, norm_y, cost_fn, cost_pow)\n return jnp.dot(c, vec) if fn is None else jnp.dot(fn(c), vec)","def eval(self, x):\n return ( float(self.coeff.nominator) / self.coeff.denominator ) * ( x ** self.expt )","def running_cost(self, t_span, step_size, x):\n cost = 0\n ones = torch.ones(x.shape[1], 1, device=x.device)\n for idx,t in enumerate(t_span):\n input_nn = torch.cat([ones*t, x[idx,:,:]], 1)\n X_C_X = self.x_M_x(x[idx,:,:], self.C)\n alpha_t = self.func_ode.alpha(input_nn)\n alpha_D_alpha = self.x_M_x(alpha_t, self.D)\n cost += step_size*(X_C_X + alpha_D_alpha)\n return cost","def evaluate_cost(self, msg):\n raise NotImplementedError()","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 fn(i, j):\n if i == len(costs): return 0 # no more houses to paint \n return costs[i][j] + min(fn(i+1, jj) for jj in range(3) if j != jj)","def _cost(self, action):\n raise NotImplementedError","def cost(lossvalues):\n return np.sum(lossvalues ** 2) / (2 * lossvalues.shape[1])","def cost_matrix(x, y, p=2):\n xc = tf.expand_dims(x, 1)\n yr = tf.expand_dims(y, 0)\n d = tf.math.pow(tf.abs(xc - yr), p)\n return tf.reduce_sum(d, axis=-1)","def calculate_cost(theta_values, data):\n population = data[:,0]\n prices = data[:,1]\n total_error = 0\n for i in range(0,len(population)):\n x = array([[1],[population[i]]])\n hypothesis = theta_values.dot(x).flatten() \n squared_error = (hypothesis - prices[i])**2\n total_error += squared_error\n return .5*total_error/len(population) #division by m is just a scaling factor since we're only interested in whether this function is minimized","def getCostFunctionSlow(self, evalpts, observations):\n #XXX: update interface to allow metric?\n def _(params):\n v = self.getVectorCostFunction(evalpts, observations)\n x = v(params)\n return sum(real((conjugate(x)*x)))\n return _","def cost(self, sample):\n assert len(sample) == len(self.domain)\n\n tail = self.n - len(np.trim_zeros(sample, 'b'))\n head = self.n - len(np.trim_zeros(np.logical_not(sample), 'f'))\n Rxt = self.n if tail > self.T and head > self.T else 0\n return -float(max(head, tail) + Rxt)","def evaluate( self, x ) :\n\n P = 0.\n for c_l in reversed( self.coefficients ) : P = c_l + x * P\n return( P )","def easy_eval(self, x):\n answer = 0\n for i in range(len(self.coefficients)):\n coef = self.coefficients[i]\n degree = len(self.coefficients) - (i+1)\n answer += x ** degree * coef\n return answer","def cost_function(x, params, y, m):\n\n x_theta = np.matmul(x, params)\n hypothesis = vectorized_sigmoid_function(x_theta)\n\n return np.sum(np.log(hypothesis) * y + np.log(1 - hypothesis) * (1 - y)) * (-1 / m)","def prediction_cost(a, y):\n return np.sum(-(y * np.log(a) + (1 - y) * np.log(1 - a)))","def cost_func(w, X, y):\n y_pred = np.dot(X, w)\n err = np.sum(np.square(y_pred - y)) / (2 * len(y))\n\n return err","def get_cost_val(self, var_name, pos):\n return self.get_other_value(self.cost, var_name, pos)","def _cost_function(self, y_pred, y, m):\n sumatory = 0\n for x in range(m):\n sumatory += (y_pred[0][x] -y[0][x])**2\n\n cost = 1/(2*m) * sumatory\n return cost","def get_cost(self):\n\n\t\tx = self.symbolic_input\n\t\ty = self.get_reconstructed_input()\n\n\t\tnegative_log_loss = -theano.tensor.sum(x*theano.tensor.log(y) +\n\t\t\t(1-x)*theano.tensor.log(1-y), axis=1)\n\n\t\tmean_loss = theano.tensor.mean(negative_log_loss)\n\n\t\treturn mean_loss","def cost_function_no_reg (model, X, y):\n\n m = len (y)\n pred = model.predict (X)\n cost = 1. / (2. * m) * ((pred - y)**2).sum ()\n return (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"],"string":"[\n \"def costFun(self, S, x):\",\n \"def cost(self,x):\\n Mx = self.generate_vector()\\n self.prior.M.mult(x,Mx)\\n return .5*Mx.inner(x)\",\n \"def final_cost(self, x):\\n return self.x_M_x(x[-1,:,:],self.R)\",\n \"def fn(x):\\n if x == 0: return 0\\n if x < 0: return -inf \\n return max(fn(x - c) * 10 + i + 1 for i, c in enumerate(cost))\",\n \"def cost(self) -> float:\",\n \"def c(x):\\n cost = per_widget_cost * x + fixed_cost\\n return cost\",\n \"def costFunction(self, x, y ):\\n self.yEst = self.forward_propagate(x)\\n sqErrors = ( self.yEst - y ) ** 2\\n J = sqErrors.sum() / 2\\n return J\",\n \"def __compute_cost(self, x, y):\\n\\n predictions = self.__compute_prediction(x)\\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\\n\\n return cost\",\n \"def compute_cost(AL, Y):\\n pass\",\n \"def cost_fun(x, problem):\\n j = 0\\n if problem['use_log_bar']:\\n c = ineqconstr(x, problem)\\n j += np.sum(logbarrierfunc(0.1, c, problem['use_sigma']))\\n\\n x, t_final = matrify(x, problem)\\n if problem['T']!=0:\\n j += np.sum([problem['cost_fun_single'](x[:, :, i], t_final, problem) for i in range(problem['Nv'])])\\n else:\\n j = t_final\\n return j\",\n \"def compute_cost(AL, Y):\\n pass\",\n \"def calculate_cost(x, y, weights):\\r\\n predictions = compute_prediction(x, weights)\\r\\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\\r\\n return cost\",\n \"def objective_function(x):\\n return x * 1 # change this to our actual function\",\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 cost_function(self, element):\\n return self.maze.cost(element)\",\n \"def get_cost(self) -> float:\\n return math.e / self.fitness\",\n \"def objective(self, x):\\n pass\",\n \"def objective(self, x):\\n pass\",\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 get_cost(self, action: Action) -> N:\\n pass\",\n \"def calcCostFun(self):\\n\\n self.start()\\n F, K = self.model()\\n \\n return self.costFunction\",\n \"def calc_cost(y, x, theta_1, theta_0):\\n h = theta_1 * x + theta_0\\n d = h - y\\n cost = np.dot(d.T, d) / (2*x.shape[0])\\n return cost.flat[0]\",\n \"def _cost(self, X, particle):\\n startprob, transmat = self._parse_particle(particle)\\n startprob, transmat = self._shape_probs(startprob, transmat)\\n return -self._compute_logprob(X, startprob, transmat, **self._params)\",\n \"def compute_cost(x, y, theta=[[0], [0]]):\\n m = y.size\\n h = x.dot(theta)\\n j = 1 / (2 * m) * np.sum(np.square(h - y))\\n return j\",\n \"def _cost_method(self, *args, **kwargs):\\n\\n cost_val = 0.5 * np.linalg.norm(self.obs_data - self.op(args[0])) ** 2\\n\\n if 'verbose' in kwargs and kwargs['verbose']:\\n print(' - DATA FIDELITY (X):', cost_val)\\n\\n return cost_val\",\n \"def _call(self, x):\\n tmp = x.asarray().flatten()\\n return self.range.element(self.cost_matrix.dot(tmp))\",\n \"def evaluate_cost(\\n self, x: Dict[str, ArrayType], p: Dict[str, ArrayType]\\n ) -> CasADiArrayType:\\n x = self.opt.decision_variables.dict2vec(x)\\n p = self.opt.parameters.dict2vec(p)\\n return self.opt.f(x, p)\",\n \"def calc_total_cost(self, X):\\n return self.sess.run(self.cost, feed_dict={self.x: X, self.scale: self.training_scale})\",\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 cost_from_X(self, data):\\n self.cost_from_X_data_specs()[0].validate(data)\\n X, Y = data\\n Y_hats= self.fprop(X)\\n return self.cost(Y, Y_hats)\",\n \"def cost_function (model, X, y, lambda_reg=0.):\\n\\n m = len (y)\\n pred = model.predict (X)\\n cost = 1. / (2. * m) * ((pred - y)**2).sum () + \\\\\\n lambda_reg / (2. * m) * (model.coef_**2).sum ()\\n return (cost)\",\n \"def cost(self, cost_object, target):\\n\\n return cost_object.f(self.a[-1], target).mean(axis=0).sum()\",\n \"def cost_function(self, config_samples):\\n cost = self.work_tracker(config_samples)\\n return cost\",\n \"def calculate_total_cost(state):\\r\\n return state.cost()\",\n \"def value(self, x):\\n f = self._objective(\\n time_series=self.observed_data,\\n a=x[0],\\n b=x[1],\\n c=x[2],\\n sigma=self.sigma\\n )\\n return f\",\n \"def __call__(self, x, u, k):\\n first_time_through = True\\n for cost, arg, weight in zip(self._costs, self._args, self._weights):\\n if arg == \\\"x\\\":\\n cost_input = x\\n else:\\n cost_input = u[arg]\\n\\n current_term = weight * cost(cost_input, k)\\n if current_term > 1e8:\\n print(\\\"Warning: cost %s is %f\\\" % (cost._name, current_term))\\n print(\\\"Input is: \\\", cost_input)\\n\\n# if cost._name[:4] == \\\"bike\\\":\\n# print(cost._name, \\\": \\\", current_term)\\n\\n if first_time_through:\\n total_cost = current_term\\n else:\\n total_cost += current_term\\n\\n first_time_through = False\\n\\n return total_cost\",\n \"def compute_cost(AL,Y,cost_function_name):\\n cost_functions = {\\n \\\"cost_func_1\\\": cf.cost_function_1\\n } \\n\\n activ_func = cost_functions.get(cost_function_name,lambda : \\\"Invalid Cost Function Name !\\\")\\n\\n cost,dAL = activ_func(AL,Y)\\n\\n return cost, dAL\",\n \"def cost(self, data_X, data_Y):\\n c = self.cost_function(data_Y, self.predict(data_X))\\n\\n if self.regularizer is not None:\\n c += self.regularizer.cost(self.particle_input, self.layers)\\n\\n return c\",\n \"def cost(self, X, y) :\\n ### ========== TODO : START ========== ###\\n # part d: compute J(theta)\\n #we know for linear/polynomial regression, the cost is the square of the errors\\n X = self.generate_polynomial_features(X)\\n y_pred_vector = np.dot(X, self.coef_)\\n cost = np.dot((y-y_pred_vector).transpose(),(y-y_pred_vector))#write in the matrix form\\n ### ========== TODO : END ========== ###\\n return cost\",\n \"def compute_objective(X, C):\\n # similar as mse\\n\\n acc = 0\\n for x in range(len(X)):\\n acc += (nearest_distance(X.iloc[x], C)) ** 2\\n\\n return acc\",\n \"def compute_cost_function(X, Y, theta, lambda_factor, temp_parameter):\\n h = compute_probabilities(X, theta, temp_parameter)\\n\\n cost = 0\\n for i in range(X.shape[0]):\\n for j in range(theta.shape[0]):\\n if Y[i] == j:\\n cost += np.log(h[j,i])\\n\\n cost = -cost / X.shape[0]\\n\\n theta = np.power(theta, 2)\\n\\n cost += lambda_factor / 2 * theta.sum()\\n\\n return cost\",\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 get_expected_cost(self):\",\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 cost(self, X=None, y=None):\\n\\t\\tif X is None:\\n\\t\\t\\tX = self.x_data\\n\\t\\telse:\\n\\t\\t\\tn_samples = np.size(X, 0)\\n\\t\\t\\tX = np.hstack((np.ones((n_samples, 1)), (X - np.mean(X,0)) / np.std(X,0)))\\n\\n\\t\\tif y is None:\\n\\t\\t\\ty = self.y_data\\n\\t\\telse:\\n\\t\\t\\ty = y[:, np.newaxis]\\n\\n\\t\\ty_pred = X @ self.weights\\n\\n\\t\\t# SSE formula\\n\\t\\tcost = 1 - (((y - y_pred) ** 2 ).sum() / ((y- y.mean())** 2).sum())\\n\\n\\t\\treturn cost\",\n \"def compute_cost(features, values, theta):\\n\\n npoints = len(values)\\n sum_of_square_errors = np.square(np.dot(features, theta) - values).sum()\\n cost = sum_of_square_errors / (2*npoints)\\n\\n return cost\",\n \"def get_action_cost(state: tuple, action: int) -> float:\\n assert len(state) == 3 and state[0] < 5 and state[1] < 4 and state[2] < 3 and action < 3\\n if state[0] == 0:\\n return 0.0\\n if state[0] == 1 and action == 0:\\n return -20.0 + 10.0 * 0.5\\n return -20.0 # Penalty = 20 due to Team Number = 9\",\n \"def cost(self):\\n\\t\\treturn self.g + self.h\",\n \"def calculate_total_cost(state):\\n pass\",\n \"def eval_cost(self, params, **kwargs):\\n raise NotImplementedError\",\n \"def cost_total(X, cost_weights=(1.0, 1.0, 1.0)):\\n return cost_weights[0] * cost_distance(X) + \\\\\\n cost_weights[1] * cost_same_team_by_distance(X) + \\\\\\n cost_weights[2] * cost_previous_neighbour_by_distance(X, normalize=True)\",\n \"def compute_cost(self,X, y):\\n \\n num_samples = len(X)\\n # Do Forward propagation to calculate our predictions\\n z1 = X.dot(self.W1) + self.b1\\n a1 = np.tanh(z1)\\n z2 = a1.dot(self.W2) + self.b2\\n exp_z = np.exp(z2)\\n a2 = exp_z / np.sum(exp_z, axis=1, keepdims=True)\\n softmax_scores = a2\\n # Calculate the cross-entropy loss\\n cross_ent_err = -np.log(softmax_scores[range(num_samples), y])\\n data_loss = np.sum(cross_ent_err)\\n return 1./num_samples * data_loss\",\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 optimize(self, x0):\\n (result,f,d) = fmin_l_bfgs_b(lambda x:self.costFun(x), np.ravel(x0),lambda x: self.gradFun(x))\\n print(\\\"optimization completed with cost: \\\" + str(f))\\n return result.reshape(self.inp_shape)\",\n \"def getCostFunction(self, evalpts, observations, sigma=None, metric=lambda x: sum(x*x)):\\n #XXX: better interface for sigma?\\n def _(params):\\n ind = 0\\n for F, n, ofilt, icheck in zip(self._forwardFactories, self._inputs, \\\\\\n self._outputFilters, self._inputCheckers):\\n # check input #XXX: is this worthwile to do?\\n my_params = params[ind:ind+n]\\n checkQ = icheck(my_params, evalpts)\\n if checkQ is not None:\\n # some parameters are out of range... returns \\\"cost\\\"\\n return checkQ\\n\\n Gm = F(params[ind:ind+n])\\n if ind == 0:\\n x = ofilt(Gm(evalpts)) \\n else:\\n x = x + ofilt(Gm(evalpts)) \\n ind = ind+n\\n if sigma is None:\\n x = x - observations\\n else:\\n x = (x - observations) / sigma\\n #return sum(real((conjugate(x)*x)))\\n #return sum(x*x) \\n return metric(x)\\n return _\",\n \"def compute_cost(features, values, theta):\\n m = len(values)\\n sum_of_square_errors = np.square(np.dot(features, theta) - values).sum()\\n cost = sum_of_square_errors / (2 * m)\\n\\n return cost\",\n \"def cost_function(data_x, data_y, parameters):\\n # Residual sum of squares\\n rss = np.sum((data_x @ parameters - data_y) ** 2)\\n\\n # Number of rows times 2\\n nb_rows_x2 = 2 * data_x.shape[0]\\n\\n return rss / nb_rows_x2\",\n \"def cost_function(theta, X, y):\\n\\n l = None\\n #######################################################################\\n # TODO: #\\n # Compute and return the cost l of a particular choice of #\\n # theta. #\\n # #\\n #######################################################################\\n thetaX = np.dot(X, theta)\\n g = tanh(thetaX)-y\\n l = np.sum(g*g) / X.shape[0]\\n \\n #######################################################################\\n # END OF YOUR CODE #\\n #######################################################################\\n return l\",\n \"def compute_cost(y, tx, w):\\n # ***************************************************\\n # INSERT YOUR CODE HERE\\n # TODO: compute loss by MSE / MAE\\n # ***************************************************\\n \\n # vector e\\n e = compute_e(y, tx, w)\\n N = compute_N(e)\\n L_MSE = np.dot(np.matrix.transpose(e), e)\\n L_MSE = L_MSE / (2 * N)\\n \\n return L_MSE\",\n \"def prediction_cost(a, y):\\n return np.sum((a - y) ** 2) / 2\",\n \"def getCost(self, state, action):\\n util.raiseNotDefined()\",\n \"def compute_cost(self, r):\\n self.r_max = 1\\n return np.exp(1 / (np.power(r, 2) - np.power(self.r_max, 2))) if r < self.r_max else 0\",\n \"def fn(i, cost):\\n if cost >= target or i == len(toppingCosts): return cost\\n return min(fn(i+1, cost), fn(i+1, cost+toppingCosts[i]), key=lambda x: (abs(x-target), x))\",\n \"def calc_cost(y, yhat, cost_matrix):\\n return np.mean(cost_matrix[list(y), list(yhat)])\",\n \"def compute_cost(self,X, y):\\r\\n num_examples = np.shape(X)[0]\\r\\n z = np.dot(X,self.theta) + self.bias\\r\\n exp_z = np.exp(z)\\r\\n softmax_scores = exp_z / np.sum(exp_z, axis=1, keepdims=True)\\r\\n \\r\\n one_hot_y = np.zeros((num_examples,np.max(y)+1))\\r\\n logloss = np.zeros((num_examples,)) \\r\\n for i in range(np.shape(X)[0]):\\r\\n one_hot_y[i,y[i]] = 1\\r\\n logloss[i] = -np.sum(np.log(softmax_scores[i,:]) * one_hot_y[i,:])\\r\\n data_loss = np.sum(logloss)\\r\\n return 1./num_examples * data_loss\",\n \"def fixed_cost(self):\\n return np.einsum('i->', self.c[self.f])\",\n \"def calculateCost(self,sol,weights):\\n\\t\\treturn sum([x.value*y if x != None else 0 \\\\\\n\\t\\t\\t\\t\\tfor x,y in zip(sol,weights)])\",\n \"def cost_derivative(self,output_results,y):\\r\\n\\t\\treturn (output_results-y)\",\n \"def get_cost(self, Y, T):\\n return - np.multiply(T, np.log(Y)).sum() / Y.shape[0]\",\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 total_cost(self):\\n return np.einsum('i->', self.c[self.s])\",\n \"def compute_cost_derivative(AL, Y):\\n pass\",\n \"def fn(self, x):\\n\\n return math.exp(x*2) - math.exp(x) - 2\",\n \"def fn(self, x):\\n\\n return math.exp(x*2) - math.exp(x) - 2\",\n \"def cost_(self, y_hat, y, eps=1e-15):\\n\\t\\treturn -(1 / y.shape[0]) * np.sum((y * np.log(y_hat + eps)) + (1 - y) * np.log(1 - y_hat + eps))\",\n \"def cost_h(self, node, xg):\\n h = (node.state - xg).T @ self.Q @ (node.state - xg)\\n return float(h)\",\n \"def cost(self, x, y):\\n return self.cross_entropy_error(x,y) + self.l2_regularization_penalty()\",\n \"def _apply_cost_xy(x, y, norm_x, norm_y, vec, cost_fn, cost_pow, fn=None):\\n c = _cost(x, y, norm_x, norm_y, cost_fn, cost_pow)\\n return jnp.dot(c, vec) if fn is None else jnp.dot(fn(c), vec)\",\n \"def eval(self, x):\\n return ( float(self.coeff.nominator) / self.coeff.denominator ) * ( x ** self.expt )\",\n \"def running_cost(self, t_span, step_size, x):\\n cost = 0\\n ones = torch.ones(x.shape[1], 1, device=x.device)\\n for idx,t in enumerate(t_span):\\n input_nn = torch.cat([ones*t, x[idx,:,:]], 1)\\n X_C_X = self.x_M_x(x[idx,:,:], self.C)\\n alpha_t = self.func_ode.alpha(input_nn)\\n alpha_D_alpha = self.x_M_x(alpha_t, self.D)\\n cost += step_size*(X_C_X + alpha_D_alpha)\\n return cost\",\n \"def evaluate_cost(self, msg):\\n raise NotImplementedError()\",\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 fn(i, j):\\n if i == len(costs): return 0 # no more houses to paint \\n return costs[i][j] + min(fn(i+1, jj) for jj in range(3) if j != jj)\",\n \"def _cost(self, action):\\n raise NotImplementedError\",\n \"def cost(lossvalues):\\n return np.sum(lossvalues ** 2) / (2 * lossvalues.shape[1])\",\n \"def cost_matrix(x, y, p=2):\\n xc = tf.expand_dims(x, 1)\\n yr = tf.expand_dims(y, 0)\\n d = tf.math.pow(tf.abs(xc - yr), p)\\n return tf.reduce_sum(d, axis=-1)\",\n \"def calculate_cost(theta_values, data):\\n population = data[:,0]\\n prices = data[:,1]\\n total_error = 0\\n for i in range(0,len(population)):\\n x = array([[1],[population[i]]])\\n hypothesis = theta_values.dot(x).flatten() \\n squared_error = (hypothesis - prices[i])**2\\n total_error += squared_error\\n return .5*total_error/len(population) #division by m is just a scaling factor since we're only interested in whether this function is minimized\",\n \"def getCostFunctionSlow(self, evalpts, observations):\\n #XXX: update interface to allow metric?\\n def _(params):\\n v = self.getVectorCostFunction(evalpts, observations)\\n x = v(params)\\n return sum(real((conjugate(x)*x)))\\n return _\",\n \"def cost(self, sample):\\n assert len(sample) == len(self.domain)\\n\\n tail = self.n - len(np.trim_zeros(sample, 'b'))\\n head = self.n - len(np.trim_zeros(np.logical_not(sample), 'f'))\\n Rxt = self.n if tail > self.T and head > self.T else 0\\n return -float(max(head, tail) + Rxt)\",\n \"def evaluate( self, x ) :\\n\\n P = 0.\\n for c_l in reversed( self.coefficients ) : P = c_l + x * P\\n return( P )\",\n \"def easy_eval(self, x):\\n answer = 0\\n for i in range(len(self.coefficients)):\\n coef = self.coefficients[i]\\n degree = len(self.coefficients) - (i+1)\\n answer += x ** degree * coef\\n return answer\",\n \"def cost_function(x, params, y, m):\\n\\n x_theta = np.matmul(x, params)\\n hypothesis = vectorized_sigmoid_function(x_theta)\\n\\n return np.sum(np.log(hypothesis) * y + np.log(1 - hypothesis) * (1 - y)) * (-1 / m)\",\n \"def prediction_cost(a, y):\\n return np.sum(-(y * np.log(a) + (1 - y) * np.log(1 - a)))\",\n \"def cost_func(w, X, y):\\n y_pred = np.dot(X, w)\\n err = np.sum(np.square(y_pred - y)) / (2 * len(y))\\n\\n return err\",\n \"def get_cost_val(self, var_name, pos):\\n return self.get_other_value(self.cost, var_name, pos)\",\n \"def _cost_function(self, y_pred, y, m):\\n sumatory = 0\\n for x in range(m):\\n sumatory += (y_pred[0][x] -y[0][x])**2\\n\\n cost = 1/(2*m) * sumatory\\n return cost\",\n \"def get_cost(self):\\n\\n\\t\\tx = self.symbolic_input\\n\\t\\ty = self.get_reconstructed_input()\\n\\n\\t\\tnegative_log_loss = -theano.tensor.sum(x*theano.tensor.log(y) +\\n\\t\\t\\t(1-x)*theano.tensor.log(1-y), axis=1)\\n\\n\\t\\tmean_loss = theano.tensor.mean(negative_log_loss)\\n\\n\\t\\treturn mean_loss\",\n \"def cost_function_no_reg (model, X, y):\\n\\n m = len (y)\\n pred = model.predict (X)\\n cost = 1. / (2. * m) * ((pred - y)**2).sum ()\\n return (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]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8048273","0.7995505","0.7497831","0.74943554","0.72771204","0.72714454","0.724877","0.7232135","0.72299874","0.72011256","0.7193746","0.7113412","0.7009601","0.69141775","0.68879235","0.6861625","0.67966616","0.67966616","0.67889404","0.6746737","0.674264","0.6732482","0.6699713","0.66988903","0.66848457","0.66827816","0.66824543","0.66770774","0.66524637","0.6650004","0.6648322","0.6592004","0.6586702","0.6578686","0.6546608","0.65286237","0.6519836","0.6500097","0.6498085","0.6493202","0.6478913","0.6478499","0.6475146","0.64654005","0.6453717","0.6452941","0.6451938","0.6449452","0.6443246","0.6435242","0.643087","0.64158744","0.6413716","0.64099","0.64094526","0.64075005","0.64057136","0.64052665","0.6402028","0.63797694","0.6370514","0.636845","0.63617885","0.6355563","0.63480794","0.6346398","0.63409764","0.63382745","0.63234687","0.6322731","0.63193595","0.63068783","0.62926275","0.62926275","0.62887263","0.6281978","0.6271723","0.62571675","0.62542546","0.6252521","0.62375927","0.6234182","0.6233611","0.62254727","0.62206024","0.6219245","0.6218334","0.6213759","0.6181573","0.61668473","0.61599743","0.6156328","0.6153567","0.6150885","0.61361545","0.6133807","0.6133249","0.6132286","0.61243653","0.61243653"],"string":"[\n \"0.8048273\",\n \"0.7995505\",\n \"0.7497831\",\n \"0.74943554\",\n \"0.72771204\",\n \"0.72714454\",\n \"0.724877\",\n \"0.7232135\",\n \"0.72299874\",\n \"0.72011256\",\n \"0.7193746\",\n \"0.7113412\",\n \"0.7009601\",\n \"0.69141775\",\n \"0.68879235\",\n \"0.6861625\",\n \"0.67966616\",\n \"0.67966616\",\n \"0.67889404\",\n \"0.6746737\",\n \"0.674264\",\n \"0.6732482\",\n \"0.6699713\",\n \"0.66988903\",\n \"0.66848457\",\n \"0.66827816\",\n \"0.66824543\",\n \"0.66770774\",\n \"0.66524637\",\n \"0.6650004\",\n \"0.6648322\",\n \"0.6592004\",\n \"0.6586702\",\n \"0.6578686\",\n \"0.6546608\",\n \"0.65286237\",\n \"0.6519836\",\n \"0.6500097\",\n \"0.6498085\",\n \"0.6493202\",\n \"0.6478913\",\n \"0.6478499\",\n \"0.6475146\",\n \"0.64654005\",\n \"0.6453717\",\n \"0.6452941\",\n \"0.6451938\",\n \"0.6449452\",\n \"0.6443246\",\n \"0.6435242\",\n \"0.643087\",\n \"0.64158744\",\n \"0.6413716\",\n \"0.64099\",\n \"0.64094526\",\n \"0.64075005\",\n \"0.64057136\",\n \"0.64052665\",\n \"0.6402028\",\n \"0.63797694\",\n \"0.6370514\",\n \"0.636845\",\n \"0.63617885\",\n \"0.6355563\",\n \"0.63480794\",\n \"0.6346398\",\n \"0.63409764\",\n \"0.63382745\",\n \"0.63234687\",\n \"0.6322731\",\n \"0.63193595\",\n \"0.63068783\",\n \"0.62926275\",\n \"0.62926275\",\n \"0.62887263\",\n \"0.6281978\",\n \"0.6271723\",\n \"0.62571675\",\n \"0.62542546\",\n \"0.6252521\",\n \"0.62375927\",\n \"0.6234182\",\n \"0.6233611\",\n \"0.62254727\",\n \"0.62206024\",\n \"0.6219245\",\n \"0.6218334\",\n \"0.6213759\",\n \"0.6181573\",\n \"0.61668473\",\n \"0.61599743\",\n \"0.6156328\",\n \"0.6153567\",\n \"0.6150885\",\n \"0.61361545\",\n \"0.6133807\",\n \"0.6133249\",\n \"0.6132286\",\n \"0.61243653\",\n \"0.61243653\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.820668"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84781,"cells":{"query":{"kind":"string","value":"Function that computes the gradient of the cost function at x"},"document":{"kind":"string","value":"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"},"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 gradient(self, x):\n pass","def gradient(cls, x):\n y = Sigmoid.apply(x)\n return np.multiply(y, 1 - y)","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 gradientdescent(cost_func, theta, args=(), delta_func = 0):\n step = 1\n old_cost = 0\n while True:\n theta_old = theta.copy()\n cost = cost_func(theta, *args)\n delta = delta_func(theta, *args)\n theta = theta - step * delta\n if cost > old_cost and old_cost != 0:\n step = step*0.7\n if np.allclose(theta_old, theta):\n break\n old_cost = cost\n return theta","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 compute_gradient(theta, X, y):\n m = X.shape[0]\n grad_theta = np.dot(X.transpose(), (np.dot(X, theta) - y)) / m\n #print theta, grad_theta, objective_function(theta, X, y)\n return grad_theta","def logit_cost_grad(self, theta, X, y):\n\n grad = np.zeros(len(theta))\n\n ### YOUR CODE HERE\n sig = utils.sigmoid(theta)\n # sig = np.subtract(sig, y)\n sig = sig - y\n grad = np.dot(X.T, sig) + 2 * self.params['lamb'] * self.regularizer[1](self.weights)\n ### END YOUR CODE\n\n return grad","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 gradient_function(theta, X, y):\n\n grad = None\n #######################################################################\n # TODO: #\n # Compute the gradient for a particular choice of theta. #\n # 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 \n theta = theta[:, np.newaxis]\n \n thetatrans = theta.T\n Xtrans = X.T\n \n MulThetaX = np.dot(thetatrans, Xtrans)\n \n h = sigmoid(MulThetaX)\n \n grad = (y - h) * Xtrans\n\n #######################################################################\n # END OF YOUR CODE #\n #######################################################################\n return grad","def gradient(w, x, t):\n return 2 * np.dot(x.T, (nn(x, w) - t))","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 gradientFunctionReg(theta, X, y, Lambda):\n m = len(y) # number of training examples\n grad = np.zeros(theta.shape[0])\n theta = np.transpose(theta)\n sum_1 = 0\n X = X.values\n y = y.values\n #calcuate the theta_0 \n# ====================== YOUR CODE HERE ======================\n# Instructions: Compute the gradient of a particular choice of theta.\n# Compute the partial derivatives and set grad to the partial\n# derivatives of the cost w.r.t. each parameter in theta\n for i in range(theta.shape[0]):\n if i == 0:\n for j in range(m):\n sum_1 += (sigmoid(np.dot(X[j],theta)) - y[j]) * X[j,i]\n else:\n for j in range(m):\n sum_1 += (sigmoid(np.dot(X[j],theta)) - y[j]) * X[j,i] + Lambda*theta[i]\n grad[i] = sum_1/m\n sum_1 = 0\n\n# =============================================================\n\n return grad","def gradient(cls, x):\n return 1 - TanH.apply(x) ** 2","def objective_function_gradients(self, x):\n self._set_params_transformed(x)\n LL_gradients = self._transform_gradients(self._log_likelihood_gradients())\n prior_gradients = self._transform_gradients(self._log_prior_gradients())\n return - LL_gradients - prior_gradients","def gradient(self, x):\n return 0.0","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 gradient(self, x):\n g = self._grad(\n time_series=self.observed_data,\n a=x[0],\n b=x[1],\n c=x[2],\n sigma=self.sigma\n )\n return g","def grad(x):\n\n return x - np.arange(1, cfg.n + 1, dtype=np.float_)","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 gradient(self, x, i=None):\n self.set_parameters(x=x)\n gradient = self.gradient_loss()\n if self.add_bias:\n gradient[1:] += self.alpha * self.gradient_regularizer()\n else:\n gradient += self.alpha * self.gradient_regularizer()\n if i is not None:\n return gradient.ravel()[i]\n return gradient.ravel()","def numerical_gradient(f, x: np.ndarray):\n h = 1e-4\n grad = np.zeros_like(x)\n for i in range(x.size):\n tmp_val = x.flat[i]\n x.flat[i] = tmp_val + h\n fxh1 = f(x)\n\n x.flat[i] = tmp_val - h\n fxh2 = f(x)\n grad.flat[i] = (fxh1 - fxh2) / (2 * h)\n x.flat[i] = tmp_val\n return grad","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 objective_function_gradients(self, x):\r\n try:\r\n self._set_params_transformed(x)\r\n obj_grads = -self._transform_gradients(self._log_likelihood_gradients() + self._log_prior_gradients())\r\n self._fail_count = 0\r\n except (LinAlgError, ZeroDivisionError, ValueError) as e:\r\n if self._fail_count >= self._allowed_failures:\r\n raise e\r\n self._fail_count += 1\r\n obj_grads = np.clip(-self._transform_gradients(self._log_likelihood_gradients() + self._log_prior_gradients()), -1e100, 1e100)\r\n return obj_grads","def approx_grad(theta, X, y):\n grad_a = np.array([(cost(theta + e, X, y) - cost(theta - e, X, y)) / (2 * 1e-5)\n for e in np.identity(len(theta)) * 1e-5])\n return grad_a","def gradient(theta, X, y, learning_rate):\n m = len(y)\n\n theta = theta.reshape((-1,1))\n grad = np.zeros(theta.shape)\n h = sigmoid(np.dot(X, theta)) \n \n grad = np.dot((h-y).T, X)/m\n grad = grad.T\n grad[1:] += (learning_rate/m)*theta[1:]\n return grad","def grad(self, x):\n grad = np.zeros((x.shape[0], 1))\n grad[x >= utils.TOLERANCE] = 1.0\n grad[x <= -utils.TOLERANCE] = -1.0\n between = (x > -utils.TOLERANCE) & (x < utils.TOLERANCE)\n grad[between] = self.rng(between.sum())\n\n return self.l * grad","def compute_gradient(self, X, y, weights):\n sigmoid = self.sigmoid(np.dot(X, weights))\n return np.dot(X.T, y - sigmoid)","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 eval_numerical_gradient(f,x):\n\n\tgrad = np.zeros(x.shape)\n\th = 0.0001\n\n\t# iterate over all indexes in x\n\tit = np.nditer(x, flag = ['multi_index'], op_flags = ['readwrite'])\n\n\twhile not it.finished:\n\t\tix = it.multi_index\n\t\told_value = x[ix]\n\n\t\tx[ix] = old_value + h\n\t\tfxh_left = f(x)\n\n\t\tx[ix] = old_value - h\n\t\tfxh_right = f(x)\n\n\t\tx[ix] = old_value\n\n\t\t# compute the partial derivative\n\t\tgrad[ix] = (fxh_left - fxh_right) / (2 * h)\n\t\tit.iterate()\n\n\treturn grad","def gradient(self, x_in):\r\n\r\n return 1 - torch.pow(self.forward(x_in), 2)","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 calc_gradient_at(self, x: np.ndarray) -> np.ndarray:\n\n if self.gradient_f:\n # if the problem has knowledge about the gradient, use it directly without approximation\n return self.gradient_f(x)\n\n return gradient_approximation(self.f, x)","def lrCostFunction(theta,X,y, lambda_reg):\n m = np.size(y)\n grad = np.zeros(np.size((theta)))\n J_base, grad = costFunction(theta, X, y)\n \n\n reg_cost = (lambda_reg / (2.0 * m)) * np.sum(theta[1:] ** 2)\n \n reg_gradient = (lambda_reg / m) * theta\n reg_gradient[0] = 0\n cost = J_base + reg_cost\n return cost, grad + reg_gradient","def gradient_descent(self, x, y):\n # Initialize weights vector\n self.weights = np.zeros(len(x[0]))\n\n # Storing number of training example in a variable \n n = len(x)\n\n # Initiate variables to keep track of the current and smallest loss recorded\n lowest_loss = sys.float_info.max\n current_loss = sys.float_info.max\n\n # Initiate variables to keep track of step sizes\n norm = sys.float_info.max\n smallest_norm = sys.float_info.max\n\n # Initiate list variable that stores all previous weights\n prev_weights = []\n\n # Initiate list that stores all the errors. \n errors = []\n \n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\n k_loss_iteration = 1\n\n # Learning loop\n for i in range(self.max_iter):\n\n # Append current weights\n prev_weights.append(np.array(self.weights))\n \n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\n\n # Compute the error of the Cost Function and store it in a list\n current_loss = self.cost(x,y)\n\n if len(errors) > 1 and current_loss > errors[-1]:\n k_loss_iteration += 1\n else: \n k_loss_iteration = 1\n\n errors.append(current_loss)\n \n # Track smallest loss\n if current_loss < lowest_loss:\n lowest_loss = current_loss\n\n # Compute the L2 Norm of the difference between current weights and previous weights\n norm = np.linalg.norm(self.weights - prev_weights[-1])\n\n # Track smallest step size and set it as error threshold\n if norm < smallest_norm:\n smallest_norm = norm\n\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\n if self.error_threshold != None and norm < self.error_threshold:\n print(\"Converged after {} iterations!\".format(i))\n break\n\n # stop if error hasn't gone down in k iterations\n if k_loss_iteration >= 10:\n print(k_loss_iteration + \" iterations of loss not decreasing on {}th itertion.\".format(i))\n break\n\n # Log final weights\n print(\"Final norm: \" + str(norm) + \"\\nSmallest step size recorded: \" + str(smallest_norm) + \"\\nFinal error: \" + str(current_loss) + \"\\nLowest error recorded: \" + str(lowest_loss) + \"\\nNumber of epochs: \" + str(len(errors)) + \"\\nFinal weights: \" + str(self.weights))","def gradient_descent(X, y, theta, learning_rate, num_iters, lambda_reg):\n thetas = [theta]\n cost = np.zeros(num_iters)\n\n J = mean_cross_entropy_costs(X, y, lambda_reg)\n cost[0] = J(thetas[0])\n for i in range(1, num_iters):\n thetas.append(compute_new_theta(X, y, thetas[i - 1], learning_rate, lambda_reg))\n cost[i] = J(thetas[i])\n return cost, thetas","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 gradFun(self, S, x):","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 costFunction(self,theta, X, y): \n m = len(y)\n h = self.sigmoid(X@theta)\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \n # grad = 1/ m * X.T @ (h - y)\n return J","def gradient_descent(data_x, data_y, parameters, learn_rate, nb_iterations):\n\n # Cost history\n cost_tracking = np.zeros(nb_iterations)\n\n for _i in range(nb_iterations):\n parameters -= learn_rate * gradient(data_x, data_y, parameters)\n # recording the cost for each iteration\n cost_tracking[_i] = cost_function(data_x, data_y, parameters)\n\n return parameters, cost_tracking","def gradient(f, x, s=_DEFAULT_STEP):\n x = np.asarray(x)\n n = len(x)\n e = np.eye(n)\n\n forw = np.zeros(n)\n for i in range(n):\n forw[i] = f(x + s*e[i])\n\n g = (forw - f(x)) / s\n return g","def gradient(self):\n functional = self\n\n class KLCCGradient(Operator):\n\n \"\"\"The gradient operator of this functional.\"\"\"\n\n def __init__(self):\n \"\"\"Initialize a new instance.\"\"\"\n super().__init__(functional.domain, functional.domain,\n linear=False)\n\n def _call(self, x):\n \"\"\"Apply the gradient operator to the given point.\n\n The gradient is not defined in points where one or more\n components are larger than or equal to one.\n \"\"\"\n if functional.prior is None:\n return 1.0 / (1 - x)\n else:\n return functional.prior / (1 - x)\n\n return KLCCGradient()","def compute_gradient(self, grad=None):\n if grad is None:\n grad = backend.ones_like(self.output_value)\n x, = self.input_nodes[0].output_value\n return backend.exp(x) * grad","def gradient(data_x, data_y, parameters):\n return data_x.T @ (data_x @ parameters - data_y) / data_x.shape[0]","def approx_grad_reg(theta, X, y, _lambda):\n grad_a = np.array([(cost_reg(theta + e, X, y, _lambda) - cost_reg(theta - e, X, y, _lambda)) / (2 * 1e-5)\n for e in np.identity(len(theta)) * 1e-5])\n return grad_a","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 compute_gradient(self, function, arguments):","def lr_cost_function(theta, X, y, learning_rate):\n m = len(y) # number of training examples\n # You need to return the following variables correctly \n J = 0\n grad = np.zeros(theta.shape)\n h = sigmoid(np.dot(X, theta))\n\n #Compute cost:\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\n J = first + second\n \n #Compute gradient\n grad = np.dot((h-y).T, X)/m\n grad = grad.T\n grad[1:] += (learning_rate/m)*theta[1:]\n return float(J), grad","def compute_cost_derivative(AL, Y):\n pass","def gradient(self):\n functional = self\n\n class KLGradient(Operator):\n\n \"\"\"The gradient operator of this functional.\"\"\"\n\n def __init__(self):\n \"\"\"Initialize a new instance.\"\"\"\n super().__init__(functional.domain, functional.domain,\n linear=False)\n\n def _call(self, x):\n \"\"\"Apply the gradient operator to the given point.\n The gradient is not defined in points where one or more\n components are non-positive.\n \"\"\"\n if functional.prior is None:\n return (-1.0) / x + 1\n else:\n return (-functional.prior) / x + 1\n\n return KLGradient()","def loss_gradient(self, x, y):\n x_preproc = self._apply_processing(x)\n x_defences, y_defences = self._apply_defences(x_preproc, y, fit=False)\n\n # Adjust the shape of y for loss functions that do not take labels in one-hot encoding\n if self._reduce_labels:\n y_defences = np.argmax(y_defences, axis=1)\n\n grads = self._loss_grads([x_defences, y_defences])[0]\n grads = self._apply_defences_gradient(x_preproc, grads)\n grads = self._apply_processing_gradient(grads)\n assert grads.shape == x_preproc.shape\n\n return grads","def calculate_gradient(y, tx, w): \n return tx.T@(sigmoid(tx@w)-y)","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 grad(\n cost: Optional[Variable],\n wrt: Union[Variable, Sequence[Variable]],\n consider_constant: Optional[Sequence[Variable]] = None,\n disconnected_inputs: Literal[\"ignore\", \"warn\", \"raise\"] = \"raise\",\n add_names: bool = True,\n known_grads: Optional[Mapping[Variable, Variable]] = None,\n return_disconnected: Literal[\"none\", \"zero\", \"disconnected\"] = \"zero\",\n null_gradients: Literal[\"raise\", \"return\"] = \"raise\",\n) -> Union[Optional[Variable], Sequence[Optional[Variable]]]:\n t0 = time.perf_counter()\n\n if cost is None:\n if known_grads is None:\n raise ValueError(\"cost and known_grads can't both be None.\")\n\n if cost is not None and isinstance(cost.type, NullType):\n raise ValueError(\n \"Can't differentiate a NaN cost. \"\n f\"Cost is NaN because {cost.type.why_null}\"\n )\n\n if cost is not None and cost.type.ndim != 0:\n raise TypeError(\"Cost must be a scalar.\")\n\n if not isinstance(wrt, Sequence):\n _wrt: List[Variable] = [wrt]\n else:\n _wrt = [x for x in wrt]\n\n outputs = []\n if cost is not None:\n outputs.append(cost)\n if known_grads is not None:\n outputs.extend(list(known_grads.keys()))\n\n var_to_app_to_idx = _populate_var_to_app_to_idx(outputs, _wrt, consider_constant)\n\n # build a dict mapping var to the gradient of cost with respect to var\n grad_dict = {}\n\n if known_grads is None:\n known_grads = {}\n\n assert isinstance(known_grads, dict)\n\n # The gradient of the cost is 1 unless specified otherwise by known_grads.\n if cost is not None:\n if cost in known_grads:\n g_cost = known_grads[cost]\n else:\n g_cost = _float_ones_like(cost)\n # g_cost may be Disconnected or NullType. A creative use of the\n # function, sure, but nonetheless one we can and should support.\n # So before we try to cast it make sure it even has a dtype\n if (\n hasattr(g_cost.type, \"dtype\")\n and cost.type.dtype in aesara.tensor.type.continuous_dtypes\n ):\n # Here we enforce the constraint that floating point variables\n # have the same dtype as their gradient.\n g_cost = g_cost.astype(cost.type.dtype)\n # DO NOT enforce g_cost to be 0 if cost is an integer.\n # This is to be enforced by the Op.grad method for the\n # Op that outputs cost.\n if hasattr(g_cost.type, \"dtype\"):\n assert g_cost.type.dtype in aesara.tensor.type.continuous_dtypes\n\n grad_dict[cost] = g_cost\n\n for var in known_grads:\n g_var = known_grads[var]\n\n if not hasattr(g_var, \"type\"):\n raise TypeError(\n \"output grads must be aesara variables.\"\n f\"Ambiguous whether {type(g_var)} should be made into tensor\"\n \" or sparse aesara variable\"\n )\n\n if not isinstance(\n g_var.type, (NullType, DisconnectedType)\n ) and \"float\" not in str(g_var.type.dtype):\n raise TypeError(\n \"Gradients must always be NullType, \"\n \"DisconnectedType, or continuous, but grad was \"\n \"given a known_grad of type \" + str(g_var.type)\n )\n\n # DO NOT check that these gradients are equal to 0 if var is int\n # The gradient is allowed to be non-zero on var in that case\n # Ops outputting var should not backpropagate its gradient further\n # but that is enforced elsewhere (grep for only_connected_to_int)\n\n grad_dict[var] = g_var\n\n def handle_disconnected(var):\n message = (\n \"grad method was asked to compute the gradient \"\n \"with respect to a variable that is not part of \"\n \"the computational graph of the cost, or is used \"\n f\"only by a non-differentiable operator: {var}\"\n )\n if disconnected_inputs == \"ignore\":\n pass\n elif disconnected_inputs == \"warn\":\n warnings.warn(message, stacklevel=2)\n elif disconnected_inputs == \"raise\":\n message = utils.get_variable_trace_string(var)\n raise DisconnectedInputError(message)\n else:\n raise ValueError(\n \"Invalid value for keyword \"\n \"'disconnected_inputs', valid values are \"\n \"'ignore', 'warn' and 'raise'.\"\n )\n\n # variables that do not influence the cost have zero gradient.\n # if wrt is such a variable, populate the grad_dict with this info\n # so that wrt not being in var_to_app_to_idx won't cause an error below\n # according to the flag, possibly raise an error if wrt is disconnected\n for elem in _wrt:\n if elem not in var_to_app_to_idx and elem is not cost and elem not in grad_dict:\n handle_disconnected(elem)\n grad_dict[elem] = disconnected_type()\n\n cost_name = None\n if add_names and cost is not None:\n cost_name = cost.name\n\n # Make sure we didn't initialize the grad_dict with any ints\n # The gradient may NEVER be an int, even if the variable is an int.\n # Read the Op contract and talk to Ian Goodfellow before changing this!\n for var in grad_dict:\n g = grad_dict[var]\n if hasattr(g.type, \"dtype\"):\n assert g.type.dtype in aesara.tensor.type.float_dtypes\n\n _rval: Sequence[Variable] = _populate_grad_dict(\n var_to_app_to_idx, grad_dict, _wrt, cost_name\n )\n\n rval: MutableSequence[Optional[Variable]] = list(_rval)\n\n for i in range(len(_rval)):\n if isinstance(_rval[i].type, NullType):\n if null_gradients == \"raise\":\n raise NullTypeGradError(\n f\"`grad` encountered a NaN. {_rval[i].type.why_null}\"\n )\n else:\n assert null_gradients == \"return\"\n if isinstance(_rval[i].type, DisconnectedType):\n handle_disconnected(_rval[i])\n if return_disconnected == \"zero\":\n rval[i] = _float_zeros_like(_wrt[i])\n elif return_disconnected.lower() == \"none\":\n rval[i] = None\n else:\n assert return_disconnected.lower() == \"disconnected\"\n\n t1 = time.perf_counter()\n global grad_time\n grad_time += t1 - t0\n\n if isinstance(wrt, tuple):\n return tuple(rval)\n elif not isinstance(wrt, list):\n return rval[0]\n\n return rval","def gradient(self, x, Y):\n if self.is_sparse:\n x = x.todense()\n Y = Y.todense()\n assert(len(shape(x))==1)\n assert(len(shape(Y))==2)\n assert(len(x)==shape(Y)[1])\n \n x_2d=reshape(x, (1, len(x)))\n k = self.kernel(x_2d, Y)\n differences = Y - x\n G = (1.0 / self.width ** 2) * (k.T * differences)\n return G","def compute_gradient(self):\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 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 compute_cost_and_grad_with_reg(theta, X, y, lambda_):\n m = X.shape[0]\n y_hat = sigmoid(X @ theta.T)\n J = - (1 / m) * np.sum(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat)) + np.sum(lambda_ / (2 * m) * theta[1:] ** 2)\n temp = theta\n temp[0] = 0\n grad = (1 / m) * X.T @ (y_hat - y) + lambda_ / m * temp\n return J, grad","def gradient_descent(x0,df,rate=0.1,max_iters=1000,min_step=1e-6,max_step=1e5,\n projection=None,trajectory=False,step_history=False,f=None,\n cost_history=False,feedback=False,plot_history=False):\n if feedback is True:\n print(\"gd.gradient_descent():\")\n if f is not None:\n assert callable(f)\n fx0 = f(x0)\n if feedback is True:\n print(f\" initial cost = {fx0:.2e}\")\n if projection is not None:\n assert callable(projection)\n project = True\n else:\n project = False\n if trajectory is True:\n xx = [x0.copy()]\n if step_history is True:\n steps = []\n if cost_history is True:\n assert callable(f)\n fx = [fx0]\n\n x = x0.copy()\n for i in range(max_iters):\n dx = -rate*df(x)\n if project is True:\n x0 = x.copy()\n x = projection(x0+dx)\n dx = x-x0\n else:\n x += dx\n if trajectory is True:\n xx.append(x.copy())\n if cost_history is True:\n fx += [f(x)]\n step_size = np.linalg.norm(dx)\n if step_history is True:\n steps += [step_size]\n if step_size < min_step or step_size > max_step:\n break\n\n results = dict()\n results['output'] = x\n if trajectory is True:\n results['trajectory'] = xx\n if cost_history is True:\n results['cost_history'] = fx\n if step_history is True:\n results['step_history'] = steps\n if plot_history is True:\n assert step_history is True or cost_history is True\n plt.figure()\n if step_history is True:\n plt.semilogy(steps,label='step size')\n if cost_history is True:\n plt.semilogy(fx,label='cost')\n plt.xlabel('iteration number')\n plt.title('Gradient Descent')\n plt.legend()\n results['figure'] = plt\n plt.show(block=False)\n \n if feedback is True:\n if f is not None:\n print(f\" final cost = {f(x):.2e}\")\n \n return results","def costFunction(self, x, y ):\n self.yEst = self.forward_propagate(x)\n sqErrors = ( self.yEst - y ) ** 2\n J = sqErrors.sum() / 2\n return J","def gradient_descent(features, values, theta, alpha, num_iterations):\n m = len(values)\n cost_history = []\n\n for i in range(num_iterations):\n predicted_values = np.dot(features, theta)\n delta = alpha / m * np.dot((predicted_values - values), features)\n theta = theta - delta\n cost = compute_cost(features, values, theta)\n cost_history.append(cost)\n return theta, pandas.Series(cost_history)","def gradient(cls, x):\n return np.minimum(-2.5 < x, x < 2.5) * 0.2","def get_gradient(self, y, x, weight):\n y = np.reshape(y, (len(y),))\n return np.dot(x.T, sigmoid(np.dot(x, weight)) - y) \\\n + self.regularizer.get_gradient(weight)","def gradient(self):\n functional = self\n\n class KLCrossEntCCGradient(Operator):\n\n \"\"\"The gradient operator of this functional.\"\"\"\n\n def __init__(self):\n \"\"\"Initialize a new instance.\"\"\"\n super().__init__(functional.domain, functional.domain,\n linear=False)\n\n def _call(self, x):\n \"\"\"Apply the gradient operator to the given point.\"\"\"\n if functional.prior is None:\n return np.exp(x)\n else:\n return functional.prior * np.exp(x)\n\n return KLCrossEntCCGradient()","def gradient(cls, x):\n return np.minimum(-1. < x, x < 1.) * 1.","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 gradient_descent(features, values, theta, alpha, num_iterations):\n \n # number of points\n npoints = len(values)\n \n # intialize cost history\n cost_history = []\n \n # num_interations iterations\n for iiter in range(num_iterations):\n \n # compute and store cost\n cost = compute_cost(features, values, theta)\n cost_history.append(cost)\n \n # update values of theta\n values_predicted = np.dot(features, theta)\n theta = theta + (alpha/npoints)*(np.dot(values - values_predicted,features))\n \n return theta, pandas.Series(cost_history)","def gradient(cls, x):\n return np.multiply(1, x > 0)","def eval_numerical_gradient(f, x, verbose = True, h = 0.00001):\n fx = f(x) # evaluate function value at original point\n grad = np.zeros_like(x) # iterate over all indexese in x\n it = np.nditer(x, flags = ['multi_index'], op_flags = ['readwrite'])\n while not it.finished:\n # evaluate function at x+h\n ix = it.multi_index\n oldval = x[ix]\n x[ix] = oldval + h # increment by h\n fxph = f(x) # evaluate f(x+h)\n x[ix] = oldval - h\n fxmh = f(x) # evaluate f(x-h)\n x[ix] = oldval # restore\n \n #compute the partial derivative with centered fromula.\n grad[ix] = (fxph - fxmh) / (2 * h)\n if verbose:\n print(ix, grad[ix])\n it.iternext()\n return grad","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 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 _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 gradient_ascent(self, w, X, y, lr):\r\n # INSERT YOUR CODE HERE\r\n #raise Exception('Function not yet implemented!')\r\n # gradient = x_j*(y-σ(wTX))\r\n return np.dot(X.T, y-self.sigmoid(np.dot(X, w)))","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 gradient(theta, x, y):\n m = len(y)\n n = len(theta)\n z = theta.dot(x.T)\n grad = np.zeros(n)\n for i in xrange(m):\n grad += (g(z[i]) - y[i]) * x[i]\n return 1. / m * grad","def eval_numerical_gradient(f, x, verbose=True, h=0.00001):\n\n fx = f(x) # evaluate function value at original point\n grad = np.zeros_like(x)\n # iterate over all indexes in x\n it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])\n while not it.finished:\n\n # evaluate function at x+h\n ix = it.multi_index\n oldval = x[ix]\n x[ix] = oldval + h # increment by h\n fxph = f(x) # evalute f(x + h)\n x[ix] = oldval - h\n fxmh = f(x) # evaluate f(x - h)\n x[ix] = oldval # restore\n\n # compute the partial derivative with centered formula\n grad[ix] = (fxph - fxmh) / (2 * h) # the slope\n if verbose:\n print(ix, grad[ix])\n it.iternext() # step to next dimension\n\n return grad","def cost_gradient_thread(self, data_XYt):\n return self.cost_gradient(data_XYt[0], data_XYt[1], thread_scale=data_XYt[2])","def grad_sigmoid(self):\n grad = self.sigmoid(self.x) * (1 - self.sigmoid(self.x))\n return grad","def grad(self, x):\n return self.smoothed_grad(x)","def grad(self, x):\n return self.smoothed_grad(x)","def grad(self, x):\n return self.smoothed_grad(x)","def gradient(self):\n functional = self\n\n class KLCrossEntropyGradient(Operator):\n\n \"\"\"The gradient operator of this functional.\"\"\"\n\n def __init__(self):\n \"\"\"Initialize a new instance.\"\"\"\n super().__init__(functional.domain, functional.domain,\n linear=False)\n\n def _call(self, x):\n \"\"\"Apply the gradient operator to the given point.\n\n The gradient is not defined in for points with components less\n than or equal to zero.\n \"\"\"\n if functional.prior is None:\n tmp = np.log(x)\n else:\n tmp = np.log(x / functional.prior)\n\n if np.all(np.isfinite(tmp)):\n return tmp\n else:\n # The derivative is not defined.\n raise ValueError('The gradient of the Kullback-Leibler '\n 'Cross Entropy functional is not defined '\n 'for `x` with one or more components '\n 'less than or equal to zero.'.format(x))\n\n return KLCrossEntropyGradient()","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 gradient_descent(self, X ,eta, tol,iter):\n gd=[]\n gd_x=[X]\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 \n prev_x=X\n new_x=prev_x -(learn_rate*first_derivative(prev_x))\n gd_x.append(new_x)\n #print(\"prev_x = \",prev_x,\" Next x = \",new_x)\n for i in range(iter):\n prev_x=new_x\n #print(prev_x)\n new_x=prev_x -(learn_rate*first_derivative(prev_x))\n gd_x.append(new_x)\n # print(\"x = \",new_x,\"Gradient =\",learn_rate*self.func(prev_x))\n if abs(self.func(new_x)) <= self.func(tol) :\n break\n iteration=iteration+1\n #print(\"Best at GD x= \",new_x)\n gd.append(gd_x)\n gd.append(new_x)\n gd.append(iteration)\n\n return gd","def sigmoid_grad(x):\n sig = sigmoid(x)\n return np.multiply(sig, 1 - sig)","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 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_reg_gradient(self):\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) + self.lambda_reg * self.w # add regularization term","def gradients(f, x, grad_ys=None):\n\n if isinstance(x, list):\n grad = tf.gradients(f, x, grad_ys=grad_ys)\n for i in range(len(x)):\n if grad[i] is None:\n grad[i] = tf.zeros_like(x[i])\n return grad\n else:\n grad = tf.gradients(f, x, grad_ys=grad_ys)[0]\n if grad is None:\n return tf.zeros_like(x)\n else:\n return grad","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 (w, x, y):\n (n,d) = x.shape\n g = np.zeros(d)\n for i in range(0,d):\n g[i] = (w*x-y)*np.transpose(x[i])\n g += 0.5*w\n return g","def calculate_gradient(y, tx, w):\n return tx.T.dot(sigmoid(tx.dot(w))-np.reshape(y,(len(y),1)))","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\n dx = backend.dot(grad, backend.transpose(y))\n dy = backend.dot(backend.transpose(x), grad)\n\n return [dx, dy]","def gradient(self, node, output_grad):\r\n \"\"\"TODO: Your code here\"\"\"\r\n return [output_grad * exp(node.inputs[0])]","def grad_ReLU(self):\n grad = np.where(self.x > 0, 1, 0)\n return grad","def compute_gradient(self, grad=None):\n x = self.input_nodes[0].output_value\n if grad is None:\n grad = backend.ones_like(self.output_value)\n if x == float('inf') or x == float('-inf'):\n return grad * float('inf')\n else:\n return grad * 1 / x","def gradient(self):\n return ConstantFunctional(self.domain, self.scalar)","def gradient_model(x, I_0, a, lam):\n if np.any(np.array(x) < 0):\n raise RuntimeError('x must be positive')\n if np.any(np.array([I_0, a, lam]) < 0):\n raise RuntimeError('all params must be positive')\n return a + I_0 * np.exp(-x / lam)","def _gradient_descent(self, X, y, epochs, learning_rate, batch_size):\n num_feats = X.shape[1]\n num_samples = X.shape[0]\n\n y = y.reshape(num_samples, 1)\n W = np.random.rand(num_feats, 1)\n training_loss_epochs = []\n\n for ix in range(epochs):\n shuffled_ix = (np.arange(0, len(X)))\n np.random.shuffle(shuffled_ix)\n X = X[shuffled_ix, :]\n y = y[shuffled_ix, :]\n\n for batch_ix in np.arange(0, X.shape[0], batch_size):\n dW = self._compute_gradient(W, X[batch_ix:batch_ix + batch_size], y[batch_ix:batch_ix + batch_size])\n W -= learning_rate * dW\n\n if ix % 10 == 0:\n y_pred = np.dot(X, W)\n training_loss = self.mse(y, y_pred)\n print('epoch {0} : training loss {1}'.format(ix, training_loss))\n training_loss_epochs.append(training_loss[0])\n\n self.weights = W\n self.training_loss = training_loss_epochs\n return None","def 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"],"string":"[\n \"def gradient(self, x):\\n pass\",\n \"def gradient(cls, x):\\n y = Sigmoid.apply(x)\\n return np.multiply(y, 1 - y)\",\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 gradientdescent(cost_func, theta, args=(), delta_func = 0):\\n step = 1\\n old_cost = 0\\n while True:\\n theta_old = theta.copy()\\n cost = cost_func(theta, *args)\\n delta = delta_func(theta, *args)\\n theta = theta - step * delta\\n if cost > old_cost and old_cost != 0:\\n step = step*0.7\\n if np.allclose(theta_old, theta):\\n break\\n old_cost = cost\\n return theta\",\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 compute_gradient(theta, X, y):\\n m = X.shape[0]\\n grad_theta = np.dot(X.transpose(), (np.dot(X, theta) - y)) / m\\n #print theta, grad_theta, objective_function(theta, X, y)\\n return grad_theta\",\n \"def logit_cost_grad(self, theta, X, y):\\n\\n grad = np.zeros(len(theta))\\n\\n ### YOUR CODE HERE\\n sig = utils.sigmoid(theta)\\n # sig = np.subtract(sig, y)\\n sig = sig - y\\n grad = np.dot(X.T, sig) + 2 * self.params['lamb'] * self.regularizer[1](self.weights)\\n ### END YOUR CODE\\n\\n return grad\",\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 gradient_function(theta, X, y):\\n\\n grad = None\\n #######################################################################\\n # TODO: #\\n # Compute the gradient for a particular choice of theta. #\\n # 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 \\n theta = theta[:, np.newaxis]\\n \\n thetatrans = theta.T\\n Xtrans = X.T\\n \\n MulThetaX = np.dot(thetatrans, Xtrans)\\n \\n h = sigmoid(MulThetaX)\\n \\n grad = (y - h) * Xtrans\\n\\n #######################################################################\\n # END OF YOUR CODE #\\n #######################################################################\\n return grad\",\n \"def gradient(w, x, t):\\n return 2 * np.dot(x.T, (nn(x, w) - t))\",\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 gradientFunctionReg(theta, X, y, Lambda):\\n m = len(y) # number of training examples\\n grad = np.zeros(theta.shape[0])\\n theta = np.transpose(theta)\\n sum_1 = 0\\n X = X.values\\n y = y.values\\n #calcuate the theta_0 \\n# ====================== YOUR CODE HERE ======================\\n# Instructions: Compute the gradient of a particular choice of theta.\\n# Compute the partial derivatives and set grad to the partial\\n# derivatives of the cost w.r.t. each parameter in theta\\n for i in range(theta.shape[0]):\\n if i == 0:\\n for j in range(m):\\n sum_1 += (sigmoid(np.dot(X[j],theta)) - y[j]) * X[j,i]\\n else:\\n for j in range(m):\\n sum_1 += (sigmoid(np.dot(X[j],theta)) - y[j]) * X[j,i] + Lambda*theta[i]\\n grad[i] = sum_1/m\\n sum_1 = 0\\n\\n# =============================================================\\n\\n return grad\",\n \"def gradient(cls, x):\\n return 1 - TanH.apply(x) ** 2\",\n \"def objective_function_gradients(self, x):\\n self._set_params_transformed(x)\\n LL_gradients = self._transform_gradients(self._log_likelihood_gradients())\\n prior_gradients = self._transform_gradients(self._log_prior_gradients())\\n return - LL_gradients - prior_gradients\",\n \"def gradient(self, x):\\n return 0.0\",\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 gradient(self, x):\\n g = self._grad(\\n time_series=self.observed_data,\\n a=x[0],\\n b=x[1],\\n c=x[2],\\n sigma=self.sigma\\n )\\n return g\",\n \"def grad(x):\\n\\n return x - np.arange(1, cfg.n + 1, dtype=np.float_)\",\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 gradient(self, x, i=None):\\n self.set_parameters(x=x)\\n gradient = self.gradient_loss()\\n if self.add_bias:\\n gradient[1:] += self.alpha * self.gradient_regularizer()\\n else:\\n gradient += self.alpha * self.gradient_regularizer()\\n if i is not None:\\n return gradient.ravel()[i]\\n return gradient.ravel()\",\n \"def numerical_gradient(f, x: np.ndarray):\\n h = 1e-4\\n grad = np.zeros_like(x)\\n for i in range(x.size):\\n tmp_val = x.flat[i]\\n x.flat[i] = tmp_val + h\\n fxh1 = f(x)\\n\\n x.flat[i] = tmp_val - h\\n fxh2 = f(x)\\n grad.flat[i] = (fxh1 - fxh2) / (2 * h)\\n x.flat[i] = tmp_val\\n return grad\",\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 objective_function_gradients(self, x):\\r\\n try:\\r\\n self._set_params_transformed(x)\\r\\n obj_grads = -self._transform_gradients(self._log_likelihood_gradients() + self._log_prior_gradients())\\r\\n self._fail_count = 0\\r\\n except (LinAlgError, ZeroDivisionError, ValueError) as e:\\r\\n if self._fail_count >= self._allowed_failures:\\r\\n raise e\\r\\n self._fail_count += 1\\r\\n obj_grads = np.clip(-self._transform_gradients(self._log_likelihood_gradients() + self._log_prior_gradients()), -1e100, 1e100)\\r\\n return obj_grads\",\n \"def approx_grad(theta, X, y):\\n grad_a = np.array([(cost(theta + e, X, y) - cost(theta - e, X, y)) / (2 * 1e-5)\\n for e in np.identity(len(theta)) * 1e-5])\\n return grad_a\",\n \"def gradient(theta, X, y, learning_rate):\\n m = len(y)\\n\\n theta = theta.reshape((-1,1))\\n grad = np.zeros(theta.shape)\\n h = sigmoid(np.dot(X, theta)) \\n \\n grad = np.dot((h-y).T, X)/m\\n grad = grad.T\\n grad[1:] += (learning_rate/m)*theta[1:]\\n return grad\",\n \"def grad(self, x):\\n grad = np.zeros((x.shape[0], 1))\\n grad[x >= utils.TOLERANCE] = 1.0\\n grad[x <= -utils.TOLERANCE] = -1.0\\n between = (x > -utils.TOLERANCE) & (x < utils.TOLERANCE)\\n grad[between] = self.rng(between.sum())\\n\\n return self.l * grad\",\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 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 eval_numerical_gradient(f,x):\\n\\n\\tgrad = np.zeros(x.shape)\\n\\th = 0.0001\\n\\n\\t# iterate over all indexes in x\\n\\tit = np.nditer(x, flag = ['multi_index'], op_flags = ['readwrite'])\\n\\n\\twhile not it.finished:\\n\\t\\tix = it.multi_index\\n\\t\\told_value = x[ix]\\n\\n\\t\\tx[ix] = old_value + h\\n\\t\\tfxh_left = f(x)\\n\\n\\t\\tx[ix] = old_value - h\\n\\t\\tfxh_right = f(x)\\n\\n\\t\\tx[ix] = old_value\\n\\n\\t\\t# compute the partial derivative\\n\\t\\tgrad[ix] = (fxh_left - fxh_right) / (2 * h)\\n\\t\\tit.iterate()\\n\\n\\treturn grad\",\n \"def gradient(self, x_in):\\r\\n\\r\\n return 1 - torch.pow(self.forward(x_in), 2)\",\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 calc_gradient_at(self, x: np.ndarray) -> np.ndarray:\\n\\n if self.gradient_f:\\n # if the problem has knowledge about the gradient, use it directly without approximation\\n return self.gradient_f(x)\\n\\n return gradient_approximation(self.f, x)\",\n \"def lrCostFunction(theta,X,y, lambda_reg):\\n m = np.size(y)\\n grad = np.zeros(np.size((theta)))\\n J_base, grad = costFunction(theta, X, y)\\n \\n\\n reg_cost = (lambda_reg / (2.0 * m)) * np.sum(theta[1:] ** 2)\\n \\n reg_gradient = (lambda_reg / m) * theta\\n reg_gradient[0] = 0\\n cost = J_base + reg_cost\\n return cost, grad + reg_gradient\",\n \"def gradient_descent(self, x, y):\\n # Initialize weights vector\\n self.weights = np.zeros(len(x[0]))\\n\\n # Storing number of training example in a variable \\n n = len(x)\\n\\n # Initiate variables to keep track of the current and smallest loss recorded\\n lowest_loss = sys.float_info.max\\n current_loss = sys.float_info.max\\n\\n # Initiate variables to keep track of step sizes\\n norm = sys.float_info.max\\n smallest_norm = sys.float_info.max\\n\\n # Initiate list variable that stores all previous weights\\n prev_weights = []\\n\\n # Initiate list that stores all the errors. \\n errors = []\\n \\n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\\n k_loss_iteration = 1\\n\\n # Learning loop\\n for i in range(self.max_iter):\\n\\n # Append current weights\\n prev_weights.append(np.array(self.weights))\\n \\n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\\n\\n # Compute the error of the Cost Function and store it in a list\\n current_loss = self.cost(x,y)\\n\\n if len(errors) > 1 and current_loss > errors[-1]:\\n k_loss_iteration += 1\\n else: \\n k_loss_iteration = 1\\n\\n errors.append(current_loss)\\n \\n # Track smallest loss\\n if current_loss < lowest_loss:\\n lowest_loss = current_loss\\n\\n # Compute the L2 Norm of the difference between current weights and previous weights\\n norm = np.linalg.norm(self.weights - prev_weights[-1])\\n\\n # Track smallest step size and set it as error threshold\\n if norm < smallest_norm:\\n smallest_norm = norm\\n\\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\\n if self.error_threshold != None and norm < self.error_threshold:\\n print(\\\"Converged after {} iterations!\\\".format(i))\\n break\\n\\n # stop if error hasn't gone down in k iterations\\n if k_loss_iteration >= 10:\\n print(k_loss_iteration + \\\" iterations of loss not decreasing on {}th itertion.\\\".format(i))\\n break\\n\\n # Log final weights\\n print(\\\"Final norm: \\\" + str(norm) + \\\"\\\\nSmallest step size recorded: \\\" + str(smallest_norm) + \\\"\\\\nFinal error: \\\" + str(current_loss) + \\\"\\\\nLowest error recorded: \\\" + str(lowest_loss) + \\\"\\\\nNumber of epochs: \\\" + str(len(errors)) + \\\"\\\\nFinal weights: \\\" + str(self.weights))\",\n \"def gradient_descent(X, y, theta, learning_rate, num_iters, lambda_reg):\\n thetas = [theta]\\n cost = np.zeros(num_iters)\\n\\n J = mean_cross_entropy_costs(X, y, lambda_reg)\\n cost[0] = J(thetas[0])\\n for i in range(1, num_iters):\\n thetas.append(compute_new_theta(X, y, thetas[i - 1], learning_rate, lambda_reg))\\n cost[i] = J(thetas[i])\\n return cost, thetas\",\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 gradFun(self, S, x):\",\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 costFunction(self,theta, X, y): \\n m = len(y)\\n h = self.sigmoid(X@theta)\\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \\n # grad = 1/ m * X.T @ (h - y)\\n return J\",\n \"def gradient_descent(data_x, data_y, parameters, learn_rate, nb_iterations):\\n\\n # Cost history\\n cost_tracking = np.zeros(nb_iterations)\\n\\n for _i in range(nb_iterations):\\n parameters -= learn_rate * gradient(data_x, data_y, parameters)\\n # recording the cost for each iteration\\n cost_tracking[_i] = cost_function(data_x, data_y, parameters)\\n\\n return parameters, cost_tracking\",\n \"def gradient(f, x, s=_DEFAULT_STEP):\\n x = np.asarray(x)\\n n = len(x)\\n e = np.eye(n)\\n\\n forw = np.zeros(n)\\n for i in range(n):\\n forw[i] = f(x + s*e[i])\\n\\n g = (forw - f(x)) / s\\n return g\",\n \"def gradient(self):\\n functional = self\\n\\n class KLCCGradient(Operator):\\n\\n \\\"\\\"\\\"The gradient operator of this functional.\\\"\\\"\\\"\\n\\n def __init__(self):\\n \\\"\\\"\\\"Initialize a new instance.\\\"\\\"\\\"\\n super().__init__(functional.domain, functional.domain,\\n linear=False)\\n\\n def _call(self, x):\\n \\\"\\\"\\\"Apply the gradient operator to the given point.\\n\\n The gradient is not defined in points where one or more\\n components are larger than or equal to one.\\n \\\"\\\"\\\"\\n if functional.prior is None:\\n return 1.0 / (1 - x)\\n else:\\n return functional.prior / (1 - x)\\n\\n return KLCCGradient()\",\n \"def compute_gradient(self, grad=None):\\n if grad is None:\\n grad = backend.ones_like(self.output_value)\\n x, = self.input_nodes[0].output_value\\n return backend.exp(x) * grad\",\n \"def gradient(data_x, data_y, parameters):\\n return data_x.T @ (data_x @ parameters - data_y) / data_x.shape[0]\",\n \"def approx_grad_reg(theta, X, y, _lambda):\\n grad_a = np.array([(cost_reg(theta + e, X, y, _lambda) - cost_reg(theta - e, X, y, _lambda)) / (2 * 1e-5)\\n for e in np.identity(len(theta)) * 1e-5])\\n return grad_a\",\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 compute_gradient(self, function, arguments):\",\n \"def lr_cost_function(theta, X, y, learning_rate):\\n m = len(y) # number of training examples\\n # You need to return the following variables correctly \\n J = 0\\n grad = np.zeros(theta.shape)\\n h = sigmoid(np.dot(X, theta))\\n\\n #Compute cost:\\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\\n J = first + second\\n \\n #Compute gradient\\n grad = np.dot((h-y).T, X)/m\\n grad = grad.T\\n grad[1:] += (learning_rate/m)*theta[1:]\\n return float(J), grad\",\n \"def compute_cost_derivative(AL, Y):\\n pass\",\n \"def gradient(self):\\n functional = self\\n\\n class KLGradient(Operator):\\n\\n \\\"\\\"\\\"The gradient operator of this functional.\\\"\\\"\\\"\\n\\n def __init__(self):\\n \\\"\\\"\\\"Initialize a new instance.\\\"\\\"\\\"\\n super().__init__(functional.domain, functional.domain,\\n linear=False)\\n\\n def _call(self, x):\\n \\\"\\\"\\\"Apply the gradient operator to the given point.\\n The gradient is not defined in points where one or more\\n components are non-positive.\\n \\\"\\\"\\\"\\n if functional.prior is None:\\n return (-1.0) / x + 1\\n else:\\n return (-functional.prior) / x + 1\\n\\n return KLGradient()\",\n \"def loss_gradient(self, x, y):\\n x_preproc = self._apply_processing(x)\\n x_defences, y_defences = self._apply_defences(x_preproc, y, fit=False)\\n\\n # Adjust the shape of y for loss functions that do not take labels in one-hot encoding\\n if self._reduce_labels:\\n y_defences = np.argmax(y_defences, axis=1)\\n\\n grads = self._loss_grads([x_defences, y_defences])[0]\\n grads = self._apply_defences_gradient(x_preproc, grads)\\n grads = self._apply_processing_gradient(grads)\\n assert grads.shape == x_preproc.shape\\n\\n return grads\",\n \"def calculate_gradient(y, tx, w): \\n return tx.T@(sigmoid(tx@w)-y)\",\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 grad(\\n cost: Optional[Variable],\\n wrt: Union[Variable, Sequence[Variable]],\\n consider_constant: Optional[Sequence[Variable]] = None,\\n disconnected_inputs: Literal[\\\"ignore\\\", \\\"warn\\\", \\\"raise\\\"] = \\\"raise\\\",\\n add_names: bool = True,\\n known_grads: Optional[Mapping[Variable, Variable]] = None,\\n return_disconnected: Literal[\\\"none\\\", \\\"zero\\\", \\\"disconnected\\\"] = \\\"zero\\\",\\n null_gradients: Literal[\\\"raise\\\", \\\"return\\\"] = \\\"raise\\\",\\n) -> Union[Optional[Variable], Sequence[Optional[Variable]]]:\\n t0 = time.perf_counter()\\n\\n if cost is None:\\n if known_grads is None:\\n raise ValueError(\\\"cost and known_grads can't both be None.\\\")\\n\\n if cost is not None and isinstance(cost.type, NullType):\\n raise ValueError(\\n \\\"Can't differentiate a NaN cost. \\\"\\n f\\\"Cost is NaN because {cost.type.why_null}\\\"\\n )\\n\\n if cost is not None and cost.type.ndim != 0:\\n raise TypeError(\\\"Cost must be a scalar.\\\")\\n\\n if not isinstance(wrt, Sequence):\\n _wrt: List[Variable] = [wrt]\\n else:\\n _wrt = [x for x in wrt]\\n\\n outputs = []\\n if cost is not None:\\n outputs.append(cost)\\n if known_grads is not None:\\n outputs.extend(list(known_grads.keys()))\\n\\n var_to_app_to_idx = _populate_var_to_app_to_idx(outputs, _wrt, consider_constant)\\n\\n # build a dict mapping var to the gradient of cost with respect to var\\n grad_dict = {}\\n\\n if known_grads is None:\\n known_grads = {}\\n\\n assert isinstance(known_grads, dict)\\n\\n # The gradient of the cost is 1 unless specified otherwise by known_grads.\\n if cost is not None:\\n if cost in known_grads:\\n g_cost = known_grads[cost]\\n else:\\n g_cost = _float_ones_like(cost)\\n # g_cost may be Disconnected or NullType. A creative use of the\\n # function, sure, but nonetheless one we can and should support.\\n # So before we try to cast it make sure it even has a dtype\\n if (\\n hasattr(g_cost.type, \\\"dtype\\\")\\n and cost.type.dtype in aesara.tensor.type.continuous_dtypes\\n ):\\n # Here we enforce the constraint that floating point variables\\n # have the same dtype as their gradient.\\n g_cost = g_cost.astype(cost.type.dtype)\\n # DO NOT enforce g_cost to be 0 if cost is an integer.\\n # This is to be enforced by the Op.grad method for the\\n # Op that outputs cost.\\n if hasattr(g_cost.type, \\\"dtype\\\"):\\n assert g_cost.type.dtype in aesara.tensor.type.continuous_dtypes\\n\\n grad_dict[cost] = g_cost\\n\\n for var in known_grads:\\n g_var = known_grads[var]\\n\\n if not hasattr(g_var, \\\"type\\\"):\\n raise TypeError(\\n \\\"output grads must be aesara variables.\\\"\\n f\\\"Ambiguous whether {type(g_var)} should be made into tensor\\\"\\n \\\" or sparse aesara variable\\\"\\n )\\n\\n if not isinstance(\\n g_var.type, (NullType, DisconnectedType)\\n ) and \\\"float\\\" not in str(g_var.type.dtype):\\n raise TypeError(\\n \\\"Gradients must always be NullType, \\\"\\n \\\"DisconnectedType, or continuous, but grad was \\\"\\n \\\"given a known_grad of type \\\" + str(g_var.type)\\n )\\n\\n # DO NOT check that these gradients are equal to 0 if var is int\\n # The gradient is allowed to be non-zero on var in that case\\n # Ops outputting var should not backpropagate its gradient further\\n # but that is enforced elsewhere (grep for only_connected_to_int)\\n\\n grad_dict[var] = g_var\\n\\n def handle_disconnected(var):\\n message = (\\n \\\"grad method was asked to compute the gradient \\\"\\n \\\"with respect to a variable that is not part of \\\"\\n \\\"the computational graph of the cost, or is used \\\"\\n f\\\"only by a non-differentiable operator: {var}\\\"\\n )\\n if disconnected_inputs == \\\"ignore\\\":\\n pass\\n elif disconnected_inputs == \\\"warn\\\":\\n warnings.warn(message, stacklevel=2)\\n elif disconnected_inputs == \\\"raise\\\":\\n message = utils.get_variable_trace_string(var)\\n raise DisconnectedInputError(message)\\n else:\\n raise ValueError(\\n \\\"Invalid value for keyword \\\"\\n \\\"'disconnected_inputs', valid values are \\\"\\n \\\"'ignore', 'warn' and 'raise'.\\\"\\n )\\n\\n # variables that do not influence the cost have zero gradient.\\n # if wrt is such a variable, populate the grad_dict with this info\\n # so that wrt not being in var_to_app_to_idx won't cause an error below\\n # according to the flag, possibly raise an error if wrt is disconnected\\n for elem in _wrt:\\n if elem not in var_to_app_to_idx and elem is not cost and elem not in grad_dict:\\n handle_disconnected(elem)\\n grad_dict[elem] = disconnected_type()\\n\\n cost_name = None\\n if add_names and cost is not None:\\n cost_name = cost.name\\n\\n # Make sure we didn't initialize the grad_dict with any ints\\n # The gradient may NEVER be an int, even if the variable is an int.\\n # Read the Op contract and talk to Ian Goodfellow before changing this!\\n for var in grad_dict:\\n g = grad_dict[var]\\n if hasattr(g.type, \\\"dtype\\\"):\\n assert g.type.dtype in aesara.tensor.type.float_dtypes\\n\\n _rval: Sequence[Variable] = _populate_grad_dict(\\n var_to_app_to_idx, grad_dict, _wrt, cost_name\\n )\\n\\n rval: MutableSequence[Optional[Variable]] = list(_rval)\\n\\n for i in range(len(_rval)):\\n if isinstance(_rval[i].type, NullType):\\n if null_gradients == \\\"raise\\\":\\n raise NullTypeGradError(\\n f\\\"`grad` encountered a NaN. {_rval[i].type.why_null}\\\"\\n )\\n else:\\n assert null_gradients == \\\"return\\\"\\n if isinstance(_rval[i].type, DisconnectedType):\\n handle_disconnected(_rval[i])\\n if return_disconnected == \\\"zero\\\":\\n rval[i] = _float_zeros_like(_wrt[i])\\n elif return_disconnected.lower() == \\\"none\\\":\\n rval[i] = None\\n else:\\n assert return_disconnected.lower() == \\\"disconnected\\\"\\n\\n t1 = time.perf_counter()\\n global grad_time\\n grad_time += t1 - t0\\n\\n if isinstance(wrt, tuple):\\n return tuple(rval)\\n elif not isinstance(wrt, list):\\n return rval[0]\\n\\n return rval\",\n \"def gradient(self, x, Y):\\n if self.is_sparse:\\n x = x.todense()\\n Y = Y.todense()\\n assert(len(shape(x))==1)\\n assert(len(shape(Y))==2)\\n assert(len(x)==shape(Y)[1])\\n \\n x_2d=reshape(x, (1, len(x)))\\n k = self.kernel(x_2d, Y)\\n differences = Y - x\\n G = (1.0 / self.width ** 2) * (k.T * differences)\\n return G\",\n \"def compute_gradient(self):\\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 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 compute_cost_and_grad_with_reg(theta, X, y, lambda_):\\n m = X.shape[0]\\n y_hat = sigmoid(X @ theta.T)\\n J = - (1 / m) * np.sum(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat)) + np.sum(lambda_ / (2 * m) * theta[1:] ** 2)\\n temp = theta\\n temp[0] = 0\\n grad = (1 / m) * X.T @ (y_hat - y) + lambda_ / m * temp\\n return J, grad\",\n \"def gradient_descent(x0,df,rate=0.1,max_iters=1000,min_step=1e-6,max_step=1e5,\\n projection=None,trajectory=False,step_history=False,f=None,\\n cost_history=False,feedback=False,plot_history=False):\\n if feedback is True:\\n print(\\\"gd.gradient_descent():\\\")\\n if f is not None:\\n assert callable(f)\\n fx0 = f(x0)\\n if feedback is True:\\n print(f\\\" initial cost = {fx0:.2e}\\\")\\n if projection is not None:\\n assert callable(projection)\\n project = True\\n else:\\n project = False\\n if trajectory is True:\\n xx = [x0.copy()]\\n if step_history is True:\\n steps = []\\n if cost_history is True:\\n assert callable(f)\\n fx = [fx0]\\n\\n x = x0.copy()\\n for i in range(max_iters):\\n dx = -rate*df(x)\\n if project is True:\\n x0 = x.copy()\\n x = projection(x0+dx)\\n dx = x-x0\\n else:\\n x += dx\\n if trajectory is True:\\n xx.append(x.copy())\\n if cost_history is True:\\n fx += [f(x)]\\n step_size = np.linalg.norm(dx)\\n if step_history is True:\\n steps += [step_size]\\n if step_size < min_step or step_size > max_step:\\n break\\n\\n results = dict()\\n results['output'] = x\\n if trajectory is True:\\n results['trajectory'] = xx\\n if cost_history is True:\\n results['cost_history'] = fx\\n if step_history is True:\\n results['step_history'] = steps\\n if plot_history is True:\\n assert step_history is True or cost_history is True\\n plt.figure()\\n if step_history is True:\\n plt.semilogy(steps,label='step size')\\n if cost_history is True:\\n plt.semilogy(fx,label='cost')\\n plt.xlabel('iteration number')\\n plt.title('Gradient Descent')\\n plt.legend()\\n results['figure'] = plt\\n plt.show(block=False)\\n \\n if feedback is True:\\n if f is not None:\\n print(f\\\" final cost = {f(x):.2e}\\\")\\n \\n return results\",\n \"def costFunction(self, x, y ):\\n self.yEst = self.forward_propagate(x)\\n sqErrors = ( self.yEst - y ) ** 2\\n J = sqErrors.sum() / 2\\n return J\",\n \"def gradient_descent(features, values, theta, alpha, num_iterations):\\n m = len(values)\\n cost_history = []\\n\\n for i in range(num_iterations):\\n predicted_values = np.dot(features, theta)\\n delta = alpha / m * np.dot((predicted_values - values), features)\\n theta = theta - delta\\n cost = compute_cost(features, values, theta)\\n cost_history.append(cost)\\n return theta, pandas.Series(cost_history)\",\n \"def gradient(cls, x):\\n return np.minimum(-2.5 < x, x < 2.5) * 0.2\",\n \"def get_gradient(self, y, x, weight):\\n y = np.reshape(y, (len(y),))\\n return np.dot(x.T, sigmoid(np.dot(x, weight)) - y) \\\\\\n + self.regularizer.get_gradient(weight)\",\n \"def gradient(self):\\n functional = self\\n\\n class KLCrossEntCCGradient(Operator):\\n\\n \\\"\\\"\\\"The gradient operator of this functional.\\\"\\\"\\\"\\n\\n def __init__(self):\\n \\\"\\\"\\\"Initialize a new instance.\\\"\\\"\\\"\\n super().__init__(functional.domain, functional.domain,\\n linear=False)\\n\\n def _call(self, x):\\n \\\"\\\"\\\"Apply the gradient operator to the given point.\\\"\\\"\\\"\\n if functional.prior is None:\\n return np.exp(x)\\n else:\\n return functional.prior * np.exp(x)\\n\\n return KLCrossEntCCGradient()\",\n \"def gradient(cls, x):\\n return np.minimum(-1. < x, x < 1.) * 1.\",\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 gradient_descent(features, values, theta, alpha, num_iterations):\\n \\n # number of points\\n npoints = len(values)\\n \\n # intialize cost history\\n cost_history = []\\n \\n # num_interations iterations\\n for iiter in range(num_iterations):\\n \\n # compute and store cost\\n cost = compute_cost(features, values, theta)\\n cost_history.append(cost)\\n \\n # update values of theta\\n values_predicted = np.dot(features, theta)\\n theta = theta + (alpha/npoints)*(np.dot(values - values_predicted,features))\\n \\n return theta, pandas.Series(cost_history)\",\n \"def gradient(cls, x):\\n return np.multiply(1, x > 0)\",\n \"def eval_numerical_gradient(f, x, verbose = True, h = 0.00001):\\n fx = f(x) # evaluate function value at original point\\n grad = np.zeros_like(x) # iterate over all indexese in x\\n it = np.nditer(x, flags = ['multi_index'], op_flags = ['readwrite'])\\n while not it.finished:\\n # evaluate function at x+h\\n ix = it.multi_index\\n oldval = x[ix]\\n x[ix] = oldval + h # increment by h\\n fxph = f(x) # evaluate f(x+h)\\n x[ix] = oldval - h\\n fxmh = f(x) # evaluate f(x-h)\\n x[ix] = oldval # restore\\n \\n #compute the partial derivative with centered fromula.\\n grad[ix] = (fxph - fxmh) / (2 * h)\\n if verbose:\\n print(ix, grad[ix])\\n it.iternext()\\n return grad\",\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 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 _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 gradient_ascent(self, w, X, y, lr):\\r\\n # INSERT YOUR CODE HERE\\r\\n #raise Exception('Function not yet implemented!')\\r\\n # gradient = x_j*(y-σ(wTX))\\r\\n return np.dot(X.T, y-self.sigmoid(np.dot(X, w)))\",\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 gradient(theta, x, y):\\n m = len(y)\\n n = len(theta)\\n z = theta.dot(x.T)\\n grad = np.zeros(n)\\n for i in xrange(m):\\n grad += (g(z[i]) - y[i]) * x[i]\\n return 1. / m * grad\",\n \"def eval_numerical_gradient(f, x, verbose=True, h=0.00001):\\n\\n fx = f(x) # evaluate function value at original point\\n grad = np.zeros_like(x)\\n # iterate over all indexes in x\\n it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])\\n while not it.finished:\\n\\n # evaluate function at x+h\\n ix = it.multi_index\\n oldval = x[ix]\\n x[ix] = oldval + h # increment by h\\n fxph = f(x) # evalute f(x + h)\\n x[ix] = oldval - h\\n fxmh = f(x) # evaluate f(x - h)\\n x[ix] = oldval # restore\\n\\n # compute the partial derivative with centered formula\\n grad[ix] = (fxph - fxmh) / (2 * h) # the slope\\n if verbose:\\n print(ix, grad[ix])\\n it.iternext() # step to next dimension\\n\\n return grad\",\n \"def cost_gradient_thread(self, data_XYt):\\n return self.cost_gradient(data_XYt[0], data_XYt[1], thread_scale=data_XYt[2])\",\n \"def grad_sigmoid(self):\\n grad = self.sigmoid(self.x) * (1 - self.sigmoid(self.x))\\n return grad\",\n \"def grad(self, x):\\n return self.smoothed_grad(x)\",\n \"def grad(self, x):\\n return self.smoothed_grad(x)\",\n \"def grad(self, x):\\n return self.smoothed_grad(x)\",\n \"def gradient(self):\\n functional = self\\n\\n class KLCrossEntropyGradient(Operator):\\n\\n \\\"\\\"\\\"The gradient operator of this functional.\\\"\\\"\\\"\\n\\n def __init__(self):\\n \\\"\\\"\\\"Initialize a new instance.\\\"\\\"\\\"\\n super().__init__(functional.domain, functional.domain,\\n linear=False)\\n\\n def _call(self, x):\\n \\\"\\\"\\\"Apply the gradient operator to the given point.\\n\\n The gradient is not defined in for points with components less\\n than or equal to zero.\\n \\\"\\\"\\\"\\n if functional.prior is None:\\n tmp = np.log(x)\\n else:\\n tmp = np.log(x / functional.prior)\\n\\n if np.all(np.isfinite(tmp)):\\n return tmp\\n else:\\n # The derivative is not defined.\\n raise ValueError('The gradient of the Kullback-Leibler '\\n 'Cross Entropy functional is not defined '\\n 'for `x` with one or more components '\\n 'less than or equal to zero.'.format(x))\\n\\n return KLCrossEntropyGradient()\",\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 gradient_descent(self, X ,eta, tol,iter):\\n gd=[]\\n gd_x=[X]\\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 \\n prev_x=X\\n new_x=prev_x -(learn_rate*first_derivative(prev_x))\\n gd_x.append(new_x)\\n #print(\\\"prev_x = \\\",prev_x,\\\" Next x = \\\",new_x)\\n for i in range(iter):\\n prev_x=new_x\\n #print(prev_x)\\n new_x=prev_x -(learn_rate*first_derivative(prev_x))\\n gd_x.append(new_x)\\n # print(\\\"x = \\\",new_x,\\\"Gradient =\\\",learn_rate*self.func(prev_x))\\n if abs(self.func(new_x)) <= self.func(tol) :\\n break\\n iteration=iteration+1\\n #print(\\\"Best at GD x= \\\",new_x)\\n gd.append(gd_x)\\n gd.append(new_x)\\n gd.append(iteration)\\n\\n return gd\",\n \"def sigmoid_grad(x):\\n sig = sigmoid(x)\\n return np.multiply(sig, 1 - sig)\",\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 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_reg_gradient(self):\\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) + self.lambda_reg * self.w # add regularization term\",\n \"def gradients(f, x, grad_ys=None):\\n\\n if isinstance(x, list):\\n grad = tf.gradients(f, x, grad_ys=grad_ys)\\n for i in range(len(x)):\\n if grad[i] is None:\\n grad[i] = tf.zeros_like(x[i])\\n return grad\\n else:\\n grad = tf.gradients(f, x, grad_ys=grad_ys)[0]\\n if grad is None:\\n return tf.zeros_like(x)\\n else:\\n return grad\",\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 (w, x, y):\\n (n,d) = x.shape\\n g = np.zeros(d)\\n for i in range(0,d):\\n g[i] = (w*x-y)*np.transpose(x[i])\\n g += 0.5*w\\n return g\",\n \"def calculate_gradient(y, tx, w):\\n return tx.T.dot(sigmoid(tx.dot(w))-np.reshape(y,(len(y),1)))\",\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\\n dx = backend.dot(grad, backend.transpose(y))\\n dy = backend.dot(backend.transpose(x), grad)\\n\\n return [dx, dy]\",\n \"def gradient(self, node, output_grad):\\r\\n \\\"\\\"\\\"TODO: Your code here\\\"\\\"\\\"\\r\\n return [output_grad * exp(node.inputs[0])]\",\n \"def grad_ReLU(self):\\n grad = np.where(self.x > 0, 1, 0)\\n return grad\",\n \"def compute_gradient(self, grad=None):\\n x = self.input_nodes[0].output_value\\n if grad is None:\\n grad = backend.ones_like(self.output_value)\\n if x == float('inf') or x == float('-inf'):\\n return grad * float('inf')\\n else:\\n return grad * 1 / x\",\n \"def gradient(self):\\n return ConstantFunctional(self.domain, self.scalar)\",\n \"def gradient_model(x, I_0, a, lam):\\n if np.any(np.array(x) < 0):\\n raise RuntimeError('x must be positive')\\n if np.any(np.array([I_0, a, lam]) < 0):\\n raise RuntimeError('all params must be positive')\\n return a + I_0 * np.exp(-x / lam)\",\n \"def _gradient_descent(self, X, y, epochs, learning_rate, batch_size):\\n num_feats = X.shape[1]\\n num_samples = X.shape[0]\\n\\n y = y.reshape(num_samples, 1)\\n W = np.random.rand(num_feats, 1)\\n training_loss_epochs = []\\n\\n for ix in range(epochs):\\n shuffled_ix = (np.arange(0, len(X)))\\n np.random.shuffle(shuffled_ix)\\n X = X[shuffled_ix, :]\\n y = y[shuffled_ix, :]\\n\\n for batch_ix in np.arange(0, X.shape[0], batch_size):\\n dW = self._compute_gradient(W, X[batch_ix:batch_ix + batch_size], y[batch_ix:batch_ix + batch_size])\\n W -= learning_rate * dW\\n\\n if ix % 10 == 0:\\n y_pred = np.dot(X, W)\\n training_loss = self.mse(y, y_pred)\\n print('epoch {0} : training loss {1}'.format(ix, training_loss))\\n training_loss_epochs.append(training_loss[0])\\n\\n self.weights = W\\n self.training_loss = training_loss_epochs\\n return None\",\n \"def 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]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77842075","0.7665237","0.7622198","0.7532601","0.744385","0.74368525","0.7415534","0.7381988","0.7379216","0.7374011","0.73667705","0.7362312","0.73497534","0.7292546","0.72891796","0.7286683","0.72824043","0.72817236","0.7221008","0.7217221","0.72115004","0.72010005","0.7175617","0.71754086","0.7173191","0.71590143","0.71467674","0.7140114","0.7131756","0.7131001","0.7130524","0.7129966","0.71225","0.7102693","0.70993704","0.7099323","0.70971864","0.7074166","0.7074052","0.70729125","0.70693624","0.7057815","0.7053709","0.70479536","0.7044672","0.7027092","0.70251757","0.70026755","0.6998083","0.6993366","0.6987603","0.69832534","0.6981358","0.6978515","0.6976825","0.69629955","0.6959243","0.6953732","0.6945607","0.69317627","0.69249403","0.69236994","0.6918956","0.6915946","0.69109964","0.69076717","0.6899734","0.6894298","0.68929833","0.6890172","0.68842787","0.6879261","0.6876824","0.68744284","0.68668777","0.6865218","0.6852037","0.6846718","0.68372226","0.68372226","0.68372226","0.6829083","0.68276507","0.6822475","0.6810264","0.6809227","0.68060666","0.6800019","0.67818946","0.67798615","0.6777603","0.6773404","0.67665905","0.67635447","0.6762423","0.67591417","0.6758775","0.6758098","0.6756054","0.67543626"],"string":"[\n \"0.77842075\",\n \"0.7665237\",\n \"0.7622198\",\n \"0.7532601\",\n \"0.744385\",\n \"0.74368525\",\n \"0.7415534\",\n \"0.7381988\",\n \"0.7379216\",\n \"0.7374011\",\n \"0.73667705\",\n \"0.7362312\",\n \"0.73497534\",\n \"0.7292546\",\n \"0.72891796\",\n \"0.7286683\",\n \"0.72824043\",\n \"0.72817236\",\n \"0.7221008\",\n \"0.7217221\",\n \"0.72115004\",\n \"0.72010005\",\n \"0.7175617\",\n \"0.71754086\",\n \"0.7173191\",\n \"0.71590143\",\n \"0.71467674\",\n \"0.7140114\",\n \"0.7131756\",\n \"0.7131001\",\n \"0.7130524\",\n \"0.7129966\",\n \"0.71225\",\n \"0.7102693\",\n \"0.70993704\",\n \"0.7099323\",\n \"0.70971864\",\n \"0.7074166\",\n \"0.7074052\",\n \"0.70729125\",\n \"0.70693624\",\n \"0.7057815\",\n \"0.7053709\",\n \"0.70479536\",\n \"0.7044672\",\n \"0.7027092\",\n \"0.70251757\",\n \"0.70026755\",\n \"0.6998083\",\n \"0.6993366\",\n \"0.6987603\",\n \"0.69832534\",\n \"0.6981358\",\n \"0.6978515\",\n \"0.6976825\",\n \"0.69629955\",\n \"0.6959243\",\n \"0.6953732\",\n \"0.6945607\",\n \"0.69317627\",\n \"0.69249403\",\n \"0.69236994\",\n \"0.6918956\",\n \"0.6915946\",\n \"0.69109964\",\n \"0.69076717\",\n \"0.6899734\",\n \"0.6894298\",\n \"0.68929833\",\n \"0.6890172\",\n \"0.68842787\",\n \"0.6879261\",\n \"0.6876824\",\n \"0.68744284\",\n \"0.68668777\",\n \"0.6865218\",\n \"0.6852037\",\n \"0.6846718\",\n \"0.68372226\",\n \"0.68372226\",\n \"0.68372226\",\n \"0.6829083\",\n \"0.68276507\",\n \"0.6822475\",\n \"0.6810264\",\n \"0.6809227\",\n \"0.68060666\",\n \"0.6800019\",\n \"0.67818946\",\n \"0.67798615\",\n \"0.6777603\",\n \"0.6773404\",\n \"0.67665905\",\n \"0.67635447\",\n \"0.6762423\",\n \"0.67591417\",\n \"0.6758775\",\n \"0.6758098\",\n \"0.6756054\",\n \"0.67543626\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7418975"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":84782,"cells":{"query":{"kind":"string","value":"Solves the inverse problem"},"document":{"kind":"string","value":"def optimize(self, x0):\n (result,f,d) = fmin_l_bfgs_b(lambda x:self.costFun(x), np.ravel(x0),lambda x: self.gradFun(x))\n print(\"optimization completed with cost: \" + str(f))\n return result.reshape(self.inp_shape)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def inverse(self):\n return self.solve(Matrix.I(self.nrows))","def inverse(self):\n self.check_square()\n\n\n N = self.rows\n\n inverse = make_matrix(N, N)\n\n # Solve on a per-column basis using Ax = b formalism\n for j in range(N):\n b = make_matrix(N, 1)\n b[j, 0] = 1\n\n x = self.solve_linear_system(b)\n\n for i in range(N):\n inverse[i, j] = x[i, 0]\n\n return inverse","def inverse( m, context = FloatContext, copy_m=True ):\n n,n_ = shape_mat(m)\n assert (n==n_) #matris should be square\n\n return solve( m, eye(n), context=context, copy_b=False, copy_a=copy_m )","def _inv(self) -> None:\n\n self.inv(inplace=True)","def inverse(self, x, y):","def invert(x):\n return linalg.inv(x)","def inv(P):\n L = cho_factor(P)\n return cho_solve(L, np.eye(P.shape[0]))","def inv(in_A):\n Q,R = qr(in_A)\n QT = Q.T\n N = shape(in_A)[0]\n \n for n in range(N-1,-1,-1):\n Rnn = R[n,n]\n R[n,:] /= Rnn\n QT[n,:] /= Rnn\n for m in range(n+1,N):\n Rnm = R[n,m]\n R[n,m] = 0\n QT[n,:] -= QT[m,:]*Rnm\n\n return QT","def inv(self):\n\t\tdeterminant = self.det()\n\t\tif determinant:\n\t\t\treturn self.adj() / determinant\n\t\telse:\n\t\t\traise ValueError(\"Not Invertible\")","def inverse(self):\n if not self.is_square():\n raise(ValueError, \"Non-square Matrix does not have an inverse.\")\n if self.h > 2:\n raise(NotImplementedError, \"inversion not implemented for matrices larger than 2x2.\")\n # TODO - your code here\n inverse = []\n if self.h == 1:\n temp = []\n temp.append(1/self.g[0][0])\n inverse.append(temp)\n else:\n identity_matrix = identity(self.h)\n det_term = 1/self.determinant()\n trace_term = self.trace()\n # implement intermediate scaling step locally\n # trace_x_I = trace_term * identity_matrix\n trace_x_I = []\n for i in range(len(self.g)):\n temp_row = []\n for j in range(len(self.g[i])):\n temp_row.append(trace_term * identity_matrix[i][j])\n trace_x_I.append(temp_row)\n # implement sub-traction locally\n # sub_term = trace_x_I - self.g\n sub_term = []\n for i in range(len(trace_x_I)):\n temp_row = []\n for j in range(len(trace_x_I[i])):\n temp_row.append(trace_x_I[i][j] - self.g[i][j])\n sub_term.append(temp_row)\n # implement final scaling step locally\n # inverse = det_term * sub_term\n inverse = []\n for i in range(len(sub_term)):\n temp_row = []\n for j in range(len(sub_term[i])):\n temp_row.append(det_term * sub_term[i][j])\n inverse.append(temp_row)\n return Matrix(inverse)\n # TODO - your code here","def erfcinv(a):","def inverse(self) -> 'Invertible':\n raise NotImplementedError","def inverse (x_ij):\n\n Hij = xyzrph2matrix (x_ij)\n Rji = Hij[0:3, 0:3]\n tij = Hij[0:3,3]\n Rij = Rji.transpose ()\n tji = -Rij.dot (tij)\n Hji = numpy.zeros ((4,4))\n Hji[0:3,0:3] = Rij\n Hji[0:3,3] = tji\n Hji[3,3] = 1\n return matrix2xyzrph (Hji)","def inverseN(self):\r\n result = Matrix(self.rows, self.columns)\r\n for r in range(self.rows):\r\n for c in range(self.columns):\r\n result.mat[r][c] = self.cofactor(r, c)\r\n result.out()\r\n result = result.transpose()\r\n det = self.determinant()\r\n print(\"1/(\" + str(det) + \")\")\r\n result.out()\r\n return result","def invert(self,el):\n return el^(self.q-2)","def _inverse(self, y):\n d = self._compute_shared(y=y)\n rely = y - d.y_k # tf.where(d.out_of_bounds, tf.zeros_like(y), y - d.y_k)\n term2 = rely * (d.d_kp1 + d.d_k - 2 * d.s_k)\n # These terms are the a, b, c terms of the quadratic formula.\n a = d.h_k * (d.s_k - d.d_k) + term2\n b = d.h_k * d.d_k - term2\n c = -d.s_k * rely\n # The expression used here has better numerical behavior for small 4*a*c.\n relx = tf.where(\n tf.equal(rely, 0), tf.zeros_like(a),\n (2 * c) / (-b - tf.sqrt(b**2 - 4 * a * c)))\n return relx * d.w_k + d.x_k #tf.where(d.out_of_bounds, y, relx * d.w_k + d.x_k)","def inverse(self):\n # find the determinant of the matrix\n determinant = self.determinant()\n # find the matrix of minors of the matrix\n matrix_of_minors = self.matrix_of_minors()\n # find the cofactor of the matrix of minors\n cofactor_matrix = self.cofactor_matrix(matrix_of_minors)\n # find the transpose of the cofactor matrix\n transpose_cofactor_matrix = self.transpose(cofactor_matrix)\n # find the adjugate (inverse) matrix\n inverse_matrix = self.adjugate_matrix(determinant, transpose_cofactor_matrix)\n\n return inverse_matrix","def inv_inplace(a):","def invert(self, solution, inverse_data):\n status = solution['status']\n\n primal_vars = None\n dual_vars = None\n if status in s.SOLUTION_PRESENT:\n opt_val = solution['value'] + inverse_data[s.OFFSET]\n primal_vars = {inverse_data[self.VAR_ID]: solution['primal']}\n return Solution(status, opt_val, primal_vars, dual_vars, {})\n else:\n return failure_solution(status)","def compute_inverse(in1, in2):\n aL = [in1]\n bL = [in2]\n tL = [0]\n t = 1\n sL = [1]\n s = 0\n q = math.floor((aL[0] / bL[0]))\n r = (aL[0] - (q * bL[0]))\n\n while r > 0:\n temp = (tL[0] - (q * bL[0]))\n tL[0] = t\n t = temp\n temp = (sL[0] - (q * s))\n sL[0] = s\n s = temp\n aL[0] = bL[0]\n bL[0] = r\n q = math.floor(aL[0] / bL[0])\n r = (aL[0] - (q * bL[0]))\n\n inverse = s % in2\n return inverse","def _r_inv(self):\n raise NotImplementedError","def inverse(self):\n data = np.linalg.inv(self._data)\n return self.create(self.rows, self.cols, data)","def __invert__(self):\n return self.inverse()","def support_inverse(rho):\n return LA.pinv(rho)","def test_inverse_c(self):\n for q in self.all:\n self.assertTrue((q * q.inverse()).almost_equal(q.inverse()*q))","def inverse(self):\n myMatrix = np.array(self.Matrix)\n if np.linalg.det(myMatrix) == 0:\n print(\"This matrix has a determinant of 0, meaning it has no inverse\")\n else:\n self.Inverse = np.linalg.inv(myMatrix)\n print(\"This is the inverse to your matrix: \", self.Inverse)","def _get_inv(self):\n m,d = self.B.shape\n Im = np.eye(m)\n Id = np.eye(d)\n BBt = self.B@self.B.T\n I_BBt_inv = np.linalg.pinv(Im + BBt)\n \n return (1/self.alpha)*(Id - self.B.T@( I_BBt_inv@self.B/self.alpha))","def inverse_transform(self, X):\n ...","def inverse_transform(self, X):\n ...","def inverse_transform(self, X):\n ...","def inverse_transform(self, X):\n ...","def inverse_transform(self, X):\n ...","def test_functional_inverse(self, dim):\n M = np.random.rand(dim, dim)\n assert np.all(M == symplectic.xxpp_to_xpxp(symplectic.xpxp_to_xxpp(M)))\n assert np.all(M == symplectic.xpxp_to_xxpp(symplectic.xxpp_to_xpxp(M)))\n\n v = np.random.rand(dim)\n assert np.all(v == symplectic.xxpp_to_xpxp(symplectic.xpxp_to_xxpp(v)))\n assert np.all(v == symplectic.xpxp_to_xxpp(symplectic.xxpp_to_xpxp(v)))","def inv(self,output,*args,**kwargs):\n raise ModelTypeError('Model is not invertible')","def modular_inverse(self):\n i = gmpy2.invert(self.c2, self.n)\n mx = pow(self.c1, self.a, self.n)\n my = pow(i, int(-self.b), self.n)\n self.m= mx * my % self.n","def Inverse(self, freedofs: pyngcore.BitArray = None, inverse: str = '') -> BaseMatrix:","def Inverse(self, freedofs: pyngcore.BitArray = None, inverse: str = '') -> BaseMatrix:","def _inverse(self, x):\n alpha, beta = self._get_alpha_beta()\n diff = x - self.x0\n r = tf.linalg.norm(diff, axis=-1, keepdims=True)\n h = 1. / (alpha + r)\n beta_h = beta * h\n return x + beta_h * diff","def inv(self, y):\n pass","def _r_inv(self):\n # [output_dim, output_dim]\n return tf.linalg.cholesky_solve(\n self._chol_obs_covariance,\n tf.eye(self.emission.output_dim, dtype=self._chol_obs_covariance.dtype),\n )","def inv(self, check=True, maxtries=float(\"inf\"), debug=False):\n if self.x == 0 or self.y == 0:\n return matrix(0)\n elif self.x == 1 or self.y == 1:\n return self*self.retrieve(0,0)**-1.0\n elif not (check and self.det() == 0.0):\n size = self.y\n out = getcopy(self)\n out.augment(diagmatrix(size))\n out.keepsolvingfull(False, maxtries, debug)\n return matrixlist(out.getaugment(size), self.converter).trans()\n else:\n raise IndexError(\"Matrix inverse does not exist because of 0 determinant\")","def inverse(self):\n if not self.is_square():\n raise(ValueError, \"Non-square Matrix does not have an inverse.\")\n if self.h > 2:\n raise(NotImplementedError, \"inversion not implemented for matrices larger than 2x2.\")\n\n # TODO - your code here\n if self.h == 1:\n inverse = [[1/self.g[0][0]]];\n else:\n a = self.g[0][0];\n b = self.g[0][1];\n c = self.g[1][0];\n d = self.g[1][1];\n if(a*d==b*c):\n raise ValueError('matrix does not have a inverse!');\n else:\n weigh = 1/(a*d-b*c);\n inverse = [[weigh*d,weigh*-1*b],[weigh*-1*c,weigh*a]];\n return Matrix(inverse);","def inverse(self,mat):\n result = np.linalg.inv(mat)\n self.out = result\n return self.out","def diffeo_inverse(a):\n M, N = a.shape[0], a.shape[1]\n result = np.empty_like(a)\n result.fill(-1) # fill invalid data\n many = np.zeros((M, N))\n many.fill(0)\n for i, j in coords_iterate((M, N)):\n i1 = a[i, j, 0]\n j1 = a[i, j, 1]\n result[i1, j1, 0] = i\n result[i1, j1, 1] = j\n many[i1, j1] += 1\n\n num = (many == 0).sum()\n if num:\n fill_invalid(result[:, :, 0], -1)\n fill_invalid(result[:, :, 1], -1)\n\n return result","def get_inverse(a):\n if len(a) == len(a[0]):\n i = get_identity(len(a))\n inverse = gaussian_solve(a, i)\n return inverse","def inv(self):\n\n self.x, self.y = self.y, self.x\n self._x_, self._y_ = self._y_, self._x_\n self.xfac, self.yfac = 1 / self.yfac, 1 / self.xfac\n self._xfac_, self._yfac_ = 1 / self._yfac_, 1 / self._xfac_\n self._u = 1 / self._u.conj()","def inverse(self):\n return self.invert()","def inv(q):\n return q * np.array([-1,-1,-1,1]) / amplitude(q) ** 2","def inverse(self):\n return self._inverse","def inv(a):\n a, cv, isMatrix = get_computation_matrix(a)\n t_dtype = TypeUtil.to_numpy_dtype(a.get_dtype())\n if a.numRows() != a.numCols():\n raise ValueError(\"inv: input a is not a square matrix!\")\n #compute LU using getrf\n (lu, piv, _) = getrf(a, overwrite_a=1, dtype=t_dtype)\n (ainv, _) = getri(lu, piv, lwork=0, overwrite_lu=1, dtype=t_dtype)\n if cv:\n if isMatrix:\n return ainv.to_numpy_matrix()\n else:\n return ainv.to_numpy_array()\n else:\n return ainv","def inverse(self):\r\n \r\n Mi=mat4()\r\n d=self.determinant()\r\n for i in range(4):\r\n for j in range(4):\r\n sign=1-((i+j)%2)*2\r\n m3=self._submat(i,j)\r\n Mi[j,i]=sign*m3.determinant()/d\r\n return Mi","def opposite(x):\n return -1*x","def ssc.inverse (x_ij):\n\n Hij = xyzrph2matrix (x_ij)\n Rji = Hij[0:3, 0:3]\n tij = Hij[0:3,3]\n Rij = Rji.transpose ()\n tji = -Rij.dot (tij)\n Hji = zeros ((4,4))\n Hji[0:3,0:3] = Rij\n Hji[0:3,3] = tji\n Hji[3,3] = 1\n return matrix2xyzrph (Hji)","def inverse(self):\n def inv(v):\n v[0], v[1] = v[1] , v[0]\n for v in [self.point1 , self.pointN , self.unitv, self.normalv]:\n inv(v)\n\n self.points = numpy.roll(self.points,1,axis=1)\n self.a, self.b = self.b, self.a\n self.angle = numpy.arccos( self.unitv[0] )*numpy.sign(self.unitv[1] )\n return","def inverse_transform(v):\n v, k = divmod(v - 1, N)\n v, j = divmod(v, N)\n v, i = divmod(v, N)\n return i, j, k","def inverse_basis(T, dimensions, t):\n B = basis(T, dimensions, t)\n return inv(B.T.dot(B)).dot(B.T)","def test_inverse_transform(self):","def inv(X):\n R, t = Rt(X)\n Ri = R.T\n return np.concatenate((\n np.concatenate((Ri, -Ri.dot(t)[:,np.newaxis]), axis=1),\n np.array([[0, 0, 1]])))","def inverse(self):\n if self.inv is None:\n if self.size > 0:\n self.inv = inverseIndex(self)\n else:\n self.inv = Connectivity()\n return self.inv","def inverse(self, x):\n x = np.asarray(x)\n def r(vec):\n return utils.recycled(vec, as_=x)\n if self.zero is not None and self.multiplier is not None:\n x = x / r(self.multiplier) + r(self.zero)\n elif self.zero is not None:\n x = x + r(self.zero)\n elif self.multiplier is not None:\n x = x / r(self.multiplier)\n return x","def inverse(self, x):\n return self.mul(self.weights, x.unsqueeze(-1)).squeeze(-1) + self.shift\n #return self.mul(torch.inverse(self.weights), (x - self.shift).unsqueeze(-1)).squeeze(-1)","def test_inverse_of_linear_vector_transforms(free_alg: Drudge):\n\n dr = free_alg\n p = dr.names\n v = p.v\n\n a = Vec('a')\n b = Vec('b')\n\n defs = [\n dr.define(a, v + 1),\n dr.define(b, v - 1)\n ]\n res = dr.lvt_inv(defs)\n\n assert len(res) == 2\n half = Rational(1, 2)\n one_checked = False\n v_checked = False\n for i in res:\n if i.lhs == 1:\n assert (i - half * a + half * b).simplify() == 0\n one_checked = True\n elif i.lhs == v:\n assert (i - half * a - half * b).simplify() == 0\n v_checked = True\n else:\n assert False\n continue\n\n assert one_checked and v_checked","def test__inverse_transform_continuous(self):","def inverse(self):\n # TODO\n # detA\n if not self.is_square():\n raise(\n ValueError, \"Non-square Matrix does not have an inverse.\")\n if self.h > 2:\n raise(\n NotImplementedError, \"inversion not implemented for matrices larger than 2x2.\")\n\n mD = self.determinant()\n if self.h == 1:\n if self.g[0][0] = 0:\n raise(NotImplementedError,\n \"The 1x1 Matrix contains 0 can't inverse\")\n else:\n return [[1 / self.g[0][0]]] \n for i in range(self.h): # Calculates the inverse of a 2x2 Matrix.\n my_Matrix = zeroes(2, 2)\n my_Matrix.g[1][1] = self.g[0][0] / mD\n my_Matrix.g[0][0] = self.g[1][1] / mD\n my_Matrix.g[0][1] = - self.g[0][1] / mD\n my_Matrix.g[1][0] = - self.g[1][0] / mD\n return my_Matrix\n\n # trace A\n # 与矩阵TraceA * I identity 单位矩阵","def inv(self):\n return self.conjugate()","def __invert(self, args):","def inverse(self):\n n = self.norm()\n c = self.conj()\n d = 1.0 / (n * n)\n c.scale(d)\n return c","def inverse(self, u: Tensor, covariates: Tensor) -> Tensor:\n return self.real_nvp.inverse(u, covariates)","def inv(self):\n self.inverse = not self._inverse\n return self","def inverse(self: T) -> T:","def InverseMatrix(matrix,vector):\r\n # Unveri reversible matrix\r\n if Determinant(matrix, 1) == 0:\r\n print(\"Error,Singular Matrix\\n\")\r\n return\r\n # result matrix initialized as singularity matrix\r\n result = MakeIMatrix(len(matrix), len(matrix))\r\n # loop for each row\r\n for i in range(len(matrix[0])):\r\n # turn the pivot into 1 (make elementary matrix and multiply with the result matrix )\r\n # pivoting process\r\n matrix, vector = RowXchange(matrix, vector)\r\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\r\n elementary[i][i] = 1/matrix[i][i]\r\n result = MultiplyMatrix(elementary, result)\r\n matrix = MultiplyMatrix(elementary, matrix)\r\n # make elementary loop to iterate for each row and subtracrt the number below (specific) pivot to zero (make\r\n # elementary matrix and multiply with the result matrix )\r\n for j in range(i+1, len(matrix)):\r\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\r\n elementary[j][i] = -(matrix[j][i])\r\n matrix = MultiplyMatrix(elementary, matrix)\r\n result = MultiplyMatrix(elementary, result)\r\n\r\n\r\n # after finishing with the lower part of the matrix subtract the numbers above the pivot with elementary for loop\r\n # (make elementary matrix and multiply with the result matrix )\r\n for i in range(len(matrix[0])-1, 0, -1):\r\n for j in range(i-1, -1, -1):\r\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\r\n elementary[j][i] = -(matrix[j][i])\r\n matrix = MultiplyMatrix(elementary, matrix)\r\n result = MultiplyMatrix(elementary, result)\r\n\r\n return result","def invert(self, results, inverse_data):\n import mosek\n # Status map is taken from:\n # https://docs.mosek.com/8.1/pythonapi/constants.html?highlight=solsta#mosek.solsta\n STATUS_MAP = {mosek.solsta.optimal: s.OPTIMAL,\n mosek.solsta.integer_optimal: s.OPTIMAL,\n mosek.solsta.prim_feas: s.OPTIMAL_INACCURATE, # for integer problems\n mosek.solsta.prim_infeas_cer: s.INFEASIBLE,\n mosek.solsta.dual_infeas_cer: s.UNBOUNDED}\n # \"Near\" statuses only up to Mosek 8.1\n if hasattr(mosek.solsta, 'near_optimal'):\n STATUS_MAP_INACCURATE = {mosek.solsta.near_optimal: s.OPTIMAL_INACCURATE,\n mosek.solsta.near_integer_optimal: s.OPTIMAL_INACCURATE,\n mosek.solsta.near_prim_infeas_cer: s.INFEASIBLE_INACCURATE,\n mosek.solsta.near_dual_infeas_cer: s.UNBOUNDED_INACCURATE}\n STATUS_MAP.update(STATUS_MAP_INACCURATE)\n STATUS_MAP = defaultdict(lambda: s.SOLVER_ERROR, STATUS_MAP)\n\n env = results['env']\n task = results['task']\n solver_opts = results['solver_options']\n\n if inverse_data['integer_variables']:\n sol = mosek.soltype.itg\n elif 'bfs' in solver_opts and solver_opts['bfs'] and inverse_data['is_LP']:\n sol = mosek.soltype.bas # the basic feasible solution\n else:\n sol = mosek.soltype.itr # the solution found via interior point method\n\n problem_status = task.getprosta(sol)\n solution_status = task.getsolsta(sol)\n\n status = STATUS_MAP[solution_status]\n\n # For integer problems, problem status determines infeasibility (no solution)\n if sol == mosek.soltype.itg and problem_status == mosek.prosta.prim_infeas:\n status = s.INFEASIBLE\n\n if status in s.SOLUTION_PRESENT:\n # get objective value\n opt_val = task.getprimalobj(sol) + inverse_data[s.OBJ_OFFSET]\n # recover the cvxpy standard-form primal variable\n z = [0.] * inverse_data['n0']\n task.getxxslice(sol, 0, len(z), z)\n primal_vars = {inverse_data[self.VAR_ID]: z}\n # recover the cvxpy standard-form dual variables\n if sol == mosek.soltype.itg:\n dual_vars = None\n else:\n dual_vars = MOSEK.recover_dual_variables(task, sol, inverse_data)\n else:\n if status == s.INFEASIBLE:\n opt_val = np.inf\n elif status == s.UNBOUNDED:\n opt_val = -np.inf\n else:\n opt_val = None\n primal_vars = None\n dual_vars = None\n\n # Store computation time\n attr = {s.SOLVE_TIME: task.getdouinf(mosek.dinfitem.optimizer_time)}\n\n # Delete the mosek Task and Environment\n task.__exit__(None, None, None)\n env.__exit__(None, None, None)\n\n return Solution(status, opt_val, primal_vars, dual_vars, attr)","def __invert__(self):\n try:\n B = ~(self.matrix())\n except ZeroDivisionError:\n raise ZeroDivisionError(\"matrix morphism not invertible\")\n try:\n return self.parent().reversed()(B)\n except TypeError:\n raise ZeroDivisionError(\"matrix morphism not invertible\")","def inverse_rigid_trans(Tr): \n inv_Tr = np.zeros_like(Tr) # 3x4\n inv_Tr[0:3,0:3] = np.transpose(Tr[0:3,0:3])\n inv_Tr[0:3,3] = np.dot(-np.transpose(Tr[0:3,0:3]), Tr[0:3,3])\n return inv_Tr","def inverse(self):\n cdef StdVectorFst result = self.copy()\n result.invert()\n return result","def Mq_inv(self, q):\n\t\traise NotImplementedError","def inverse(self) -> np.ndarray:\n if self.is_versor():\n return self.conjugate\n return self.conjugate / np.linalg.norm(self.q)","def inverse(self):\n if self.determinant() != 0:\n ops = reduce_to_red_echelon(self.data.copy(), True)[1]\n matrix = identity_matrix(self.n_rows).data\n \n if ops:\n if isinstance(ops[0], str):\n ops = [ops]\n \n for op in ops:\n if op[0] == 'swap':\n matrix = row_swap(matrix, op[1], op[2])\n elif op[0] == 'multiplication':\n matrix = row_multiply(matrix, op[1], op[2])\n elif op[0] == 'subtract':\n matrix = row_subtract(matrix, op[1], op[2], op[3])\n else:\n raise ValueError('Row operation not recognized')\n else:\n raise ValueError('Matrix has a determinant of 0 and is not invertible')\n return Matrix(matrix)","def inverse(self, x, *args, **kwargs):\n if self.list_of_inverses is None:\n utils.print_warning(\"inverses were not given\")\n return\n for i in range(len(self.list_of_inverses)):\n x = self.list_of_inverses[i](x, *args, **kwargs)\n return x","def inverse_matrice(T):\n a,b,c,d = T[0][0],T[0][1],T[1][0],T[1][1]\n det = a*d-b*c\n aa,bb,cc,dd = d/det,-b/det,-c/det,a/det\n Tinv = [[aa,bb],[cc,dd]]\n return Tinv","def inverse(self):\n ss = self._sum_of_squares()\n if ss > 0:\n return self.__class__(array=(self._vector_conjugate() / ss))\n else:\n raise ZeroDivisionError(\"a zero quaternion (0 + 0i + 0j + 0k) cannot be inverted\")","def inverse(self, z, y):\n y_summary = self.summary_net(y)\n return self.invertible_net(z, y_summary, inverse=True)","def inv(self):\n return MoebGen(self._d / self._det, - self._b / self._det, - self._c / self._det, self._a / self._det)","def find_inverse(a,n):\n if a==0 or gcd(a,n)!=1: return \".\"\n if a==1: return 1\n k=1\n while True:\n a_inv = (1+n*k)/a \n if a_inv.is_integer():\n return int(a_inv)\n else:\n k=k+1","def _vect_matrix_inverse(A):\n identity = np.identity(A.shape[2], dtype=A.dtype)\n return np.array([np.linalg.solve(x, identity) for x in A])","def inverse(num, r):\n if int(num) == 0:\n return 0\n else:\n # Multiply with every number in the field and\n # check if the result is one. Easy Peasy!\n # Todo: Use Extended Euclidean Algo\n # or Logs/Anti-Logs\n for i in range(1, 256):\n if _multiply(num, i, r) == 1:\n return i","def inverse_transform(self, x):\n raise NotImplementedError()","def solve(self):","def inverse(self, y):\n device = y.device\n return t.einsum('ij,k,kj->ik', y, 1. / t.sqrt(self.eig).to(device), self.rot.to(device))","def inverse_transform(self, X):\n\n pass # pragma: no cover","def inverse(self):\n return ~self","def inverse(self: Float[LinearOperator, \"*batch N N\"]) -> Float[LinearOperator, \"*batch N N\"]:\n return self.__class__(self._diag.reciprocal())","def _tridi_inverse_iteration(d, e, w, x0=None, rtol=1e-6):\n\teig_diag = d - w\n\tif x0 is None:\n\t\tx0 = np.random.randn(len(d))\n\tx_prev = np.zeros_like(x0)\n\tnorm_x = np.linalg.norm(x0)\n\t# the eigenvector is unique up to sign change, so iterate\n\t# until || |x^(n)| - |x^(n-1)| ||^2 < rtol\n\tx0 /= norm_x\n\twhile np.linalg.norm(np.abs(x0) - np.abs(x_prev)) > rtol:\n\t\tx_prev = x0.copy()\n\t\t_tridisolve(eig_diag, e, x0)\n\t\tnorm_x = np.linalg.norm(x0)\n\t\tx0 /= norm_x\n\treturn x0","def mod_inverse_iterative(a, b):\n x, y, u, v = 0, 1, 1, 0\n while a != 0:\n q = int(b / a)\n r = b % a\n m = x - u * q\n n = y - v * q\n b, a, x, y, u, v = a, r, u, v, m, n\n return b, x, y","def invertible(A, B):\n\tdetA = la.det(A)\n\tdetB = la.det(B)\n\t\n\tif (detA == 0):\n\t\tif (detB == 0):\n\t\t\tprint(\"None are invertible\")\n\t\telse:\n\t\t\treturn B\n\telse:\n\t\tif (detB == 0):\n\t\t\treturn A\n\t\telse:\n\t\t\tprint(\"Both are invertible\")","def invert(self):\n if self.m != self.n:\n raise exc.LinearAlgebraError(\"cannot invert a non-square matrix\")\n if self.determinant == 0:\n raise exc.LinearAlgebraError(\"cannot invert a singular matrix\")\n # TODO: implement block matrices in their own method\n block_rows = [r1 + r2 for r1, r2 in\n zip(self.data, self.makeIdentity(self.m).data)]\n inverse_block = Matrix.fromRows(block_rows).row_reduce()\n return inverse_block.subset([i for i in range(self.m)],\n [j + self.n for j in range(self.n)])","def pseudoInversa(J):\n\tJinv = np.linalg.pinv(J)\n\treturn Jinv","def inverse_transform(self, y: Array2D) -> Array2D:","def test_inverse_non_interacting(self, size):\n t_nn = 1.2\n idx = np.arange(size)\n g0_inv_full = np.zeros((size, size), dtype=complex)\n g0_inv_full[idx[:-1], idx[1:]] = g0_inv_full[idx[1:], idx[:-1]] = t_nn\n for g0 in self.g0_loc_inv:\n g0_inv_full[idx, idx] = g0\n rv, h, rv_inv = gt.matrix.decompose_gf(g0_inv_full)\n g0 = gt.matrix.construct_gf(rv_inv=rv_inv, diag_inv=h**-1, rv=rv)\n assert_allclose(g0.dot(g0_inv_full), np.identity(size), atol=1e-14)\n assert_allclose(g0, la.inv(g0_inv_full))\n g0_alt = gt.matrix.Decomposition(rv, h**-1, rv_inv).reconstruct(kind='full')\n assert_allclose(g0, g0_alt)","def inverse(self, ys):\n with torch.no_grad():\n xs = torch.matmul(ys, torch.diag(torch.reciprocal(torch.exp(self.scaling_diag))))\n xs = self.layer4.inverse(xs)\n xs = self.layer3.inverse(xs)\n xs = self.layer2.inverse(xs)\n xs = self.layer1.inverse(xs)\n return xs","def ginverse(p, x):\n x_ = x.data\n sinu = torch.sin(p.narrow(-1,0,1)).pow(2)\n x_.narrow(-1,1,1).mul_(sinu.pow(-1))\n return x_"],"string":"[\n \"def inverse(self):\\n return self.solve(Matrix.I(self.nrows))\",\n \"def inverse(self):\\n self.check_square()\\n\\n\\n N = self.rows\\n\\n inverse = make_matrix(N, N)\\n\\n # Solve on a per-column basis using Ax = b formalism\\n for j in range(N):\\n b = make_matrix(N, 1)\\n b[j, 0] = 1\\n\\n x = self.solve_linear_system(b)\\n\\n for i in range(N):\\n inverse[i, j] = x[i, 0]\\n\\n return inverse\",\n \"def inverse( m, context = FloatContext, copy_m=True ):\\n n,n_ = shape_mat(m)\\n assert (n==n_) #matris should be square\\n\\n return solve( m, eye(n), context=context, copy_b=False, copy_a=copy_m )\",\n \"def _inv(self) -> None:\\n\\n self.inv(inplace=True)\",\n \"def inverse(self, x, y):\",\n \"def invert(x):\\n return linalg.inv(x)\",\n \"def inv(P):\\n L = cho_factor(P)\\n return cho_solve(L, np.eye(P.shape[0]))\",\n \"def inv(in_A):\\n Q,R = qr(in_A)\\n QT = Q.T\\n N = shape(in_A)[0]\\n \\n for n in range(N-1,-1,-1):\\n Rnn = R[n,n]\\n R[n,:] /= Rnn\\n QT[n,:] /= Rnn\\n for m in range(n+1,N):\\n Rnm = R[n,m]\\n R[n,m] = 0\\n QT[n,:] -= QT[m,:]*Rnm\\n\\n return QT\",\n \"def inv(self):\\n\\t\\tdeterminant = self.det()\\n\\t\\tif determinant:\\n\\t\\t\\treturn self.adj() / determinant\\n\\t\\telse:\\n\\t\\t\\traise ValueError(\\\"Not Invertible\\\")\",\n \"def inverse(self):\\n if not self.is_square():\\n raise(ValueError, \\\"Non-square Matrix does not have an inverse.\\\")\\n if self.h > 2:\\n raise(NotImplementedError, \\\"inversion not implemented for matrices larger than 2x2.\\\")\\n # TODO - your code here\\n inverse = []\\n if self.h == 1:\\n temp = []\\n temp.append(1/self.g[0][0])\\n inverse.append(temp)\\n else:\\n identity_matrix = identity(self.h)\\n det_term = 1/self.determinant()\\n trace_term = self.trace()\\n # implement intermediate scaling step locally\\n # trace_x_I = trace_term * identity_matrix\\n trace_x_I = []\\n for i in range(len(self.g)):\\n temp_row = []\\n for j in range(len(self.g[i])):\\n temp_row.append(trace_term * identity_matrix[i][j])\\n trace_x_I.append(temp_row)\\n # implement sub-traction locally\\n # sub_term = trace_x_I - self.g\\n sub_term = []\\n for i in range(len(trace_x_I)):\\n temp_row = []\\n for j in range(len(trace_x_I[i])):\\n temp_row.append(trace_x_I[i][j] - self.g[i][j])\\n sub_term.append(temp_row)\\n # implement final scaling step locally\\n # inverse = det_term * sub_term\\n inverse = []\\n for i in range(len(sub_term)):\\n temp_row = []\\n for j in range(len(sub_term[i])):\\n temp_row.append(det_term * sub_term[i][j])\\n inverse.append(temp_row)\\n return Matrix(inverse)\\n # TODO - your code here\",\n \"def erfcinv(a):\",\n \"def inverse(self) -> 'Invertible':\\n raise NotImplementedError\",\n \"def inverse (x_ij):\\n\\n Hij = xyzrph2matrix (x_ij)\\n Rji = Hij[0:3, 0:3]\\n tij = Hij[0:3,3]\\n Rij = Rji.transpose ()\\n tji = -Rij.dot (tij)\\n Hji = numpy.zeros ((4,4))\\n Hji[0:3,0:3] = Rij\\n Hji[0:3,3] = tji\\n Hji[3,3] = 1\\n return matrix2xyzrph (Hji)\",\n \"def inverseN(self):\\r\\n result = Matrix(self.rows, self.columns)\\r\\n for r in range(self.rows):\\r\\n for c in range(self.columns):\\r\\n result.mat[r][c] = self.cofactor(r, c)\\r\\n result.out()\\r\\n result = result.transpose()\\r\\n det = self.determinant()\\r\\n print(\\\"1/(\\\" + str(det) + \\\")\\\")\\r\\n result.out()\\r\\n return result\",\n \"def invert(self,el):\\n return el^(self.q-2)\",\n \"def _inverse(self, y):\\n d = self._compute_shared(y=y)\\n rely = y - d.y_k # tf.where(d.out_of_bounds, tf.zeros_like(y), y - d.y_k)\\n term2 = rely * (d.d_kp1 + d.d_k - 2 * d.s_k)\\n # These terms are the a, b, c terms of the quadratic formula.\\n a = d.h_k * (d.s_k - d.d_k) + term2\\n b = d.h_k * d.d_k - term2\\n c = -d.s_k * rely\\n # The expression used here has better numerical behavior for small 4*a*c.\\n relx = tf.where(\\n tf.equal(rely, 0), tf.zeros_like(a),\\n (2 * c) / (-b - tf.sqrt(b**2 - 4 * a * c)))\\n return relx * d.w_k + d.x_k #tf.where(d.out_of_bounds, y, relx * d.w_k + d.x_k)\",\n \"def inverse(self):\\n # find the determinant of the matrix\\n determinant = self.determinant()\\n # find the matrix of minors of the matrix\\n matrix_of_minors = self.matrix_of_minors()\\n # find the cofactor of the matrix of minors\\n cofactor_matrix = self.cofactor_matrix(matrix_of_minors)\\n # find the transpose of the cofactor matrix\\n transpose_cofactor_matrix = self.transpose(cofactor_matrix)\\n # find the adjugate (inverse) matrix\\n inverse_matrix = self.adjugate_matrix(determinant, transpose_cofactor_matrix)\\n\\n return inverse_matrix\",\n \"def inv_inplace(a):\",\n \"def invert(self, solution, inverse_data):\\n status = solution['status']\\n\\n primal_vars = None\\n dual_vars = None\\n if status in s.SOLUTION_PRESENT:\\n opt_val = solution['value'] + inverse_data[s.OFFSET]\\n primal_vars = {inverse_data[self.VAR_ID]: solution['primal']}\\n return Solution(status, opt_val, primal_vars, dual_vars, {})\\n else:\\n return failure_solution(status)\",\n \"def compute_inverse(in1, in2):\\n aL = [in1]\\n bL = [in2]\\n tL = [0]\\n t = 1\\n sL = [1]\\n s = 0\\n q = math.floor((aL[0] / bL[0]))\\n r = (aL[0] - (q * bL[0]))\\n\\n while r > 0:\\n temp = (tL[0] - (q * bL[0]))\\n tL[0] = t\\n t = temp\\n temp = (sL[0] - (q * s))\\n sL[0] = s\\n s = temp\\n aL[0] = bL[0]\\n bL[0] = r\\n q = math.floor(aL[0] / bL[0])\\n r = (aL[0] - (q * bL[0]))\\n\\n inverse = s % in2\\n return inverse\",\n \"def _r_inv(self):\\n raise NotImplementedError\",\n \"def inverse(self):\\n data = np.linalg.inv(self._data)\\n return self.create(self.rows, self.cols, data)\",\n \"def __invert__(self):\\n return self.inverse()\",\n \"def support_inverse(rho):\\n return LA.pinv(rho)\",\n \"def test_inverse_c(self):\\n for q in self.all:\\n self.assertTrue((q * q.inverse()).almost_equal(q.inverse()*q))\",\n \"def inverse(self):\\n myMatrix = np.array(self.Matrix)\\n if np.linalg.det(myMatrix) == 0:\\n print(\\\"This matrix has a determinant of 0, meaning it has no inverse\\\")\\n else:\\n self.Inverse = np.linalg.inv(myMatrix)\\n print(\\\"This is the inverse to your matrix: \\\", self.Inverse)\",\n \"def _get_inv(self):\\n m,d = self.B.shape\\n Im = np.eye(m)\\n Id = np.eye(d)\\n BBt = self.B@self.B.T\\n I_BBt_inv = np.linalg.pinv(Im + BBt)\\n \\n return (1/self.alpha)*(Id - self.B.T@( I_BBt_inv@self.B/self.alpha))\",\n \"def inverse_transform(self, X):\\n ...\",\n \"def inverse_transform(self, X):\\n ...\",\n \"def inverse_transform(self, X):\\n ...\",\n \"def inverse_transform(self, X):\\n ...\",\n \"def inverse_transform(self, X):\\n ...\",\n \"def test_functional_inverse(self, dim):\\n M = np.random.rand(dim, dim)\\n assert np.all(M == symplectic.xxpp_to_xpxp(symplectic.xpxp_to_xxpp(M)))\\n assert np.all(M == symplectic.xpxp_to_xxpp(symplectic.xxpp_to_xpxp(M)))\\n\\n v = np.random.rand(dim)\\n assert np.all(v == symplectic.xxpp_to_xpxp(symplectic.xpxp_to_xxpp(v)))\\n assert np.all(v == symplectic.xpxp_to_xxpp(symplectic.xxpp_to_xpxp(v)))\",\n \"def inv(self,output,*args,**kwargs):\\n raise ModelTypeError('Model is not invertible')\",\n \"def modular_inverse(self):\\n i = gmpy2.invert(self.c2, self.n)\\n mx = pow(self.c1, self.a, self.n)\\n my = pow(i, int(-self.b), self.n)\\n self.m= mx * my % self.n\",\n \"def Inverse(self, freedofs: pyngcore.BitArray = None, inverse: str = '') -> BaseMatrix:\",\n \"def Inverse(self, freedofs: pyngcore.BitArray = None, inverse: str = '') -> BaseMatrix:\",\n \"def _inverse(self, x):\\n alpha, beta = self._get_alpha_beta()\\n diff = x - self.x0\\n r = tf.linalg.norm(diff, axis=-1, keepdims=True)\\n h = 1. / (alpha + r)\\n beta_h = beta * h\\n return x + beta_h * diff\",\n \"def inv(self, y):\\n pass\",\n \"def _r_inv(self):\\n # [output_dim, output_dim]\\n return tf.linalg.cholesky_solve(\\n self._chol_obs_covariance,\\n tf.eye(self.emission.output_dim, dtype=self._chol_obs_covariance.dtype),\\n )\",\n \"def inv(self, check=True, maxtries=float(\\\"inf\\\"), debug=False):\\n if self.x == 0 or self.y == 0:\\n return matrix(0)\\n elif self.x == 1 or self.y == 1:\\n return self*self.retrieve(0,0)**-1.0\\n elif not (check and self.det() == 0.0):\\n size = self.y\\n out = getcopy(self)\\n out.augment(diagmatrix(size))\\n out.keepsolvingfull(False, maxtries, debug)\\n return matrixlist(out.getaugment(size), self.converter).trans()\\n else:\\n raise IndexError(\\\"Matrix inverse does not exist because of 0 determinant\\\")\",\n \"def inverse(self):\\n if not self.is_square():\\n raise(ValueError, \\\"Non-square Matrix does not have an inverse.\\\")\\n if self.h > 2:\\n raise(NotImplementedError, \\\"inversion not implemented for matrices larger than 2x2.\\\")\\n\\n # TODO - your code here\\n if self.h == 1:\\n inverse = [[1/self.g[0][0]]];\\n else:\\n a = self.g[0][0];\\n b = self.g[0][1];\\n c = self.g[1][0];\\n d = self.g[1][1];\\n if(a*d==b*c):\\n raise ValueError('matrix does not have a inverse!');\\n else:\\n weigh = 1/(a*d-b*c);\\n inverse = [[weigh*d,weigh*-1*b],[weigh*-1*c,weigh*a]];\\n return Matrix(inverse);\",\n \"def inverse(self,mat):\\n result = np.linalg.inv(mat)\\n self.out = result\\n return self.out\",\n \"def diffeo_inverse(a):\\n M, N = a.shape[0], a.shape[1]\\n result = np.empty_like(a)\\n result.fill(-1) # fill invalid data\\n many = np.zeros((M, N))\\n many.fill(0)\\n for i, j in coords_iterate((M, N)):\\n i1 = a[i, j, 0]\\n j1 = a[i, j, 1]\\n result[i1, j1, 0] = i\\n result[i1, j1, 1] = j\\n many[i1, j1] += 1\\n\\n num = (many == 0).sum()\\n if num:\\n fill_invalid(result[:, :, 0], -1)\\n fill_invalid(result[:, :, 1], -1)\\n\\n return result\",\n \"def get_inverse(a):\\n if len(a) == len(a[0]):\\n i = get_identity(len(a))\\n inverse = gaussian_solve(a, i)\\n return inverse\",\n \"def inv(self):\\n\\n self.x, self.y = self.y, self.x\\n self._x_, self._y_ = self._y_, self._x_\\n self.xfac, self.yfac = 1 / self.yfac, 1 / self.xfac\\n self._xfac_, self._yfac_ = 1 / self._yfac_, 1 / self._xfac_\\n self._u = 1 / self._u.conj()\",\n \"def inverse(self):\\n return self.invert()\",\n \"def inv(q):\\n return q * np.array([-1,-1,-1,1]) / amplitude(q) ** 2\",\n \"def inverse(self):\\n return self._inverse\",\n \"def inv(a):\\n a, cv, isMatrix = get_computation_matrix(a)\\n t_dtype = TypeUtil.to_numpy_dtype(a.get_dtype())\\n if a.numRows() != a.numCols():\\n raise ValueError(\\\"inv: input a is not a square matrix!\\\")\\n #compute LU using getrf\\n (lu, piv, _) = getrf(a, overwrite_a=1, dtype=t_dtype)\\n (ainv, _) = getri(lu, piv, lwork=0, overwrite_lu=1, dtype=t_dtype)\\n if cv:\\n if isMatrix:\\n return ainv.to_numpy_matrix()\\n else:\\n return ainv.to_numpy_array()\\n else:\\n return ainv\",\n \"def inverse(self):\\r\\n \\r\\n Mi=mat4()\\r\\n d=self.determinant()\\r\\n for i in range(4):\\r\\n for j in range(4):\\r\\n sign=1-((i+j)%2)*2\\r\\n m3=self._submat(i,j)\\r\\n Mi[j,i]=sign*m3.determinant()/d\\r\\n return Mi\",\n \"def opposite(x):\\n return -1*x\",\n \"def ssc.inverse (x_ij):\\n\\n Hij = xyzrph2matrix (x_ij)\\n Rji = Hij[0:3, 0:3]\\n tij = Hij[0:3,3]\\n Rij = Rji.transpose ()\\n tji = -Rij.dot (tij)\\n Hji = zeros ((4,4))\\n Hji[0:3,0:3] = Rij\\n Hji[0:3,3] = tji\\n Hji[3,3] = 1\\n return matrix2xyzrph (Hji)\",\n \"def inverse(self):\\n def inv(v):\\n v[0], v[1] = v[1] , v[0]\\n for v in [self.point1 , self.pointN , self.unitv, self.normalv]:\\n inv(v)\\n\\n self.points = numpy.roll(self.points,1,axis=1)\\n self.a, self.b = self.b, self.a\\n self.angle = numpy.arccos( self.unitv[0] )*numpy.sign(self.unitv[1] )\\n return\",\n \"def inverse_transform(v):\\n v, k = divmod(v - 1, N)\\n v, j = divmod(v, N)\\n v, i = divmod(v, N)\\n return i, j, k\",\n \"def inverse_basis(T, dimensions, t):\\n B = basis(T, dimensions, t)\\n return inv(B.T.dot(B)).dot(B.T)\",\n \"def test_inverse_transform(self):\",\n \"def inv(X):\\n R, t = Rt(X)\\n Ri = R.T\\n return np.concatenate((\\n np.concatenate((Ri, -Ri.dot(t)[:,np.newaxis]), axis=1),\\n np.array([[0, 0, 1]])))\",\n \"def inverse(self):\\n if self.inv is None:\\n if self.size > 0:\\n self.inv = inverseIndex(self)\\n else:\\n self.inv = Connectivity()\\n return self.inv\",\n \"def inverse(self, x):\\n x = np.asarray(x)\\n def r(vec):\\n return utils.recycled(vec, as_=x)\\n if self.zero is not None and self.multiplier is not None:\\n x = x / r(self.multiplier) + r(self.zero)\\n elif self.zero is not None:\\n x = x + r(self.zero)\\n elif self.multiplier is not None:\\n x = x / r(self.multiplier)\\n return x\",\n \"def inverse(self, x):\\n return self.mul(self.weights, x.unsqueeze(-1)).squeeze(-1) + self.shift\\n #return self.mul(torch.inverse(self.weights), (x - self.shift).unsqueeze(-1)).squeeze(-1)\",\n \"def test_inverse_of_linear_vector_transforms(free_alg: Drudge):\\n\\n dr = free_alg\\n p = dr.names\\n v = p.v\\n\\n a = Vec('a')\\n b = Vec('b')\\n\\n defs = [\\n dr.define(a, v + 1),\\n dr.define(b, v - 1)\\n ]\\n res = dr.lvt_inv(defs)\\n\\n assert len(res) == 2\\n half = Rational(1, 2)\\n one_checked = False\\n v_checked = False\\n for i in res:\\n if i.lhs == 1:\\n assert (i - half * a + half * b).simplify() == 0\\n one_checked = True\\n elif i.lhs == v:\\n assert (i - half * a - half * b).simplify() == 0\\n v_checked = True\\n else:\\n assert False\\n continue\\n\\n assert one_checked and v_checked\",\n \"def test__inverse_transform_continuous(self):\",\n \"def inverse(self):\\n # TODO\\n # detA\\n if not self.is_square():\\n raise(\\n ValueError, \\\"Non-square Matrix does not have an inverse.\\\")\\n if self.h > 2:\\n raise(\\n NotImplementedError, \\\"inversion not implemented for matrices larger than 2x2.\\\")\\n\\n mD = self.determinant()\\n if self.h == 1:\\n if self.g[0][0] = 0:\\n raise(NotImplementedError,\\n \\\"The 1x1 Matrix contains 0 can't inverse\\\")\\n else:\\n return [[1 / self.g[0][0]]] \\n for i in range(self.h): # Calculates the inverse of a 2x2 Matrix.\\n my_Matrix = zeroes(2, 2)\\n my_Matrix.g[1][1] = self.g[0][0] / mD\\n my_Matrix.g[0][0] = self.g[1][1] / mD\\n my_Matrix.g[0][1] = - self.g[0][1] / mD\\n my_Matrix.g[1][0] = - self.g[1][0] / mD\\n return my_Matrix\\n\\n # trace A\\n # 与矩阵TraceA * I identity 单位矩阵\",\n \"def inv(self):\\n return self.conjugate()\",\n \"def __invert(self, args):\",\n \"def inverse(self):\\n n = self.norm()\\n c = self.conj()\\n d = 1.0 / (n * n)\\n c.scale(d)\\n return c\",\n \"def inverse(self, u: Tensor, covariates: Tensor) -> Tensor:\\n return self.real_nvp.inverse(u, covariates)\",\n \"def inv(self):\\n self.inverse = not self._inverse\\n return self\",\n \"def inverse(self: T) -> T:\",\n \"def InverseMatrix(matrix,vector):\\r\\n # Unveri reversible matrix\\r\\n if Determinant(matrix, 1) == 0:\\r\\n print(\\\"Error,Singular Matrix\\\\n\\\")\\r\\n return\\r\\n # result matrix initialized as singularity matrix\\r\\n result = MakeIMatrix(len(matrix), len(matrix))\\r\\n # loop for each row\\r\\n for i in range(len(matrix[0])):\\r\\n # turn the pivot into 1 (make elementary matrix and multiply with the result matrix )\\r\\n # pivoting process\\r\\n matrix, vector = RowXchange(matrix, vector)\\r\\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\\r\\n elementary[i][i] = 1/matrix[i][i]\\r\\n result = MultiplyMatrix(elementary, result)\\r\\n matrix = MultiplyMatrix(elementary, matrix)\\r\\n # make elementary loop to iterate for each row and subtracrt the number below (specific) pivot to zero (make\\r\\n # elementary matrix and multiply with the result matrix )\\r\\n for j in range(i+1, len(matrix)):\\r\\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\\r\\n elementary[j][i] = -(matrix[j][i])\\r\\n matrix = MultiplyMatrix(elementary, matrix)\\r\\n result = MultiplyMatrix(elementary, result)\\r\\n\\r\\n\\r\\n # after finishing with the lower part of the matrix subtract the numbers above the pivot with elementary for loop\\r\\n # (make elementary matrix and multiply with the result matrix )\\r\\n for i in range(len(matrix[0])-1, 0, -1):\\r\\n for j in range(i-1, -1, -1):\\r\\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\\r\\n elementary[j][i] = -(matrix[j][i])\\r\\n matrix = MultiplyMatrix(elementary, matrix)\\r\\n result = MultiplyMatrix(elementary, result)\\r\\n\\r\\n return result\",\n \"def invert(self, results, inverse_data):\\n import mosek\\n # Status map is taken from:\\n # https://docs.mosek.com/8.1/pythonapi/constants.html?highlight=solsta#mosek.solsta\\n STATUS_MAP = {mosek.solsta.optimal: s.OPTIMAL,\\n mosek.solsta.integer_optimal: s.OPTIMAL,\\n mosek.solsta.prim_feas: s.OPTIMAL_INACCURATE, # for integer problems\\n mosek.solsta.prim_infeas_cer: s.INFEASIBLE,\\n mosek.solsta.dual_infeas_cer: s.UNBOUNDED}\\n # \\\"Near\\\" statuses only up to Mosek 8.1\\n if hasattr(mosek.solsta, 'near_optimal'):\\n STATUS_MAP_INACCURATE = {mosek.solsta.near_optimal: s.OPTIMAL_INACCURATE,\\n mosek.solsta.near_integer_optimal: s.OPTIMAL_INACCURATE,\\n mosek.solsta.near_prim_infeas_cer: s.INFEASIBLE_INACCURATE,\\n mosek.solsta.near_dual_infeas_cer: s.UNBOUNDED_INACCURATE}\\n STATUS_MAP.update(STATUS_MAP_INACCURATE)\\n STATUS_MAP = defaultdict(lambda: s.SOLVER_ERROR, STATUS_MAP)\\n\\n env = results['env']\\n task = results['task']\\n solver_opts = results['solver_options']\\n\\n if inverse_data['integer_variables']:\\n sol = mosek.soltype.itg\\n elif 'bfs' in solver_opts and solver_opts['bfs'] and inverse_data['is_LP']:\\n sol = mosek.soltype.bas # the basic feasible solution\\n else:\\n sol = mosek.soltype.itr # the solution found via interior point method\\n\\n problem_status = task.getprosta(sol)\\n solution_status = task.getsolsta(sol)\\n\\n status = STATUS_MAP[solution_status]\\n\\n # For integer problems, problem status determines infeasibility (no solution)\\n if sol == mosek.soltype.itg and problem_status == mosek.prosta.prim_infeas:\\n status = s.INFEASIBLE\\n\\n if status in s.SOLUTION_PRESENT:\\n # get objective value\\n opt_val = task.getprimalobj(sol) + inverse_data[s.OBJ_OFFSET]\\n # recover the cvxpy standard-form primal variable\\n z = [0.] * inverse_data['n0']\\n task.getxxslice(sol, 0, len(z), z)\\n primal_vars = {inverse_data[self.VAR_ID]: z}\\n # recover the cvxpy standard-form dual variables\\n if sol == mosek.soltype.itg:\\n dual_vars = None\\n else:\\n dual_vars = MOSEK.recover_dual_variables(task, sol, inverse_data)\\n else:\\n if status == s.INFEASIBLE:\\n opt_val = np.inf\\n elif status == s.UNBOUNDED:\\n opt_val = -np.inf\\n else:\\n opt_val = None\\n primal_vars = None\\n dual_vars = None\\n\\n # Store computation time\\n attr = {s.SOLVE_TIME: task.getdouinf(mosek.dinfitem.optimizer_time)}\\n\\n # Delete the mosek Task and Environment\\n task.__exit__(None, None, None)\\n env.__exit__(None, None, None)\\n\\n return Solution(status, opt_val, primal_vars, dual_vars, attr)\",\n \"def __invert__(self):\\n try:\\n B = ~(self.matrix())\\n except ZeroDivisionError:\\n raise ZeroDivisionError(\\\"matrix morphism not invertible\\\")\\n try:\\n return self.parent().reversed()(B)\\n except TypeError:\\n raise ZeroDivisionError(\\\"matrix morphism not invertible\\\")\",\n \"def inverse_rigid_trans(Tr): \\n inv_Tr = np.zeros_like(Tr) # 3x4\\n inv_Tr[0:3,0:3] = np.transpose(Tr[0:3,0:3])\\n inv_Tr[0:3,3] = np.dot(-np.transpose(Tr[0:3,0:3]), Tr[0:3,3])\\n return inv_Tr\",\n \"def inverse(self):\\n cdef StdVectorFst result = self.copy()\\n result.invert()\\n return result\",\n \"def Mq_inv(self, q):\\n\\t\\traise NotImplementedError\",\n \"def inverse(self) -> np.ndarray:\\n if self.is_versor():\\n return self.conjugate\\n return self.conjugate / np.linalg.norm(self.q)\",\n \"def inverse(self):\\n if self.determinant() != 0:\\n ops = reduce_to_red_echelon(self.data.copy(), True)[1]\\n matrix = identity_matrix(self.n_rows).data\\n \\n if ops:\\n if isinstance(ops[0], str):\\n ops = [ops]\\n \\n for op in ops:\\n if op[0] == 'swap':\\n matrix = row_swap(matrix, op[1], op[2])\\n elif op[0] == 'multiplication':\\n matrix = row_multiply(matrix, op[1], op[2])\\n elif op[0] == 'subtract':\\n matrix = row_subtract(matrix, op[1], op[2], op[3])\\n else:\\n raise ValueError('Row operation not recognized')\\n else:\\n raise ValueError('Matrix has a determinant of 0 and is not invertible')\\n return Matrix(matrix)\",\n \"def inverse(self, x, *args, **kwargs):\\n if self.list_of_inverses is None:\\n utils.print_warning(\\\"inverses were not given\\\")\\n return\\n for i in range(len(self.list_of_inverses)):\\n x = self.list_of_inverses[i](x, *args, **kwargs)\\n return x\",\n \"def inverse_matrice(T):\\n a,b,c,d = T[0][0],T[0][1],T[1][0],T[1][1]\\n det = a*d-b*c\\n aa,bb,cc,dd = d/det,-b/det,-c/det,a/det\\n Tinv = [[aa,bb],[cc,dd]]\\n return Tinv\",\n \"def inverse(self):\\n ss = self._sum_of_squares()\\n if ss > 0:\\n return self.__class__(array=(self._vector_conjugate() / ss))\\n else:\\n raise ZeroDivisionError(\\\"a zero quaternion (0 + 0i + 0j + 0k) cannot be inverted\\\")\",\n \"def inverse(self, z, y):\\n y_summary = self.summary_net(y)\\n return self.invertible_net(z, y_summary, inverse=True)\",\n \"def inv(self):\\n return MoebGen(self._d / self._det, - self._b / self._det, - self._c / self._det, self._a / self._det)\",\n \"def find_inverse(a,n):\\n if a==0 or gcd(a,n)!=1: return \\\".\\\"\\n if a==1: return 1\\n k=1\\n while True:\\n a_inv = (1+n*k)/a \\n if a_inv.is_integer():\\n return int(a_inv)\\n else:\\n k=k+1\",\n \"def _vect_matrix_inverse(A):\\n identity = np.identity(A.shape[2], dtype=A.dtype)\\n return np.array([np.linalg.solve(x, identity) for x in A])\",\n \"def inverse(num, r):\\n if int(num) == 0:\\n return 0\\n else:\\n # Multiply with every number in the field and\\n # check if the result is one. Easy Peasy!\\n # Todo: Use Extended Euclidean Algo\\n # or Logs/Anti-Logs\\n for i in range(1, 256):\\n if _multiply(num, i, r) == 1:\\n return i\",\n \"def inverse_transform(self, x):\\n raise NotImplementedError()\",\n \"def solve(self):\",\n \"def inverse(self, y):\\n device = y.device\\n return t.einsum('ij,k,kj->ik', y, 1. / t.sqrt(self.eig).to(device), self.rot.to(device))\",\n \"def inverse_transform(self, X):\\n\\n pass # pragma: no cover\",\n \"def inverse(self):\\n return ~self\",\n \"def inverse(self: Float[LinearOperator, \\\"*batch N N\\\"]) -> Float[LinearOperator, \\\"*batch N N\\\"]:\\n return self.__class__(self._diag.reciprocal())\",\n \"def _tridi_inverse_iteration(d, e, w, x0=None, rtol=1e-6):\\n\\teig_diag = d - w\\n\\tif x0 is None:\\n\\t\\tx0 = np.random.randn(len(d))\\n\\tx_prev = np.zeros_like(x0)\\n\\tnorm_x = np.linalg.norm(x0)\\n\\t# the eigenvector is unique up to sign change, so iterate\\n\\t# until || |x^(n)| - |x^(n-1)| ||^2 < rtol\\n\\tx0 /= norm_x\\n\\twhile np.linalg.norm(np.abs(x0) - np.abs(x_prev)) > rtol:\\n\\t\\tx_prev = x0.copy()\\n\\t\\t_tridisolve(eig_diag, e, x0)\\n\\t\\tnorm_x = np.linalg.norm(x0)\\n\\t\\tx0 /= norm_x\\n\\treturn x0\",\n \"def mod_inverse_iterative(a, b):\\n x, y, u, v = 0, 1, 1, 0\\n while a != 0:\\n q = int(b / a)\\n r = b % a\\n m = x - u * q\\n n = y - v * q\\n b, a, x, y, u, v = a, r, u, v, m, n\\n return b, x, y\",\n \"def invertible(A, B):\\n\\tdetA = la.det(A)\\n\\tdetB = la.det(B)\\n\\t\\n\\tif (detA == 0):\\n\\t\\tif (detB == 0):\\n\\t\\t\\tprint(\\\"None are invertible\\\")\\n\\t\\telse:\\n\\t\\t\\treturn B\\n\\telse:\\n\\t\\tif (detB == 0):\\n\\t\\t\\treturn A\\n\\t\\telse:\\n\\t\\t\\tprint(\\\"Both are invertible\\\")\",\n \"def invert(self):\\n if self.m != self.n:\\n raise exc.LinearAlgebraError(\\\"cannot invert a non-square matrix\\\")\\n if self.determinant == 0:\\n raise exc.LinearAlgebraError(\\\"cannot invert a singular matrix\\\")\\n # TODO: implement block matrices in their own method\\n block_rows = [r1 + r2 for r1, r2 in\\n zip(self.data, self.makeIdentity(self.m).data)]\\n inverse_block = Matrix.fromRows(block_rows).row_reduce()\\n return inverse_block.subset([i for i in range(self.m)],\\n [j + self.n for j in range(self.n)])\",\n \"def pseudoInversa(J):\\n\\tJinv = np.linalg.pinv(J)\\n\\treturn Jinv\",\n \"def inverse_transform(self, y: Array2D) -> Array2D:\",\n \"def test_inverse_non_interacting(self, size):\\n t_nn = 1.2\\n idx = np.arange(size)\\n g0_inv_full = np.zeros((size, size), dtype=complex)\\n g0_inv_full[idx[:-1], idx[1:]] = g0_inv_full[idx[1:], idx[:-1]] = t_nn\\n for g0 in self.g0_loc_inv:\\n g0_inv_full[idx, idx] = g0\\n rv, h, rv_inv = gt.matrix.decompose_gf(g0_inv_full)\\n g0 = gt.matrix.construct_gf(rv_inv=rv_inv, diag_inv=h**-1, rv=rv)\\n assert_allclose(g0.dot(g0_inv_full), np.identity(size), atol=1e-14)\\n assert_allclose(g0, la.inv(g0_inv_full))\\n g0_alt = gt.matrix.Decomposition(rv, h**-1, rv_inv).reconstruct(kind='full')\\n assert_allclose(g0, g0_alt)\",\n \"def inverse(self, ys):\\n with torch.no_grad():\\n xs = torch.matmul(ys, torch.diag(torch.reciprocal(torch.exp(self.scaling_diag))))\\n xs = self.layer4.inverse(xs)\\n xs = self.layer3.inverse(xs)\\n xs = self.layer2.inverse(xs)\\n xs = self.layer1.inverse(xs)\\n return xs\",\n \"def ginverse(p, x):\\n x_ = x.data\\n sinu = torch.sin(p.narrow(-1,0,1)).pow(2)\\n x_.narrow(-1,1,1).mul_(sinu.pow(-1))\\n return x_\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78967696","0.768662","0.7365531","0.7246305","0.7235828","0.71719176","0.7033936","0.69739187","0.69531745","0.6916821","0.6867409","0.6858064","0.6847429","0.68383527","0.6826942","0.68186474","0.6793239","0.6787958","0.67806756","0.67797565","0.6773841","0.67426556","0.67390823","0.67216974","0.67202854","0.66869056","0.6686556","0.66855305","0.66855305","0.66855305","0.66855305","0.66855305","0.6680804","0.6677164","0.66722023","0.6651823","0.6651823","0.6649977","0.6638236","0.6636141","0.66352916","0.6608896","0.6597504","0.6596732","0.657836","0.65728307","0.65655625","0.6564429","0.65634644","0.654639","0.6544119","0.652951","0.6494564","0.6493348","0.64831847","0.6474903","0.6466217","0.6460166","0.6457555","0.6453759","0.64521766","0.64490217","0.64348596","0.6406753","0.63987166","0.63984036","0.6386605","0.6382849","0.63687605","0.636531","0.6363698","0.63501316","0.6347803","0.6329411","0.6304527","0.6300951","0.6296811","0.62956","0.6289662","0.62890935","0.6285575","0.62845165","0.6277645","0.6274996","0.6271446","0.6263067","0.6260021","0.6258347","0.6257408","0.6254754","0.62429255","0.62428105","0.62355775","0.62242174","0.6205959","0.61958075","0.6190573","0.6188359","0.6169984","0.6167521","0.61672896"],"string":"[\n \"0.78967696\",\n \"0.768662\",\n \"0.7365531\",\n \"0.7246305\",\n \"0.7235828\",\n \"0.71719176\",\n \"0.7033936\",\n \"0.69739187\",\n \"0.69531745\",\n \"0.6916821\",\n \"0.6867409\",\n \"0.6858064\",\n \"0.6847429\",\n \"0.68383527\",\n \"0.6826942\",\n \"0.68186474\",\n \"0.6793239\",\n \"0.6787958\",\n \"0.67806756\",\n \"0.67797565\",\n \"0.6773841\",\n \"0.67426556\",\n \"0.67390823\",\n \"0.67216974\",\n \"0.67202854\",\n \"0.66869056\",\n \"0.6686556\",\n \"0.66855305\",\n \"0.66855305\",\n \"0.66855305\",\n \"0.66855305\",\n \"0.66855305\",\n \"0.6680804\",\n \"0.6677164\",\n \"0.66722023\",\n \"0.6651823\",\n \"0.6651823\",\n \"0.6649977\",\n \"0.6638236\",\n \"0.6636141\",\n \"0.66352916\",\n \"0.6608896\",\n \"0.6597504\",\n \"0.6596732\",\n \"0.657836\",\n \"0.65728307\",\n \"0.65655625\",\n \"0.6564429\",\n \"0.65634644\",\n \"0.654639\",\n \"0.6544119\",\n \"0.652951\",\n \"0.6494564\",\n \"0.6493348\",\n \"0.64831847\",\n \"0.6474903\",\n \"0.6466217\",\n \"0.6460166\",\n \"0.6457555\",\n \"0.6453759\",\n \"0.64521766\",\n \"0.64490217\",\n \"0.64348596\",\n \"0.6406753\",\n \"0.63987166\",\n \"0.63984036\",\n \"0.6386605\",\n \"0.6382849\",\n \"0.63687605\",\n \"0.636531\",\n \"0.6363698\",\n \"0.63501316\",\n \"0.6347803\",\n \"0.6329411\",\n \"0.6304527\",\n \"0.6300951\",\n \"0.6296811\",\n \"0.62956\",\n \"0.6289662\",\n \"0.62890935\",\n \"0.6285575\",\n \"0.62845165\",\n \"0.6277645\",\n \"0.6274996\",\n \"0.6271446\",\n \"0.6263067\",\n \"0.6260021\",\n \"0.6258347\",\n \"0.6257408\",\n \"0.6254754\",\n \"0.62429255\",\n \"0.62428105\",\n \"0.62355775\",\n \"0.62242174\",\n \"0.6205959\",\n \"0.61958075\",\n \"0.6190573\",\n \"0.6188359\",\n \"0.6169984\",\n \"0.6167521\",\n \"0.61672896\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84783,"cells":{"query":{"kind":"string","value":"Subset selection for Deep Neural Networks. Solves an inverse problem to find a suited input that minimizes the cost function given in calcCost."},"document":{"kind":"string","value":"def __init__(self, calcGrad, calcCost, input, alpha = 0.01, gamma = 0.1):\n\tVisualizer.__init__(self, calcGrad, calcCost, input)\n\tself.alpha = alpha\n\tself.gamma = gamma"},"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 training_batch_selection(train_set_size, input_img):\n\n input_dims = input_img.shape\n all_data_indices = np.arange(input_dims[0]*input_dims[1])\n all_data_indices = all_data_indices.reshape(input_dims[:-1])\n\n conf = get_config()\n inside = int(np.floor(conf[\"inside_part\"]))\n outside = int(np.floor(conf[\"outside_part\"]))\n cx = ii.image.c_x\n cy = ii.image.c_y\n\n # Find the position of the crop in the image and determine part least affected by radial distortion\n center_x = (conf[\"crop\"][\"left_top\"]['x'] + conf[\"crop\"][\"size\"][\"height\"]/2)*2/ii.image.height-1.\n center_y = (conf[\"crop\"][\"left_top\"]['y'] + conf[\"crop\"][\"size\"][\"width\"]/2)*2/ii.image.width-1.\n\n left_right_center = max(min((center_y-cy)*2, 1), -1)\n top_bot_center = max(min((center_x - cx) * 2, 1), -1)\n\n # DEBUG: set your own center\n # left_right_center = 0\n # top_bot_center = 0\n\n from_x = int(round(inside*(1.-top_bot_center)))\n to_x = min(-int(round(inside*(1.+top_bot_center))), -1)\n from_y = int(round(inside*(1.-left_right_center)))\n to_y = min(-int(round(inside*(1.+left_right_center))), -1)\n\n # Exclude part that is minimally affected by radial distortion\n selection_exclude = all_data_indices[from_x:to_x, from_y:to_y]\n selection_exclude = selection_exclude.reshape(-1)\n\n # Exclude outer border in order to avoid index out of bounds\n selection_include = all_data_indices[outside:-outside,\n outside:-outside]\n selection_include = selection_include.reshape(-1)\n\n selection = [x for x in selection_include if x not in selection_exclude]\n selection = np.random.permutation(selection)\n\n # DEBUG: forcing larger training set\n train_set_size = int(train_set_size*2)\n\n selection = selection[:train_set_size]\n\n # DEBUG: display image region for selection\n image = input_img.reshape(-1)\n image[:] = 0\n image[selection_include] = input_img.reshape(-1)[selection_include]\n image[selection_exclude] = 0\n image = image.reshape(input_dims[0], input_dims[1])\n Verbose.imshow(image, Verbose.debug)\n\n return selection","def _selection(self, evaluations, selection, method=\"truncated\", best_rate=0.2):\n\n if selection:\n end_range_for_parents = max(1, int(self.population_size * best_rate))\n evaluations_sorted = torch.sort(evaluations)\n population_sorted = self.population[evaluations_sorted[1]]\n\n if self.best_individual is None:\n self.best_individual = population_sorted[0]\n self.best_eval = evaluations_sorted[0][0]\n elif self.best_eval > evaluations_sorted[0][0]:\n self.best_individual = population_sorted[0]\n self.best_eval = evaluations_sorted[0][0]\n best_population = torch.zeros([end_range_for_parents, len(self.population[0])], device=self.device)\n if method == \"truncated\":\n \"\"\"\n returns best individuals\n \"\"\"\n best_population = population_sorted[:end_range_for_parents]\n elif method == \"fitness_based\":\n \"\"\"\n probability of each individual to be selected is proportional to its fitness value\n \"\"\"\n tot = sum(evaluations)\n probabilities = evaluations / tot\n for i in range(end_range_for_parents):\n best_idx = torch.distributions.categorical.Categorical(\n probabilities.clone().detach()).sample()\n best_population[i] = self.population[best_idx]\n # avoid repetitions\n probabilities[best_idx] = 0\n elif method == \"rank_based\":\n \"\"\"\n probability of each individual to be selected is proportional to its rank value\n \"\"\"\n tot = ((1 + len(evaluations)) / 2) * len(evaluations)\n ranks = torch.linspace(1, len(evaluations), steps=len(evaluations), device=self.device)\n sorted_probabilities = 1 - ranks / tot\n for i in range(end_range_for_parents):\n best_idx = torch.distributions.categorical.Categorical(\n sorted_probabilities).sample()\n best_population[i] = population_sorted[best_idx]\n # avoid repetitions\n sorted_probabilities[best_idx] = 0\n if self.elitism:\n best_population[end_range_for_parents - 1] = self.best_individual\n else:\n best_population = self.population\n return best_population","def select_model():\r\n from sklearn import tree\r\n import graphviz\r\n\r\n ValidationSetAndLabels = AllSets[1]\r\n ValLabels = ValidationSetAndLabels[:, [-1]] # extract labels (last column)\r\n ValSet = np.delete(ValidationSetAndLabels, -1, axis=1) # delete labels\r\n\r\n TrainingSetAndLabels = AllSets[2]\r\n TrainLabels = TrainingSetAndLabels[:, [-1]] # extract labels (last column)\r\n TrainSet = np.delete(TrainingSetAndLabels, -1, axis=1) # delete labels\r\n\r\n \"\"\"\r\n This is the code to select the best hyperparameter (part b)\r\n\r\n for SplitCriterion in ['entropy', 'gini']:\r\n print \"Criterion: \" + SplitCriterion + '\\n'\r\n\r\n for MaxDepth in [int(depth) for depth in np.linspace(1, np.log2(TrainSet.shape[1]), 5)]:\r\n print \"max_depth: \" + str(MaxDepth) + '\\n'\r\n\r\n MyTree = tree.DecisionTreeClassifier(criterion=SplitCriterion, max_depth=MaxDepth)\r\n MyTree = MyTree.fit(TrainSet, TrainLabels)\r\n\r\n Predictions = MyTree.predict(ValSet)\r\n Result = np.abs(Predictions - ValLabels.flatten())\r\n\r\n Accuracy = 100 * float(np.count_nonzero(Result == 0)) / Predictions.shape[0]\r\n\r\n print \"Accuracy for this test is: %f %%\" %Accuracy\r\n print '\\n'\r\n\r\n print '\\n'\r\n \"\"\"\r\n\r\n MyTree = tree.DecisionTreeClassifier(criterion='entropy', max_depth=12)\r\n\r\n MyTree = MyTree.fit(TrainSet, TrainLabels)\r\n\r\n Predictions = MyTree.predict(ValSet)\r\n Result = np.abs(Predictions - ValLabels.flatten())\r\n\r\n Accuracy = 100 * float(np.count_nonzero(Result == 0)) / Predictions.shape[0]\r\n\r\n dot_data = tree.export_graphviz(MyTree, out_file=None, max_depth=2,\r\n feature_names=AllSets[3], filled=True, rounded=True, special_characters=True,\r\n class_names=TrainLabels.flatten().astype(str))\r\n graph = graphviz.Source(dot_data)\r\n graph.render(\"output\")","def feature_selection(train_features, test_features, train_similarity_target, test_similarity_target, regressor, used_features):\n\t# percentile selector\n\tpercentile_selector, percentile_score, percentile_train_features_selected, percentile_test_features_selected, percentile_mask = best_percentile_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor)\n\n\t# model based selector\n\tmodel_based_selector, model_based_score, model_based_train_features_selected, model_based_test_features_selected, model_based_mask = best_model_based_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor)\n\n\t# iterative based selector\n\titerative_based_selector, iterative_based_score, iterative_based_train_features_selected, iterative_based_test_features_selected, iterative_based_mask = best_iterative_based_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor)\n\n\tall_scores = []\n\n\tregressor.fit(train_features, train_similarity_target)\n\tprint(\"The score on all features: %.3f\" % regressor.score(test_features, test_similarity_target))\n\tall_scores.append(regressor.score(test_features, test_similarity_target))\n\n\t# show results for the percentile selector\n\tall_scores.append(percentile_score)\n\n\t# show results for the model based selector\n\tall_scores.append(model_based_score)\n\n\t# show results for the iterative based selector\n\tall_scores.append(iterative_based_score)\n\n\tmax_value_position = all_scores.index(max(all_scores))\n\n\tif max_value_position == 0:\n\t\tprint(\"Returning all features!\\n\")\n\t\treturn train_features, test_features\n\telif max_value_position == 1:\n\t\tpercentile_mask = build_mask(percentile_mask, used_features)\n\t\tmask_save_path = os.path.join('feature_selection_masks', 'percentile_mask.txt')\n\t\tdebug_data(percentile_mask, mask_save_path)\n\n\t\tprint(\"Returning features selected with the percentile selector!\\n\")\n\t\treturn percentile_selector, percentile_train_features_selected, percentile_test_features_selected\n\telif max_value_position == 2:\n\t\tmodel_based_mask = build_mask(model_based_mask, used_features)\n\t\tmask_save_path = os.path.join('feature_selection_masks', 'model_based_mask.txt')\n\t\tdebug_data(model_based_mask, mask_save_path)\n\n\t\tprint(\"Returning features selected with the model based selector!\\n\")\n\t\treturn model_based_selector, model_based_train_features_selected, model_based_test_features_selected\n\telse:\n\t\titerative_based_mask = build_mask(iterative_based_mask, used_features)\n\t\tmask_save_path = os.path.join('feature_selection_masks', 'iterative_based_mask.txt')\n\t\tdebug_data(iterative_based_mask, mask_save_path)\n\n\t\tprint(\"Returning features selected with the iterative based selector!\\n\")\n\t\treturn iterative_based_selector, iterative_based_train_features_selected, iterative_based_test_features_selected","def best_iterative_based_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor):\n\titerative_based_score = 0\n\t# given that all pairs use the same amount of features, the position 0 was arbitrarily selected to compute the number of features being used\n\tmin_number_features = int(0.15*len(train_features[0]))\n\tmax_number_features = int(0.85*len(train_features[0]))\n\n\t# min_number_features = 19\n\t# max_number_features = 20\n\n\titerative_based_selector = None\n\titerative_based_train_features_selected = None\n\titerative_based_test_features_selected = None\n\n\tfor i in range(min_number_features, max_number_features):\n\t\tprint(i)\n\t\ttemp_iterative_based_selector = RFE(RandomForestRegressor(n_estimators=100), n_features_to_select=i)\n\t\ttemp_iterative_based_selector.fit(train_features, train_similarity_target)\n\t\ttemp_iterative_based_train_features_selected = temp_iterative_based_selector.transform(train_features)\n\t\ttemp_iterative_based_test_features_selected = temp_iterative_based_selector.transform(test_features)\n\n\t\tregressor.fit(temp_iterative_based_train_features_selected, train_similarity_target)\n\n\t\ttemp_score = regressor.score(temp_iterative_based_test_features_selected, test_similarity_target)\n\t\tprint(\"The score on the selected features (Iterative Based Selector): %.3f\" % temp_score)\n\n\t\tif temp_score > iterative_based_score:\n\t\t\titerative_based_score = temp_score\n\t\t\titerative_based_selector = temp_iterative_based_selector\n\t\t\titerative_based_train_features_selected = temp_iterative_based_train_features_selected\n\t\t\titerative_based_test_features_selected = temp_iterative_based_test_features_selected\n\n\titerative_based_mask = iterative_based_selector.get_support()\n\tprint(\"This is the iterative based mask: \")\n\tprint(iterative_based_mask)\n\n\treturn iterative_based_selector, iterative_based_score, iterative_based_train_features_selected, iterative_based_test_features_selected, iterative_based_mask","def select(self, batch_size):\n\n #if self.tree.filled_size() < batch_size:\n # print('CALLING REPLAY SAMPLING WHEN NOT FULL ENOUGH')\n # #return None, None\n\n out = []\n indices = []\n #weights = []\n priorities = []\n avoid_resampling = False\n for _ in range(batch_size):\n r = random.random()\n #return (idx, self.tree[idx], self.data[dataIdx])\n data, priority, index = self.tree.find(r)\n #index, priority, data = self.tree.find(r)\n #print(index)\n #print(\"d: {}, \\n priority: {}, \\n index: {}\".format(data, priority, index))\n priorities.append(priority)\n #weights.append((1. / self.memory_size / priority) ** beta if priority > 1e-16 else 0)\n indices.append(index)\n out.append(data)\n if avoid_resampling: self.priority_update([index], [self.epsilon_priority]) # To avoid resampling same transition too much\n\n for i in range(len(priorities)):\n if priorities[i] >= self.bonus_priority: # remove priority bonus\n priorities[i] -= self.bonus_priority\n self.priority_update([indices[i]],[priorities[i]])\n\n # avoid resampling part self.priority_update(indices, priorities) # Revert priorities\n #weights /= max(weights) # Normalize for stability\n return out, indices","def evalute_subset(X_train, X_test, y_train, y_test):\r\n clf = KNeighborsClassifier(n_neighbors=3)\r\n clf.fit(X_train, y_train) \r\n y_pred = clf.predict(X_test)\r\n return accuracy_score(y_test, y_pred)","def aux_best_percentile_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor, used_features):\n\tpercentile_score = 0\n\tpercentiles = [25, 35, 45, 50, 55, 65, 75]\n\t# percentiles = [45]\n\tpercentile_selector = None\n\tpercentile_train_features_selected = None\n\tpercentile_test_features_selected = None\n\n\tfor percentile in percentiles:\n\t\tprint(percentile)\n\t\ttemp_percentile_selector = SelectPercentile(score_func=f_regression, percentile=percentile)\n\t\ttemp_percentile_selector.fit(train_features, train_similarity_target)\n\t\ttemp_percentile_train_features_selected = temp_percentile_selector.transform(train_features)\n\t\ttemp_percentile_test_features_selected = temp_percentile_selector.transform(test_features)\n\n\t\tregressor.fit(temp_percentile_train_features_selected, train_similarity_target)\n\n\t\ttemp_score = regressor.score(temp_percentile_test_features_selected, test_similarity_target)\n\t\tprint(\"The score on the selected features (Percentile Selector): %.3f\" % temp_score)\n\n\t\tif temp_score > percentile_score:\n\t\t\tpercentile_score = temp_score\n\t\t\tpercentile_selector = temp_percentile_selector\n\t\t\tpercentile_train_features_selected = temp_percentile_train_features_selected\n\t\t\tpercentile_test_features_selected = temp_percentile_test_features_selected\n\n\tpercentile_mask = percentile_selector.get_support()\n\tprint(\"This is the percentile mask: \")\n\tprint(percentile_mask)\n\n\tpercentile_mask = build_mask(percentile_mask, used_features)\n\tmask_save_path = os.path.join('feature_selection_masks', 'assin2_percentile_based_mask.txt')\n\tdebug_data(percentile_mask, mask_save_path)\n\n\treturn percentile_train_features_selected, percentile_test_features_selected, percentile_selector","def test_subset_imask_squeeze(self, model_data, imask_subset_config):\n # foreach doesn't have this additional dimension\n foreach = [\"techs\"]\n imask = _imask_foreach(model_data, foreach)\n assert imask.dims == (\"techs\",)\n # on using 'where', the 'nodes' dimension is added\n imask = _imask_where(model_data, \"foo\", [\"node_tech\"], imask, \"and_\")\n assert sorted(imask.dims) == sorted([\"nodes\", \"techs\"])\n imask_subset = _subset_imask(\"foo\", imask_subset_config(foreach), imask)\n assert imask_subset.dims == (\"techs\",)\n assert imask_subset.equals(imask.loc[{\"nodes\": \"foo\"}].drop_vars(\"nodes\"))","def best_model_based_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor):\n\tmodel_based_score = 0\n\tscaling_factors = [\"0.25*mean\", \"0.5*mean\", \"median\", \"1.25*mean\", \"1.5*mean\"]\n\t# scaling_factors = [\"0.5*mean\", \"median\"]\n\tmodel_based_selector = None\n\tmodel_based_train_features_selected = None\n\tmodel_based_test_features_selected = None\n\n\tfor factor in scaling_factors:\n\t\tprint(factor)\n\t\ttemp_model_based_selector = SelectFromModel(RandomForestRegressor(n_estimators=100), threshold=factor)\n\t\ttemp_model_based_selector.fit(train_features, train_similarity_target)\n\t\ttemp_model_based_train_features_selected = temp_model_based_selector.transform(train_features)\n\t\ttemp_model_based_test_features_selected = temp_model_based_selector.transform(test_features)\n\n\t\tregressor.fit(temp_model_based_train_features_selected, train_similarity_target)\n\n\t\ttemp_score = regressor.score(temp_model_based_test_features_selected, test_similarity_target)\n\t\tprint(\"The score on the selected features (Model Based Selector): %.3f\" % temp_score)\n\n\t\tif temp_score > model_based_score:\n\t\t\tmodel_based_score = temp_score\n\t\t\tmodel_based_selector = temp_model_based_selector\n\t\t\tmodel_based_train_features_selected = temp_model_based_train_features_selected\n\t\t\tmodel_based_test_features_selected = temp_model_based_test_features_selected\n\n\tmodel_based_mask = model_based_selector.get_support()\n\tprint(\"This is the model based mask: \")\n\tprint(model_based_mask)\n\n\treturn model_based_selector, model_based_score, model_based_train_features_selected, model_based_test_features_selected, model_based_mask","def select(individuals, n):\r\n # return selBest(individuals, n)\r\n return individuals[:n]","def negSamplingCostAndGradient(predicted, target, outputVectors, dataset,\n K=10):\n\n # Sampling of indices is done for you. Do not modify this if you\n # wish to match the autograder and receive points!\n indices = [target]\n indices.extend(getNegativeSamples(target, dataset, K))\n\n ### YOUR CODE HERE\n #The cost now is maximize the predicted and target pair,\n #minimizing the predicted and the sampled pairs\n cost = 0\n gradPred = np.zeros(predicted.shape[0])\n grad = np.zeros(outputVectors.shape)\n\n for indice in indices:\n target_vector = outputVectors[indice]\n vector_product = np.dot(target_vector,predicted)\n if indice != target:\n cost += -np.log(sigmoid(-vector_product))\n gradPred += sigmoid(vector_product)*target_vector\n # use += in case of repeatance\n grad[indice,:] += sigmoid(vector_product)*predicted\n else:\n cost += -np.log(sigmoid(vector_product))\n gradPred += (sigmoid(vector_product) - 1)*target_vector\n grad[indice,:] += (sigmoid(vector_product)-1)*predicted\n ### END YOUR CODE\n #print indices\n\n return cost, gradPred, grad","def local_optimize(X, nrounds=1, cost_weights=(1.,1.,1.), use_all=True, use_subset=False):\n\n old_cost = cost_total(X, cost_weights=cost_weights)\n\n orig_cost = old_cost\n\n configs = [X.names_seats_dict.copy()]\n\n # loop through number of rounds\n for ind1 in range(nrounds):\n\n # loop through randomly\n for ind in np.random.choice(range(len(X.seats)), len(X.seats), replace=True):\n # print(old_cost)\n # get a candidate\n\n if not use_all:\n neighbours_to_check = np.random.choice(X.seats_graph[X.seats[ind]],len(X.seats_graph[X.seats[ind]]), False)\n else:\n if use_subset:\n neighbours_to_check = [st for st in X.seats if np.random.rand() > .5]\n else:\n neighbours_to_check = X.seats\n\n for ind_n in neighbours_to_check:\n\n X_new = X.copy()\n X_new.update(swap_neighbour(X_new, p1=X.seats[ind], p2=ind_n))\n\n new_cost = cost_total(X_new, cost_weights=cost_weights)\n\n # accept if better\n if new_cost < old_cost:\n old_cost = new_cost\n configs.append(X.names_seats_dict)\n X = X_new.copy()\n\n return X, orig_cost, old_cost, configs","def trainModelOnSubset(self, data, attributes, class_label, indices=None, startNode = None, max_depth=-1):\n\t\t\n\t\t#print (data)\n\t\t#print(\"_________---_________\")\n\t\t\n\t\tif startNode == None:\n\t\t\tstartNode = self.root\n\t\t\n\t\t#print(startNode.name)\n\t\t\n\t\t#print(\"Attributes: \" + str(attributes))\n\t\t\n\t\tnew_attributes=attributes[:]\n\t\t\n\t\tif indices == None:\n\t\t\tsubset = data\t\t\t\n\t\telse:\n\t\t\tsubset = data.loc[indices]\n\t\t\n\t\t\n\t\tif (len(new_attributes) > 0 and not subset.empty):\n\t\t\tbestAttribute_index = startNode.trainNode(data, new_attributes, class_label, indices)\n\t\t\tbestAttribute = new_attributes[bestAttribute_index]\n\t\t\tnew_attributes.pop(bestAttribute_index)\n\t\t\tvalues = attributes_full[bestAttribute]\n\t\t\t\n\t\t\t\n\t\t\t\n\t\t\t\n\t\t\tfor i in values:\n\t\t\t\tnode = Node(i)\n\t\t\t\tstartNode.add_child(node)\n\t\t\t\t#print(node.get_name())\n\t\t\t\t#print(bestAttribute)\n\t\t\t\tindex = list(subset.index[subset[bestAttribute] == i])\n\t\t\t\tself.trainModelOnSubset(subset, new_attributes, class_label, index, node)\n\t\t\t\n\t\telse:\n\t\t\tbestAttribute=class_label\n\t\t\tvalues = attributes_full[bestAttribute]\n\t\t\tsublist = data[bestAttribute].tolist()\n\t\t\ttop = 0\n\t\t\tname = \"test\"\n\t\t\tfor i in values:\n\t\t\t\tif sublist.count(i) > top:\n\t\t\t\t\tname = i\n\t\t\t\t\ttop = sublist.count(i)\n\t\t\tnode = Node(name)\n\t\t\tstartNode.add_child(node)","def _select(self):\n # The order of adding mutants and babies is important.\n # Later the statistics are computed assuming this addition order.\n self._add_newpop(self._mutants, self._babies)\n last_idx = min(self.pop_size, len(self._curr_pop))\n # Make sure the best and the worst chromos\n # after the selection are correctly placed.\n self._selects = np.argpartition(self._errors, 0)\n self._selects = self._selects[0:last_idx]\n self._curr_pop = self._curr_pop[self._selects]\n self._diffs = self._diffs[self._selects]\n self._errors = self._errors[self._selects]\n best = self._errors[0]\n if best < self._best_error:\n self._best_error = best\n self._best_gen = self._gen_idx","def best_percentile_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor):\n\tpercentile_score = 0\n\tpercentiles = [25, 35, 45, 50, 55, 65, 75]\n\t# percentiles = [45]\n\tpercentile_selector = None\n\tpercentile_train_features_selected = None\n\tpercentile_test_features_selected = None\n\n\tfor percentile in percentiles:\n\t\tprint(percentile)\n\t\ttemp_percentile_selector = SelectPercentile(score_func=f_regression, percentile=percentile)\n\t\ttemp_percentile_selector.fit(train_features, train_similarity_target)\n\t\ttemp_percentile_train_features_selected = temp_percentile_selector.transform(train_features)\n\t\ttemp_percentile_test_features_selected = temp_percentile_selector.transform(test_features)\n\n\t\tregressor.fit(temp_percentile_train_features_selected, train_similarity_target)\n\n\t\ttemp_score = regressor.score(temp_percentile_test_features_selected, test_similarity_target)\n\t\tprint(\"The score on the selected features (Percentile Selector): %.3f\" % temp_score)\n\n\t\tif temp_score > percentile_score:\n\t\t\tpercentile_score = temp_score\n\t\t\tpercentile_selector = temp_percentile_selector\n\t\t\tpercentile_train_features_selected = temp_percentile_train_features_selected\n\t\t\tpercentile_test_features_selected = temp_percentile_test_features_selected\n\n\tpercentile_mask = percentile_selector.get_support()\n\tprint(\"This is the percentile mask: \")\n\tprint(percentile_mask)\n\n\treturn percentile_selector, percentile_score, percentile_train_features_selected, percentile_test_features_selected, percentile_mask","def finish_sensitivity(self):\n # do at most 1000 features\n idx = torch.randperm(self._features.shape[1])[:100]\n self._features = self._features[:, idx]\n\n weight = self.module.weight.data\n num_features_in = weight.shape[1]\n selected_in = torch.zeros(num_features_in).bool()\n\n # greedy approach to rank in features\n for rank in reversed(range(num_features_in)):\n error_best = torch.Tensor([np.Inf])\n best = None\n\n # loop through remaining features to see which to add next\n for idx_in in range(num_features_in):\n # it's already in the set, no need trying to add it...\n if selected_in[idx_in]:\n continue\n\n # try adding in feature j and compute error\n selected_in[idx_in] = 1\n error_with_j = (\n self._features[selected_in].sum(dim=0) ** 2\n ).sum()\n\n # see if it's better than previous best\n if error_with_j < error_best:\n error_best = error_with_j\n best = idx_in\n\n # remove j from selectedIn for now\n selected_in[idx_in] = 0\n\n # add best one from this round to selectedIn\n selected_in[best] = 1\n\n # also note the rank of best in the sensitivities\n self.sensitivity_in[best] = rank","def runNN(selectables_interests=[[0.0, 0.1, 0.6, 0.7], [0.0, 0.5, 0.6, 1]], profile_interests = [0.0, 0.1, 0.2, 0.3]):\n #Intialise a single neuron neural network.\n # Apply vertical normalisation for the pageobject interests\n if len(selectables_interests)>0:\n selectables_interests = normalize(selectables_interests, axis=0, norm='l1')\n else:\n # If there is nothing to compare it to, return the current profile.\n return profile_interests\n # For the given size of the first element in the array (number of interests) add a dimension of such size\n Interest_Array_Inputs = [[] for i in range(len(selectables_interests[0]))]\n Interest_Array_Outputs = [[] for i in range(len(selectables_interests[0]))]\n # Creating instances of 3 dimensional Inputs/Outputs sets\n for ida, ll in enumerate(selectables_interests):\n # For the number of permutations\n current_fuzzy_element_permutation = fuzzy_permutation(ll)\n for index in range(len(current_fuzzy_element_permutation[0])):\n # Insert array inside column Interest for the input, output.\n Interest_Array_Inputs[current_fuzzy_element_permutation[0][index][0]].append(current_fuzzy_element_permutation[0][index][1][:])\n Interest_Array_Outputs[current_fuzzy_element_permutation[1][index][0]].append([current_fuzzy_element_permutation[1][index][1]])\n profile_Interest_Inputs = []\n # Creating the list of inputs (Leaving out an interest to be predicted)\n for index, inputList in enumerate(fuzzy_permutation(profile_interests)[0]):\n profile_Interest_Inputs.append(inputList[1])\n\n collected_interests = []\n # Training on each individual interest\n for i in range(len(profile_interests)):\n collected_interests.append(initialise_train_result(Interest_Array_Inputs[i], Interest_Array_Outputs[i], profile_Interest_Inputs[i]))\n well_ordered_interests = collected_interests[::-1]\n # Returns the outcoming interests.\n return well_ordered_interests","def index_subset(subset, numTestClasses=7, randomSeed=123 ):\n print(\"datasets.py is ingesting the DF dataset from data/SETA.npz\")\n npzfile = np.load(\"data/SETA.npz\", allow_pickle=True)\n data = npzfile[\"data\"]\n labels = npzfile[\"labels\"]\n npzfile.close()\n distinctLabelCount= len(set(labels))\n \n\n #print(\"distinctLabelCount\", distinctLabelCount)\n \n #random.seed(randomSeed)\n testClasses = random.sample(range(0,distinctLabelCount),numTestClasses)\n\n # Test the overrides \n \n # WORST \n #testClasses = np.array([18.0,16.0,14.0,11.0,10.0,9.0,7.0]).tolist()\n # BEST\n #testClasses = np.array([5.0,6.0,8.0,12.0,13.0,14.0,19.0]).tolist()\n \n testClasses = [np.float64(i) for i in testClasses]\n\n mask = np.isin(labels,testClasses)\n \n \n X_test = data[np.where(mask)]\n X_train = data[np.where(~mask)]\n y_test = labels[np.where(mask)]\n y_train = labels[np.where(~mask)]\n \n if subset==\"background\":\n \n print(\"SETA data\", data.shape)\n print(\"labels\", labels.shape)\n print(testClasses)\n \n print(\"Current working directory is \", os.getcwd())\n X = X_train\n y = y_train\n print(\"SETA background data shape\", X.shape)\n elif subset==\"evaluation\":\n X = X_test\n y = y_test\n print(\"SETA evaluation data shape\", X.shape)\n images = []\n \n #print(\"y shape\", y.shape)\n \n \n for i in range(y.shape[0]):\n images.append({\n 'subset': subset,\n 'class_name': y[i],\n 'data': X[i].reshape(1,X[1].shape[0]) # This is the shape needed for Matching Networks\n #'data': X[i] #.reshape(X[1].shape[0]) # This is the shape needed for MAML\n })\n \n return images","def create_valid_subset(model_data, name, config):\n\n # Start with a mask that is True where the tech exists at a node (across all timesteps and for a each carrier and cost, where appropriate)\n imask = _imask_foreach(model_data, config.foreach)\n if imask is False: # i.e. not all of 'foreach' are in model_data\n return None\n # Add \"where\" info as imasks\n where_array = config.get_key(\"where\", default=[])\n if where_array:\n imask = _imask_where(model_data, name, where_array, imask, \"and_\")\n\n # Add imask based on subsets\n imask = _subset_imask(name, config, imask)\n\n # Only build and return imask if there are some non-zero elements\n if isinstance(imask, xr.DataArray) and imask.sum() != 0:\n # Squeeze out any unwanted dimensions\n if len(imask.dims) > len(config.foreach):\n imask = imask.sum([i for i in imask.dims if i not in config.foreach]) > 0\n # We have a problem if we have too few dimensions at this point...\n if len(imask.dims) < len(config.foreach):\n raise ValueError(f\"Missing dimension(s) in imask for set {name}\")\n\n valid_subset = _get_valid_subset(\n reorganise_xarray_dimensions(imask).astype(bool)\n )\n\n return valid_subset\n\n else:\n return None","def TSP(noOfCities, cityIndicesExcluding1, citiesDistance):\r\n\r\n # Initializing the DP Matrix\r\n # Dictionary because the subset is also to be saved alongwith end vertex as index of dictionary\r\n dpMatrixDict = {}\r\n\r\n # Base case\r\n dpMatrixDict[ ( 1, ), 1 ] = 0\r\n\r\n # Iterating to solve bigger subproblems using dynamic programming\r\n for subsetSizeWithout1 in range(1, noOfCities):\r\n\r\n # Subset is of size subsetSizeWithout1 + 1\r\n print(\"COMPUTING. ON ITERATION NUMBER : \" + str(subsetSizeWithout1) + \" OUT OF \" + str(noOfCities - 1) )\r\n\r\n # Reducing computation by ignoring off the smaller subproblems solutions no longer required\r\n if subsetSizeWithout1 > 3:\r\n smallerEfficientDpMatrixDict = {}\r\n for key in dpMatrixDict:\r\n if len(key[0]) == subsetSizeWithout1:\r\n smallerEfficientDpMatrixDict[key] = dpMatrixDict[key]\r\n dpMatrixDict = smallerEfficientDpMatrixDict\r\n\r\n # Getting the subsets reuired\r\n sizeSpecificSubsets = getSubsets(cityIndicesExcluding1, subsetSizeWithout1)\r\n\r\n # Base cases\r\n for subset in sizeSpecificSubsets:\r\n dpMatrixDict[subset, 1] = 99999999\r\n\r\n\r\n for subset in sizeSpecificSubsets:\r\n\r\n # Computing through each possible end vertex\r\n for j in subset[1:]:\r\n\r\n # List to store the candidates for minimums\r\n possibilities = []\r\n\r\n # Computing through each possible last hop\r\n for k in subset:\r\n\r\n # Storing possibilities alongwith the end vertex\r\n if k != j:\r\n tupleCopy = tupleCopyWithoutElement(subset, j)\r\n possibilities.append( dpMatrixDict[tupleCopy, k] + citiesDistance[k, j] )\r\n\r\n # Getting the minimum path from the possible minimum candidates\r\n try:\r\n minimumPath = min(possibilities)\r\n dpMatrixDict[subset, j] = minimumPath\r\n except:\r\n continue\r\n\r\n\r\n # List for storing all final possible path candidates containing all the vertices\r\n # and a last hop between the start and end vertex to make a cycle\r\n finalHamiltonianPathCandidates = []\r\n\r\n # Final Set(and/or Subset) including all the vertices\r\n almostCompletePath = tuple(range(1, noOfCities + 1))\r\n\r\n # Adding the last hop of the cycle of hamiltonian path between the end and start vertex\r\n for j in cityIndicesExcluding1:\r\n finalHamiltonianPathCandidates.append( dpMatrixDict[almostCompletePath, j] + citiesDistance[j, 1] )\r\n\r\n # Getting the final minimum solution\r\n hamiltonianPathSolution = min(finalHamiltonianPathCandidates)\r\n\r\n # Printing the solution\r\n print(\"The optimal(minimum) length Hamiltonian path distance is : \" + str( hamiltonianPathSolution ) )\r\n\r\n return","def set_subset(self):\r\n if self._random_subset:\r\n perm = torch.randperm(len(self._indices))\r\n self._subset = self._indices[perm][:self._subset_size]\r\n else:\r\n self._subset = torch.Tensor(self._indices[:self._subset_size])","def worker(selection_idx, results_table):\n randgen = np.random.RandomState()\n \n # Data-specific positive set partition (the real-world dataset consists of multiple motif classes, always exactly 3 instances of each class stored consequently).\n # The partition assures that the training and test sets do not share instances of the same motif class\n positive_n_train = round(0.8 * len(positive_set_) / 3) * 3\n block_start_idx = randgen.randint(positive_n_train / 3 + 1) * 3 \n block_end_idx = block_start_idx + len(positive_set_) - positive_n_train\n positive_set_part_train, positive_set_part_test = (np.concatenate((positive_set_[: block_start_idx], positive_set_[block_end_idx: ])), positive_set_[block_start_idx: block_end_idx])\n \n # Negative set partition with random selection of elements to match the size of the positive set\n negative_set = negative_set_[randgen.choice(len(negative_set_), size = positive_set_.shape[0], replace = False)]\n negative_n = len(negative_set)\n negative_n_train = round(negative_n * 0.8)\n negative_set_part_train, negative_set_part_test = (negative_set[: negative_n_train], negative_set[negative_n_train: ])\n \n data_part_train = np.float64(np.concatenate((positive_set_part_train, negative_set_part_train)))\n labels_part_train = np.concatenate((np.ones(len(positive_set_part_train), dtype = 'i1'), np.zeros(len(negative_set_part_train), dtype = 'i1')))\n data_part_test = np.float64(np.concatenate((positive_set_part_test, negative_set_part_test)))\n labels_part_test = np.concatenate((np.ones(len(positive_set_part_test), dtype = 'i1'), np.zeros(len(negative_set_part_test), dtype = 'i1')))\n \n # Specifying the pipeline and the CV structure\n pruner = feature_selection.VarianceThreshold()\n scaler = preprocessing.StandardScaler()\n feature_selector = feature_selection.SelectKBest(feature_selection.f_classif)\n classifier = svm.SVC(kernel = 'rbf', gamma = 0.01, class_weight = 'balanced')\n pipeline0 = pipeline.Pipeline([\n ('pruning', pruner),\n ('scaling', scaler),\n ('selection', feature_selector),\n ('classification', classifier)\n ])\n cv_structure = model_selection.StratifiedShuffleSplit(n_splits = 10, test_size = 0.2)\n scoring = 'recall_macro' #same as balanced accuracy\n grid = model_selection.GridSearchCV(pipeline0, scoring = scoring, param_grid = param_grid, cv = cv_structure, n_jobs = 1)\n \n # Training the pipeline, saving the data\n grid.fit(data_part_train, labels_part_train)\n results_table[selection_idx][0] = np.log10(grid.best_params_['classification__C'])\n results_table[selection_idx][1] = grid.best_params_['selection__k']\n results_table[selection_idx][2] = grid.best_score_\n \n # Testing the pipeline, saving the data\n results_table[selection_idx][3] = grid.score(data_part_test, labels_part_test)","def run_forward_selection(\n training_predictor_table, validation_predictor_table,\n training_target_table, validation_target_table, sklearn_model_object,\n min_fractional_cost_decrease=0.0033):\n\n assert min_fractional_cost_decrease > 0.\n assert min_fractional_cost_decrease < 1.\n\n selected_predictor_names = []\n max_auc_values = [-numpy.inf]\n remaining_predictor_names = list(training_predictor_table)\n\n while len(remaining_predictor_names) > 0:\n num_selected_predictors = len(selected_predictor_names)\n num_remaining_predictors = len(remaining_predictor_names)\n\n print((\n 'Step {0:d} of forward selection: {1:d} predictors selected, '\n '{2:d} remaining...'\n ).format(\n num_selected_predictors + 1, num_selected_predictors,\n num_remaining_predictors\n ))\n\n new_max_auc, best_predictor_name = _forward_selection_step(\n training_predictor_table=training_predictor_table,\n validation_predictor_table=validation_predictor_table,\n training_target_table=training_target_table,\n validation_target_table=validation_target_table,\n remaining_predictor_names=remaining_predictor_names,\n sklearn_model_object=sklearn_model_object\n )\n\n print((\n 'Max validation AUC ({0:.4f}) given by adding {1:s} '\n '(previous max AUC = {2:.4f})'\n ).format(\n new_max_auc, best_predictor_name, max_auc_values[-1]\n ))\n\n stopping_criterion = max_auc_values[-1] * (\n 1. + min_fractional_cost_decrease\n )\n\n if new_max_auc < stopping_criterion:\n break\n\n selected_predictor_names.append(best_predictor_name)\n max_auc_values.append(new_max_auc)\n\n remaining_predictor_names = list(\n set(list(training_predictor_table)) -\n set(selected_predictor_names)\n )\n\n return selected_predictor_names, numpy.array(max_auc_values[1:])","def SelectWorkingSet(L, q):\n i = 0\n index = 0\n while i < int(q/2):\n if L[index, 1] > 0 and L[index, 1] < C:\n WorkingSet[i, 0] = L[index, 0]\n WorkingSet[i, 1] = L[index, 1]\n WorkingSet[i, 2] = index\n i = i + 1\n elif y_train[int(L[index, 0])] == -1 and L[index, 1] <= 0:\n WorkingSet[i, 0] = L[index, 0]\n WorkingSet[i, 1] = L[index, 1]\n WorkingSet[i, 2] = index\n i = i + 1\n elif y_train[int(L[index, 0])] == 1 and L[index, 1] == 100:\n WorkingSet[i, 0] = L[index, 0]\n WorkingSet[i, 1] = L[index, 1]\n WorkingSet[i, 2] = index\n i = i + 1\n index = index + 1\n # print(WorkingSet)\n # print(index)\n\n index = len(y_train) - 1\n while i < int(q):\n j = 0\n while j < (int(q/2)):\n if index == int(WorkingSet[j, 2]):\n # print(\"Hello cunt\")\n # print(index)\n index = index - 1\n # print(index)\n if j > 0:\n j = 0\n else:\n j = j + 1\n if L[index, 1] > 0 + error and L[index, 1] < C:\n WorkingSet[i, 0] = L[index, 0]\n WorkingSet[i, 1] = L[index, 1]\n WorkingSet[i, 2] = index\n i = i + 1\n elif y_train[int(L[index, 0])] == 1 and L[index, 1] <= 0:\n WorkingSet[i, 0] = L[index, 0]\n WorkingSet[i, 1] = L[index, 1]\n WorkingSet[i, 2] = index\n i = i + 1\n elif y_train[int(L[index, 0])] == -1 and L[index, 1] == 100:\n WorkingSet[i, 0] = L[index, 0]\n WorkingSet[i, 1] = L[index, 1]\n WorkingSet[i, 2] = index\n i = i + 1\n index = index - 1\n # print(WorkingSet)\n return WorkingSet","def KS_algorithm(dataset_x, dataset_y, train_size = 0.7, return_dataset = True):\n #Decide number of total samples\n n = dataset_x.shape[0]\n \n #Turn into train_size to float\n try: \n train_size = float(train_size)\n except Expection as e:\n print(e)\n \n #Jusge if the train_size is by ratio or quantity\n if 0 < train_size < 1: \n num_of_samples = round(n*train_size)\n elif 1 < train_size < 2: \n return \"Train size must be between 1 to 0 or 2 to number of total samples\" \n elif train_size == n or train_size == 1:\n return [x for x in range(n)]\n elif 2 <= train_size < n:\n num_of_samples = round(train_size)\n elif train_size > n:\n return \"Num_of_samples must be less than or equal to original number of samples\"\n \n #Create original sample index\n samples = [x for x in range(n)]\n \n #Create distance matrix\n print('Building distance matrix')\n dist_matrix = create_dist_matrix(dataset_x)\n\n #Pick first two furthest away data points\n print('Picking two furthest away samples')\n max_array = np.argmax(dist_matrix == np.max(dist_matrix), axis = 1)\n ind1 = max_array[max_array != 0][0]\n ind2 = max_array[ind1]\n\n #Initiate chosen sample list, append first two samples and remove from remaining sample list\n chosen_samples = [ind1, ind2]\n samples.remove(ind1)\n samples.remove(ind2) \n remaining_samples = num_of_samples - 2\n\n #Continue picking samples if not yet reaching target number of samples\n while remaining_samples > 0:\n sub_array = np.min(dist_matrix[:,chosen_samples], axis=1)\n chosen = np.argmax(sub_array)\n chosen_samples.append(chosen)\n samples.remove(chosen)\n remaining_samples -= 1\n \n #See if this function should return train and test set or simply index of chosen samples\n if return_dataset == True:\n not_chosen_samples = [x for x in range(n) if x not in chosen_samples]\n return dataset_x.iloc[chosen_samples,:], dataset_x.iloc[not_chosen_samples,:], dataset_y.iloc[chosen_samples,:], dataset_y.iloc[not_chosen_samples,:] \n else:\n return chosen_samples","def test_cost_consideration():\n # input\n net = create_test_net()\n idx = pp.create_sgen(net, 1, 1.3, index=2)\n pp.create_poly_cost(net, idx, \"sgen\", 2.3, index=4)\n pp.runpp(net)\n assert all(net.sgen.index.values == np.array([0, 5, 2]))\n assert all(net.poly_cost.element == np.array([0, 0, 5, 2]))\n\n for cost_type in [\"poly_cost\", \"pwl_cost\"]:\n\n if cost_type == \"pwl_cost\":\n for poly in net.poly_cost.itertuples():\n net.poly_cost.drop(poly.Index, inplace=True)\n pp.create_pwl_cost(net, poly.element, poly.et, [[0, 20, 1]], index=poly.Index)\n\n # eq generation\n boundary_buses = [0, 2]\n internal_buses = [1]\n eq_net1 = pp.grid_equivalents.get_equivalent(net, \"rei\", boundary_buses, internal_buses)\n eq_net2 = pp.grid_equivalents.get_equivalent(net, \"rei\", boundary_buses, internal_buses,\n return_internal=False)\n\n # check elements\n check_elements_amount(eq_net1, {\"bus\": 6, \"load\": 3, \"sgen\": 3, \"shunt\": 5, \"ext_grid\": 1,\n \"line\": 2, \"impedance\": 10, cost_type: 4},\n check_all_pp_elements=True)\n check_elements_amount(eq_net2, {\"bus\": 5, \"load\": 3, \"sgen\": 2, \"shunt\": 5, \"ext_grid\": 1,\n \"impedance\": 10, cost_type: 3},\n check_all_pp_elements=True)\n assert all(eq_net1.sgen.index.values == np.array([0, 1, 2])) # simple create_sgen()\n # without index=... expected\n assert all(eq_net2.sgen.index.values == np.array([0, 1]))\n\n # --- check poly cost\n # eq_net1\n assert np.all(net[cost_type].loc[net[cost_type].et == \"ext_grid\"].values ==\n eq_net1[cost_type].loc[eq_net1[cost_type].et == \"ext_grid\"])\n for i in range(3):\n idx_net = net.sgen.sort_values(\"p_mw\").index[i]\n idx_eq_net = eq_net1.sgen.sort_values(\"p_mw\").index[i]\n assert np.all(net[cost_type].loc[(net[cost_type].element == idx_net) &\n (net[cost_type].et == \"sgen\")].drop(\n columns=[\"element\"]).values ==\n eq_net1[cost_type].loc[(eq_net1[cost_type].element == idx_eq_net) &\n (eq_net1[cost_type].et == \"sgen\")].drop(\n columns=[\"element\"]).values)\n\n # eq_net2\n assert np.all(net[cost_type].loc[net[cost_type].et == \"ext_grid\"].values ==\n eq_net2[cost_type].loc[eq_net2[cost_type].et == \"ext_grid\"])\n for i in range(2):\n idx_net = net.sgen.loc[~net.sgen.bus.isin(boundary_buses+internal_buses)].sort_values(\n \"p_mw\").index[i]\n idx_eq_net = eq_net2.sgen.sort_values(\"p_mw\").index[i]\n assert np.all(net[cost_type].loc[(net[cost_type].element == idx_net) &\n (net[cost_type].et == \"sgen\")].drop(\n columns=[\"element\"]).values ==\n eq_net2[cost_type].loc[(eq_net2[cost_type].element == idx_eq_net) &\n (eq_net2[cost_type].et == \"sgen\")].drop(\n columns=[\"element\"]).values)","def training_batch_selection_affine(train_set_size, input_dims):\n all_data_indices = np.arange(input_dims[0]*input_dims[1])\n all_data_indices = all_data_indices.reshape(input_dims)\n max_misplacement = int(np.floor(get_config()[\"expected_max_px_misplacement\"]))\n selection = all_data_indices[max_misplacement:-max_misplacement,\n max_misplacement:-max_misplacement]\n selection = selection.reshape(-1)\n selection = np.random.permutation(selection)\n selection = selection[:train_set_size]\n\n return selection","def runRandom(self):\n \n # Implementing Random Selection\n\n N = self.myDS.shape[0] \n d = self.myDS.shape[1] \n self.opt_selected = []\n total_reward = 0\n for n in range(0, N):\n ad = random.randrange(d)\n self.opt_selected.append(ad)\n reward = self.myDS.values[n, ad]\n total_reward = total_reward + reward\n \n return total_reward","def select_sweepstakes(self):\n pass","def diophantine_subset_sum(number_list, target, time_limit=TIME_LIMIT):\n started_at = time.time()\n\n # Sort numbers list.\n number_list = sorted(number_list)\n\n # Build sums list.\n sums_list = [number_list[0]]\n for n in range(1, len(number_list)):\n sums_list.append(number_list[n] + sums_list[n-1])\n\n # Sanity check target.\n if number_list[0] > target or target > sums_list[-1]:\n return []\n\n # Add first subset to subset stack.\n subset_stack = [(len(number_list)-1, target, ())]\n\n # Process subset stack.\n while subset_stack:\n # Enforce time constraint.\n runtime = time.time() - started_at\n if runtime > time_limit:\n raise SummerTimeoutError('No solution found in %d seconds.' % (time_limit))\n\n # Pop first subset off queue\n offset, subtarget, subset = subset_stack.pop()\n\n # Keeps only sums less than subset target.\n sumlist_offset = 0\n while sums_list[sumlist_offset] < subtarget and sumlist_offset < len(sums_list)-1:\n sumlist_offset += 1\n\n # If next sums list value matches subset target, we have a solution.\n if sums_list[sumlist_offset] == subtarget:\n return subset + tuple(number_list[0:sumlist_offset+1])\n\n # Keep only numbers in list less than subset target.\n while number_list[offset] > subtarget and offset > 0:\n offset = offset - 1\n\n # If next number in list matches subset target, we have a solution.\n if number_list[offset] == subtarget:\n return subset + tuple([number_list[offset]])\n\n # Add subsets to queue for any number list values falling between sums list\n # offset and numbers list offset\n step = (sumlist_offset <= offset) and 1 or -1\n for new_offset in range(sumlist_offset, offset+step, step):\n\n new_subset = subset + tuple([number_list[new_offset]])\n new_subtarget = subtarget - number_list[new_offset]\n\n if number_list[0] > new_subtarget:\n break\n\n subset_stack.append((new_offset-1, new_subtarget, new_subset))\n\n # Solution not found\n return []","def test_subset_imask_non_iterable_subset(self, model_data, imask_subset_config):\n foreach = [\"nodes\", \"techs\"]\n imask = _imask_foreach(model_data, foreach)\n\n with pytest.raises(TypeError) as excinfo:\n _subset_imask(\n \"foo\", AttrDict({\"foreach\": foreach, \"subset.nodes\": \"bar\"}), imask\n )\n assert check_error_or_warning(\n excinfo,\n \"set `foo` must subset over an iterable, instead got non-iterable `bar` for subset `nodes`\",\n )","def scan(\n self,\n clean_x: np.ndarray,\n adv_x: np.ndarray,\n clean_size: Optional[int] = None,\n advs_size: Optional[int] = None,\n run: int = 10,\n ) -> Tuple[list, list, float]:\n clean_pvalranges = self.calculate_pvalue_ranges(clean_x)\n adv_pvalranges = self.calculate_pvalue_ranges(adv_x)\n\n clean_scores = []\n adv_scores = []\n\n if clean_size is None and advs_size is None:\n # Individual scan\n with tqdm(\n len(clean_pvalranges) + len(adv_pvalranges), desc=\"Subset scanning\", disable=not self.verbose\n ) as pbar:\n for j, c_p in enumerate(clean_pvalranges):\n best_score, _, _, _ = Scanner.fgss_individ_for_nets(c_p)\n clean_scores.append(best_score)\n pbar.update(1)\n for j, a_p in enumerate(adv_pvalranges):\n best_score, _, _, _ = Scanner.fgss_individ_for_nets(a_p)\n adv_scores.append(best_score)\n pbar.update(1)\n\n else:\n len_adv_x = len(adv_x)\n len_clean_x = len(clean_x)\n\n for _ in trange(run, desc=\"Subset scanning\", disable=not self.verbose):\n np.random.seed()\n\n advchoice = np.random.choice(range(len_adv_x), advs_size, replace=False)\n cleanchoice = np.random.choice(range(len_clean_x), clean_size, replace=False)\n\n combined_pvals = np.concatenate((clean_pvalranges[cleanchoice], adv_pvalranges[advchoice]), axis=0)\n\n best_score, _, _, _ = Scanner.fgss_for_nets(clean_pvalranges[cleanchoice])\n clean_scores.append(best_score)\n best_score, _, _, _ = Scanner.fgss_for_nets(combined_pvals)\n adv_scores.append(best_score)\n\n y_true = np.append([np.ones(len(adv_scores))], [np.zeros(len(clean_scores))])\n all_scores = np.append([adv_scores], [clean_scores])\n\n fpr, tpr, _ = metrics.roc_curve(y_true, all_scores)\n roc_auc = metrics.auc(fpr, tpr)\n detectionpower = roc_auc\n\n return clean_scores, adv_scores, detectionpower","def index_subset(subset, numTestClasses=3, randomSeed=123):\n print(\"datasets.py is ingesting the DF dataset from data/DC.npz\")\n npzfile = np.load(\"data/DC.npz\", allow_pickle=True)\n data = npzfile[\"data\"]\n labels = npzfile[\"labels\"]\n npzfile.close()\n distinctLabelCount= len(set(labels))\n \n #print(\"data\", data.shape)\n #print(\"labels\", labels.shape)\n #print(\"distinctLabelCount\", distinctLabelCount)\n \n #random.seed(randomSeed)\n testClasses = random.sample(range(0,distinctLabelCount),numTestClasses)\n testClasses = [np.float64(i) for i in testClasses]\n \n \n mask = np.isin(labels,testClasses)\n\n X_test = data[np.where(mask)]\n X_train = data[np.where(~mask)]\n y_test = labels[np.where(mask)]\n y_train = labels[np.where(~mask)]\n \n if subset==\"background\":\n print(\"Current working directory is \", os.getcwd())\n X = X_train\n y = y_train\n print(\"DC background data shape\", X.shape)\n elif subset==\"evaluation\":\n X = X_test\n y = y_test\n print(\"DC evaluation data shape\", X.shape)\n images = []\n \n #print(\"y shape\", y.shape)\n \n \n for i in range(y.shape[0]):\n images.append({\n 'subset': subset,\n 'class_name': y[i],\n 'data': X[i].reshape(1,X[1].shape[0]) # This is the shape needed for Matching Networks\n #'data': X[i] #.reshape(X[1].shape[0]) # This is the shape needed for MAML\n })\n \n return images","def trainNet():","def eval(self, dataset, use_subset=False, subset_size=100, verbose=False,\r\n nms_thresh=0.45, nms_topk=400, post_nms=100):\r\n autograd.set_training(False)\r\n # NOTE: multi-gpu is a little bugged\r\n if 'cuda' in self.device:\r\n if mx.context.num_gpus() > 0:\r\n if self.device == 'cuda':\r\n ctx = [mx.gpu(0)]\r\n else:\r\n ctx = [mx.gpu(int(self.device.split(':')[1]))]\r\n else:\r\n ctx = [mx.cpu()]\r\n else:\r\n ctx = [mx.cpu()]\r\n print(self.device, ctx)\r\n\r\n with warnings.catch_warnings(record=True):\r\n warnings.simplefilter(\"always\")\r\n self._model.initialize()\r\n self._model.collect_params().reset_ctx(ctx)\r\n self._model.hybridize(static_alloc=True, static_shape=True)\r\n self._model.set_nms(nms_thresh=nms_thresh, nms_topk=nms_topk, post_nms=post_nms)\r\n\r\n dataset, eval_metric = self.__prepare_val_dataset(dataset, data_shape=self.img_size)\r\n\r\n eval_metric.reset()\r\n\r\n val_transform = presets.ssd.SSDDefaultValTransform(self.img_size, self.img_size)\r\n dataset = dataset.transform(val_transform)\r\n\r\n val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))\r\n if not use_subset:\r\n if verbose:\r\n print('Evaluation on entire dataset...')\r\n val_loader = gluon.data.DataLoader(\r\n dataset, self.batch_size, shuffle=False, batchify_fn=val_batchify_fn, last_batch='keep',\r\n num_workers=self.num_workers)\r\n else:\r\n print('Evaluation on subset of dataset...')\r\n val_loader = gluon.data.DataLoader(\r\n dataset, self.batch_size, sampler=gluon.data.RandomSampler(subset_size),\r\n batchify_fn=val_batchify_fn, last_batch='keep',\r\n num_workers=self.num_workers\r\n )\r\n\r\n for batch in tqdm(val_loader, total=len(val_loader)):\r\n data = gluon.utils.split_and_load(batch[0], ctx_list=ctx, batch_axis=0, even_split=False)\r\n label = gluon.utils.split_and_load(batch[1], ctx_list=ctx, batch_axis=0, even_split=False)\r\n det_bboxes = []\r\n det_ids = []\r\n det_scores = []\r\n gt_bboxes = []\r\n gt_ids = []\r\n gt_difficults = []\r\n for x, y in zip(data, label):\r\n # get prediction results\r\n ids, scores, bboxes = self._model(x)\r\n det_ids.append(ids)\r\n det_scores.append(scores)\r\n # clip to image size\r\n det_bboxes.append(bboxes.clip(0, batch[0].shape[2]))\r\n # split ground truths\r\n gt_ids.append(y.slice_axis(axis=-1, begin=4, end=5))\r\n gt_bboxes.append(y.slice_axis(axis=-1, begin=0, end=4))\r\n gt_difficults.append(y.slice_axis(axis=-1, begin=5, end=6) if y.shape[-1] > 5 else np.zeros(ids.shape))\r\n\r\n # update metric\r\n eval_metric.update(det_bboxes, det_ids, det_scores, gt_bboxes, gt_ids, gt_difficults)\r\n map_name, mean_ap = eval_metric.get()\r\n\r\n if verbose:\r\n val_msg = '\\n'.join(['{}={}'.format(k, v) for k, v in zip(map_name, mean_ap)])\r\n print(val_msg)\r\n eval_dict = {k.lower(): v for k, v in zip(map_name, mean_ap)}\r\n return eval_dict","def __call__(self, graph: Data, n_min: int, nodes_to_keep: List[int] = None, exhaustive: bool = False):\n nodes_to_keep = nodes_to_keep if nodes_to_keep is not None else []\n mcts = self._get_mcts(graph, n_min, nodes_to_keep, exhaustive)\n\n for iteration in range(self.m):\n mcts.search_one_iteration()\n\n explanation = mcts.best_leaf_node()\n\n return explanation.node_set, mcts","def fit(self):\n if self.minimizer == \"differential_evolution\":\n kwargs = {\"maxiter\": self._maxiter}\n elif self.minimizer == \"shgo\":\n kwargs = {\"options\": {\"maxiter\": self._maxiter,\n \"jac\": self.cost_func.jac_cost}}\n elif self.minimizer == \"dual_annealing\":\n kwargs = {\"maxiter\": self._maxiter, \"local_search_options\": {\n \"jac\": self.cost_func.jac_cost}}\n fun = self.cost_func.eval_cost\n bounds = self.value_ranges\n algorithm = getattr(optimize, self.minimizer)\n result = algorithm(fun, bounds, **kwargs)\n self._popt = result.x\n if result.success:\n self._status = 0\n elif \"Maximum number of iteration\" in result.message:\n self._status = 1\n else:\n self._status = 2","def sel_sus(fitness, size):\r\n # Sort fitness in descending order\r\n sorted_fitness, sorted_index = extra.sort_lists(fitness, list(range(len(fitness))), descending=True)\r\n # Total fitness\r\n total_fitness = sum(sorted_fitness)\r\n # Normalize fitness (i.e map fitness values to the interval [0, 1])\r\n sorted_fitness[:] /= total_fitness\r\n # Distance between the pointers to create\r\n distance = 1 / size\r\n # Initial pointer start\r\n start = random.uniform(0, distance)\r\n # Pointers\r\n pointers = [start + i * distance for i in range(size)]\r\n\r\n # Perform selection\r\n sel_individuals = []\r\n for pointer in pointers:\r\n i = 0\r\n tmp_sum = sorted_fitness[i]\r\n while tmp_sum < pointer:\r\n i += 1\r\n tmp_sum += sorted_fitness[i]\r\n sel_individuals.append(sorted_index[i])\r\n\r\n return sel_individuals","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE IF YOU WANT TO PRACTICE ***\"\n aStarSearch(problem)","def index_subset(subset, numTestClasses=100, randomSeed=123):\n print(\"datasets.py is ingesting the AWF dataset from data/AWF.npz\")\n npzfile = np.load(\"data/AWF.npz\", allow_pickle=True)\n data = npzfile[\"data\"]\n \n labels = npzfile[\"labels\"]\n \n print(\"The dataset shape is\", data.shape)\n print(\"The labels shape is\", labels.shape)\n npzfile.close()\n distinctLabelCount= len(set(labels))\n print(\"The total labels are\", distinctLabelCount)\n \n \n distinctLabels= set(labels)\n #random.seed(randomSeed)\n selectedClasses = random.choices(tuple(distinctLabels), k=numTestClasses)\n \n \n dfLabels = pd.DataFrame(labels)\n mask = dfLabels[0].isin(selectedClasses)\n \n X_test = data[np.where(mask)]\n X_train = data[np.where(~mask)]\n y_test = labels[np.where(mask)]\n y_train = labels[np.where(~mask)]\n \n if subset==\"background\":\n print(\"\\nCurrent working directory is \", os.getcwd())\n print(\"\\n\\n________________________________\")\n print(\"Assembling the training dataset\")\n print(\"________________________________\")\n X = X_train\n y = y_train\n print(\"\\n\\nAWF X_train data shape\", X.shape)\n print(\"AWF y_train data shape\", y.shape)\n \n elif subset==\"evaluation\":\n print(\"\\n\\n________________________________\")\n print(\"Assembling the test dataset\")\n print(\"________________________________\") \n print(\"\\nThe number of test classes is:\", len(selectedClasses))\n print(\"\\n\\nThe test classes are:\\n\\n\", selectedClasses)\n \n X = X_test\n y = y_test\n print(\"\\n\\nAWF X_test data shape\", X.shape)\n print(\"AWF y_test data shape\", y.shape)\n images = []\n \n #print(\"y shape\", y.shape)\n \n \n for i in range(y.shape[0]):\n images.append({\n 'subset': subset,\n 'class_name': y[i],\n 'data': X[i].reshape(1,X[1].shape[0]) # This is the shape needed for Matching Networks\n #'data': X[i] #.reshape(X[1].shape[0]) # This is the shape needed for MAML\n })\n \n return images","def filter_by_subset(self, *args):\n self.subset_labels = sorted(set(self.subset_labels + list(args)))\n return self","def index_subset(subset, numTestClasses=33, randomSeed=123):\n print(\"datasets.py is ingesting the DF dataset from data/DF.npz\")\n npzfile = np.load(\"data/DF.npz\", allow_pickle=True)\n data = npzfile[\"data\"]\n labels = npzfile[\"labels\"]\n npzfile.close()\n distinctLabelCount= len(set(labels))\n \n print(\"\\ndata\", data.shape)\n print(\"labels\", labels.shape)\n print(\"Total distinct class labels in the DF.npz dataset: \", distinctLabelCount)\n \n #random.seed(randomSeed)\n testClasses = random.sample(range(0,distinctLabelCount),numTestClasses)\n testClasses = [np.float64(i) for i in testClasses]\n \n \n mask = np.isin(labels,testClasses)\n\n X_test = data[np.where(mask)]\n X_train = data[np.where(~mask)]\n y_test = labels[np.where(mask)]\n y_train = labels[np.where(~mask)]\n \n if subset==\"background\":\n print(\"Current working directory is \", os.getcwd())\n X = X_train\n y = y_train\n print(\"DF background data shape\", X.shape)\n elif subset==\"evaluation\":\n X = X_test\n y = y_test\n print(\"DF evaluation data shape\", X.shape)\n images = []\n \n #print(\"y shape\", y.shape)\n \n \n for i in range(y.shape[0]):\n images.append({\n 'subset': subset,\n 'class_name': y[i],\n 'data': X[i].reshape(1,X[1].shape[0]) # This is the shape needed for Matching Networks\n #'data': X[i] #.reshape(X[1].shape[0]) # This is the shape needed for MAML\n })\n \n return images","def select(self):\n\t\tbest_num_components = self.n_constant\n\t\treturn self.base_model(best_num_components)","def select(self):\n\t\twarnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n\t\tscore_best = float(\"inf\")\n\t\tbest_model = None\n\t\tfor numStates in range(self.min_n_components, self.max_n_components + 1):\n\t\t\ttry:\n\t\t\t\tmodel = self.base_model(numStates)\n\t\t\t\tlog_l = model.score(self.X, self.lengths)\n\t\t\t\tp = numStates\n\t\t\t\tlog_n = np.log(len(self.lengths))\n\t\t\t\tscore = -2 * log_l + p * log_n\n\t\t\t\tif score < score_best:\n\t\t\t\t\tscore_best = score\n\t\t\t\t\tbest_model = model\n\t\t\texcept Exception as e:\n\t\t\t\tpass\n\n\t\twhile best_model is None:\n\t\t\tbest_model = self.base_model(np.random.randint(self.min_n_components, self.max_n_components + 1))\n\n\t\treturn best_model","def get_optimal_submesh_assignments(\n best_n_stages, F_argmin, n_devices, n_ops, submesh_sizes\n):\n current_s = best_n_stages\n current_layer = 0\n current_devices = n_devices\n\n optimal_layer_submesh_assignments = []\n while current_s > 0 and current_layer < n_ops and current_devices > 0:\n next_start_layer, submesh_shape_idx, sharding_config_idx = F_argmin[\n current_s, current_layer, current_devices\n ]\n assert next_start_layer != -1 and current_devices != -1\n optimal_layer_submesh_assignments.append(\n ((current_layer, next_start_layer), submesh_shape_idx, sharding_config_idx)\n )\n current_s -= 1\n current_layer = next_start_layer\n current_devices -= submesh_sizes[submesh_shape_idx]\n\n assert current_s == 0 and current_layer == n_ops and current_devices == 0\n\n return optimal_layer_submesh_assignments","def test_non_it(self):\n self.idx = [9, 11, 6, 10, 12, 2, 8, 1, 5, 0, 7, 4, 3]\n selector = PCovCUR(n_to_select=12, iterative=False)\n selector.fit(self.X, self.y)\n\n self.assertTrue(np.allclose(selector.selected_idx_, self.idx[:-1]))","def nn(data):\n training_set = SupervisedDataSet*\n\n\n input_nodes = 3\n hidden_layer_1 = 10\n hidden_layer_2 = 10\n output_layer = 5\n\n net = buildNetwork(input_nodes, hidden_layer_1, hidden_layer_2, output_layer, bias=True, hiddenclass=TanhLayer)","def selectFeatures(k_features=5, *args):\n X, y = args\n skb = SelectKBest(k=k_features)\n return skb.fit_transform(X, y)","def select_candidates(self, X, y, candidate_mask, train_mask):\n\n return self.best_heuristic(X=X, y=y, candidate_mask=candidate_mask,\n train_mask=train_mask, classifier=self.classifier,\n n_candidates=self.n_candidates, random_state=self.pool_rng.randint(1000),\n **self.h_kwargs)","def get_pool_subset(X_pool, Y_pool, subset_size=2000):\n subset_indices = np.asarray(random.sample(range(0,X_pool.shape[0]), subset_size))\n X_pool_subset = X_pool[subset_indices]\n Y_pool_subset = Y_pool[subset_indices]\n X_pool = np.delete(X_pool, subset_indices, axis=0)\n Y_pool = np.delete(Y_pool, subset_indices, axis=0)\n return (X_pool, Y_pool), (X_pool_subset, Y_pool_subset)","def select(self):\n warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n\n best_bic_score = float(\"inf\")\n best_model = self.base_model(self.n_constant)\n for n in range(self.min_n_components, self.max_n_components + 1):\n try:\n # bic = - 2*log(likelihood) + p*log(N)\n # N is number of data points\n # p => number of parameters\n # p = initial state occupation probabilities\n # + transition probabilities\n # + emission probabilities\n # initial state occupation probabilities, can be obtained from n,\n # as the probabilities add up to 1.0 => initial state occupation probabilities = n - 1\n # transition probabilities => n*(n - 1)\n # emission probabilities => n * num_features * 2 = num_means + num_covar\n # Hence, p = n - 1 + n*(n - 1) + 2* n * num_features\n # p = n*n + 2*n*num_features - 1\n\n model = self.base_model(n)\n log_likelihood = model.score(self.X, self.lengths)\n num_features = len(self.X[0])\n log_n = math.log(self.X.shape[0])\n\n p = n*n + 2*n*num_features - 1\n bic = -2 * log_likelihood + p * log_n\n if bic < best_bic_score:\n best_bic_score = bic\n best_model = model\n except:\n continue\n\n return best_model","def negSamplingCostAndGradient(predicted, target, outputVectors, dataset,\n K=10):\n\n # Sampling of indices is done for you. Do not modify this if you\n # wish to match the autograder and receive points!\n indices = [target]\n indices.extend(getNegativeSamples(target, dataset, K))\n\n ### YOUR CODE HERE\n # Similar to softmax, we find the target matrix\n # v_c structured as 1xD matrix\n # u_o assume to be 1xD matrix\n # u_k assume to be K x D matrix\n # we pull the data assuming that each row represent one vector\n v_c = predicted\n u_o = outputVectors[target]\n u_k = outputVectors[indices]\n\n\n # The intermediary matrix outputs\n # z_o, h_o: single scalar number\n # z_k, h_k: K x 1 vector, wich each number associated with a neg sample\n z_o = np.dot(u_o, v_c)\n h_o = sigmoid(z_o)\n z_k = np.dot(u_k, v_c)\n h_k = sigmoid( - z_k)\n\n J_1 = - np.log(h_o)\n J_2 = - np.sum( np.log(h_k) )\n cost = J_1+ J_2\n\n # Return the gradient for the prediction function\n # the prediction vector interacts with both the predicted vector\n # the negative sample vectors so below are both parts of the gradient\n # here we are trying to increase the prediction matrix to maximize\n # the similarity with the predicted vector\n # output is a 1 x D matrix\n grad_pred_o = - (1 - h_o)*u_o\n\n # the second part is tyring to decrease\n # similarity with the negative sample vectors\n # K x 1 multiply be input is a k x D matrix, we will need to sum all negative samples\n # along the rows. output is a 1 x D matrix\n # reshape h_k so that it can multiple\n grad_pred_k = np.dot(( 1 - h_k).T, u_k)\n # find the predicted matrix gradient\n # output is a 1 x D matrix\n gradPred = grad_pred_o + grad_pred_k\n\n\n # Return the gradient of the output vector\n # create a matrix the same shape as outputVector\n grad = np.zeros(outputVectors.shape)\n # first find the gradient wrt to the target output vector\n # here we want to increase the similarity between\n # the target output vector and the center vector\n # outputs is a 1 x D matrix\n grad_u_o = - (1-h_o)*v_c\n\n # print('***************grad_u_o************')\n # print(grad_u_o)\n # print(grad_u_o.shape)\n # replace the target row in output vector gradient\n grad[target, ] = grad_u_o\n # then find the gradient descent of all the u_k matrices\n # K x 1 matrix multiply by 1 x 3\n # K x D\n grad_uk = - np.outer((h_k - 1), v_c)\n # print('***************grad_uk************')\n # print(grad_uk)\n # for each token (row) replace gradient\n for k in xrange(u_k.shape[0]):\n index = indices[k]\n grad[index] += grad_uk[k]\n\n ### END YOUR CODE\n return cost, gradPred, grad","def selection(population: list, weights: list):\n\n new_population = list()\n\n for individual in population:\n new_population.append(individual[1])\n\n individuals = choices(new_population, weights=weights, k=2)\n\n return individuals[0], individuals[1]","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE ***\"\n util.raiseNotDefined()","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE ***\"\n util.raiseNotDefined()","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE ***\"\n util.raiseNotDefined()","def slice(self, evidence={}):\n return self.condition(evidence)\n \n \n\n# def eliminate(self, elimVars, elimOp):\n # TODO: awkward way to define this; convert to more direct implementation?\n for v in elimVars:\n if len(self.markovBlanket(v)) > 2: raise ValueError(\"Cannot eliminate {} with {} (>2) neighbors\".format(v,len(self.markovBlanket(v))))\n flist = self.factorsWith(v)\n gm_model = GraphModel(flist); print(gm_model); gm_model.eliminate([v],elimOp)\n fnew = gm_model.factors[0]\n self.removeFactors(flist); # doesn't quite work? numerical roundoff issues?\n self.L[v,:] = 0; self.L[:,v] = 0; self.h[v] = 0; # TODO: better to mark as removed? how?\n self.addFactors([fnew])\n # TODO: \"remove\" variable by setting states = 0? \"known value\" = 0?","def check_subset(P1,P2,k=-1):","def main():\n create_sets()\n optimal_weights = genetic_algorithm()\n obtain_best_model(optimal_weights)","def get_umap_subsets(self, nn=100, md=0.1, **kwargs):\n # First get umap results:\n results = Table.read(\"../data/dimred_results/apogee_rc_dimred_hyperparametertest.fits\")\n self.Xu = results[\"X_umap_euclidean_nn\"+str(nn) + \"_md\"+str(md)]\n self.Yu = results[\"Y_umap_euclidean_nn\"+str(nn) + \"_md\"+str(md)]\n \n # Now run HDBSCAN to define the subsets\n import hdbscan\n clusterer = hdbscan.HDBSCAN(**kwargs)\n clusterer.fit( np.vstack((self.Xu, self.Yu)).T )\n self.classcol = clusterer.labels_\n self.classprob= clusterer.probabilities_\n self.subsets = np.unique(clusterer.labels_)\n #self.classcol= np.char.rstrip(self.data[\"tsne_class_teffcut40\"],b' ')#.decode('utf8').strip()\n #self.subsets = [\"thin\", \"thick1\", \"thick2\", \"thick3\", \"thick4\",\n # \"mpthin\", \"mpthintrans\", \"smr\", \"t4trans\", \"youngthin\",\n # \"debris1\", \"debris2\", \"debris3\", \"debris4\", \"debris5\", \n # \"smr2\", \"t2trans1\", \"highTi\",\"lowMg\",\"highAlMg?\"]\n self.names = [\"\", \"\", \"\", \"\",\n \"\", \"\", \"Transition group\", \"\", \"\",\n \"Young local disc\", \"\", \"\", \"[s/Fe]-enhanced\", \"\", \"\", r\"\", \"Debris candidate\", \n r\"Extreme-Ti star\", r\"Low-[Mg/Fe] star\", \"High-[Al/Mg] star\"]\n self.Xcoords = [10, 11, 4.5, -12, 18, -31, 22, 26,-22.5, -14, -2, -25]\n self.Ycoords = [5.5,.5, -2, -4, 6, 0, 1.5, -.5, -7, -2, -6, 14]\n self.fsize = [20 , 16, 12, 12, 15, 13, 11, 11, 11, 11, 11, 11]\n self.sym = [\"o\", \"v\", \"^\", \">\", \"<\", \"s\", \"o\", \"*\", \"<\", \"o\",\n \"h\", \"d\", \"D\", \"v\", \"p\", \"*\", \"D\", \"p\", \"s\", \"8\"]\n self.al = [.6, .8, .8, .8, .8, .8, .8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\n self.lw = [0,.5,.5,.5, .5, .5, .5, .5, .5, .5, .5, .5, .5, .5, .5, .5, .5, .5, .5, .5, .5]\n self.size= [7,12,12,12,12,15,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18]\n self.col = [\"grey\", \"m\", \"hotpink\", \"crimson\", \"r\",\n \"g\", \"brown\", \"orange\", \"gold\", \"k\",\n \"yellow\", \n \"gold\", \"lime\", \"k\", \"royalblue\"]","def selection(self):\n\n for i in range(self.pop_num*3): # It is important. Next, we will rank the array of parents and children in ascending order of survivability (sum (fit)).\n self.par_and_sons[i].fit = SimpleSegmentationGA.fitness_function(self.gray, self.delta_x, self.length, self.par_and_sons[i].A)\n\n # Sort.\n self.par_and_sons = sorted(self.par_and_sons, key=lambda individ: individ.fit) \n self.population=self.par_and_sons[:self.pop_num].copy()","def get_selected_subsamples(sample_func, clusters, trajs_dict, visit_profile, Nsample, false_rate=80):\n print('The desired false rate is %f'%(false_rate/Nsample))\n crter = 0\n done_first_round = False\n nclusters = len(clusters)\n \n print('Start the first selection until the number of potential profiles is more than Nsample')\n while crter < Nsample:\n i = np.random.choice(range(nclusters))\n if len(clusters[i]) > Nsample*5 or len(clusters[i]) < Nsample: continue\n # try sampling\n selected_spl, plist_spl = sample_func(trajs_dict, plist=None, usrs=clusters[i])\n # do the deterministic attack\n a2 = get_trick_mat(clusters[i] , selected_spl, visit_profile)\n nonzero_list = [np.sum(np.count_nonzero(ai))>=1 for ai in make_sym_mat(a2)] \n crter = np.sum(nonzero_list)\n \n print('Finish the first round selection, %d candidates are selected from cluster %d'%(crter, i))\n round_one_usrs = np.array(clusters[i])[nonzero_list]\n \n crter2 = 0; len_rone = len(round_one_usrs)\n print('Start the second selection until false rate %f'%(false_rate/Nsample))\n while crter2 < false_rate:\n final_selected_usrs = round_one_usrs[np.random.choice(len_rone, Nsample, replace=False)]\n tmp = get_trick_mat(final_selected_usrs, selected_spl, visit_profile)\n crter2 = np.sum([np.sum(np.count_nonzero(ai))>=1 for ai in make_sym_mat(tmp)])\n print('Final false rate for deterministic attack%f'%(crter2/Nsample))\n return selected_spl, final_selected_usrs, plist_spl","def cost(self, output, labels, weights):\n raise NotImplementedError('Must be overridden by concrete subclass')","def reduced_cost(data, indexing, cf, cf_prime, v, k, uw_sample_count=None):\n # copy indexing and move v to k\n cpy = indexing.copy()\n cpy[v] = k\n vs = np.arange(data.shape[0])\n points = None\n if uw_sample_count is None:\n # compute all possible 3-ary subsets that contain v\n points = np.array(np.meshgrid(v,vs,vs)).T.reshape(-1,3)\n points = points[ (points[:,0] != points[:,1]) & \n (points[:,0] != points[:,2]) & \n (points[:,1] < points[:,2]) ]\n else:\n # sample 3-ary subsets that contain v\n pointsv = np.ones((uw_sample_count,1), dtype=np.int)*v\n allowed = np.arange(indexing.shape[0])[np.arange(indexing.shape[0]) != v]\n pointsuw = sample_noreplace(allowed, uw_sample_count, 2)\n points = np.concatenate((pointsv, pointsuw), axis=1)\n # the result is the difference between the original indexing\n # and the indexing after the move-operation\n result = (partial_cost(data, indexing, points, cf, cf_prime) -\n partial_cost(data, cpy, points, cf, cf_prime))\n return result","def nonlocality_test(self, \n source: str = 'meas', \n rows: Optional[Sequence[int]] = None, \n nosignaling: bool = False,\n min_size: Optional[Union[int, Sequence[int]]] = None, \n max_size: Optional[int] = None, \n step: Optional[int] = None, \n progressbar: bool = False):\n \n (rows, min_size, max_size, step, subset) = self.__handle_args(\n source=source, rows=rows, nosignaling=nosignaling, \n min_size=min_size, max_size=max_size, step=step)\n \n self.new_LP('feasibility') \n \n subset_size = len(subset)\n if subset_size > 0: \n for row in subset: \n rows.remove(row) \n self.populate_LP('feasibility', source, subset)\n \n if progressbar: \n pbar = tqdm(initial=0, total=max_size) \n for size in itertools.chain(range(min_size, max_size, step), [max_size]):\n \n new_rows = []\n \n if not nosignaling:\n for new in range(size - subset_size):\n new_rows.append(rows.pop(np.random.randint(len(rows)))) \n else:\n while len(new_rows) < size - subset_size and rows:\n new = rows.pop(np.random.randint(len(rows)))\n if self.get_nonredundant(new): new_rows.append(new)\n \n if new_rows:\n subset_size += len(new_rows)\n self.populate_LP('feasibility', source, new_rows)\n\n self.LP.solve() \n\n status = self.LP.solution.get_status_string()\n NL = True if status=='infeasible' else (\n False if status=='optimal' else status)\n \n if progressbar:\n pbar.update(subset_size - pbar.n)\n pbar.set_description_str(desc=str(NL), refresh=True)\n if NL or not rows: \n break\n\n return NL","def get_obj_new(model_old, demand_path, slink_dict, demand_dict, w_a, w_b, theta, s_limit):\n model = copy.deepcopy(model_old)\n \n #cpu_vector = model.cost_dict['cpu']\n dist_matrix = model.cost_dict['dist']\n rtt_matrix = model.cost_dict['rtt']\n #bw_matrix = model.cost_dict['bw']\n w_a1, w_a2 = w_a\n w_b1, w_b2 = w_b\n theta1, theta2, theta3 = theta\n # find total capacity and used bw on substrate nodes\n node_port_list, used_bw_list = total_port(model)\n #print \"CHECK POINT-1\", used_bw_list, node_port_list\n vnet_info = model.get_vnet_info()\n infeasible = 0\n\n fail_nodes = model.failed_dict\n start_time = time.time()\n select_dict, slink_dict = find_standby2(model, s_limit, w_a, w_b, theta, demand_path, demand_dict, slink_dict)\n # random selection\n #select_dict, slink_dict = find_random(model, s_limit, w_a, w_b, theta, demand_path, demand_dict, slink_dict)\n #print \"selection takes: \", time.time() - start_time\n #print \"Selected\", select_dict\n sum_cost_1_2 = 0\n r_list = {}\n \n for node_id in range(0,len(used_bw_list)):\n r_list[node_id] = used_bw_list[node_id]/node_port_list[node_id]\n #print \"INITIAL\", r_list\n svr_subset = {}\n for vnet in model.vnets:\n j = vnet.vnet_id\n f = fail_nodes[j]\n # only count the failed virtual network\n if f == -1:\n pass\n else:\n for node_id in vnet_info[j]['standby']:\n svr_subset[node_id] = r_list[node_id]\n #print \"Subset SVR: \", svr_subset\n \n if j in select_dict:\n #print \"FEASIBLE FOUND\"\n #print vnet_info[j]['standby']\n i = select_dict[j]\n failed_node = vnet.vnodes[f]\n vneighbors = failed_node.vneighbors\n for k in vneighbors: \n eta = operation_cost()\n #print \"a1: \", w_a1, \"a2: \", w_a2, \"b1: \", w_b1, \"b2: \", w_b2\n dist_c = dist_cost(i, f, k, dist_matrix, w_a1, w_a2)\n rtt_c = rtt_cost(i, k, rtt_matrix)\n sigma = connect_cost(dist_c, rtt_c, w_b1, w_b2)\n sum_cost_1_2 += theta1 * eta + theta2 * sigma\n #find residual bw on substrate node\n #xi = resource_cost(bw_matrix, i)\n req_bw = sum(failed_node.neighbor_traffic.values())\n #util = req_bw / xi\n #print req_bw, i, used_bw_list[i], node_port_list[i]\n util = req_bw/node_port_list[i]\n \n if i not in r_list:\n r_list[i] = util #+ used_bw_list[i]/node_port_list[i]\n else:\n r_list[i] += util\n svr_subset[i] = r_list[i]\n #print sigma, \" v_\" + str(vnet.vnet_id) + \"_\" + str(f) + \"_\" + str(i) + \"_\" + str(k) + \"_\" + str(k)\n else:\n print \"INFEASIBLE at vnet: \", j\n infeasible = 1\n #print \"DONE\"\n \n if infeasible == 0:\n #print svr_subset\n max_util = max(svr_subset.values())\n obj = sum_cost_1_2 + theta3 * max_util\n else:\n obj = \"infeasible\"\n max_util = \"none\"\n #print obj\n used_time = time.time() - start_time\n return obj, select_dict, max_util, used_time","def evaluation(x_selected, y, state_of_art=False):\n # check_number_of_clusters(X_selected)\n # n_clusters = best_number_of_clusters\n\n y_true = np.asarray(y)\n\n if state_of_art:\n avg_sil, model = get_results(x_selected, [max(y_true)])\n else:\n avg_sil, model = get_results(x_selected)\n\n # using GPU\n #avg_sil, model = get_results_from_GPU(x_selected)\n\n \"\"\" VALID DISTANCES METRICS\n 'euclidean', 'l2', 'l1', 'manhattan', 'cityblock',\n 'braycurtis', 'canberra', 'chebyshev', 'correlation',\n 'cosine', 'dice', 'hamming', 'jaccard', 'kulsinski',\n 'mahalanobis', 'matching', 'minkowski', 'rogerstanimoto',\n 'russellrao', 'seuclidean', 'sokalmichener',\n 'sokalsneath', 'sqeuclidean', 'yule', \"wminkowski\"\n \n max([\n metrics.silhouette_score(x_selected, model.labels_, metric='euclidean'),\n metrics.silhouette_score(x_selected, model.labels_, metric='cosine'),\n\n metrics.silhouette_score(x_selected, model.labels_, metric='manhattan'),\n metrics.silhouette_score(x_selected, model.labels_, metric='braycurtis'),\n metrics.silhouette_score(x_selected, model.labels_, metric='canberra'),\n metrics.silhouette_score(x_selected, model.labels_, metric='chebyshev'),\n metrics.silhouette_score(x_selected, model.labels_, metric='hamming'),\n metrics.silhouette_score(x_selected, model.labels_, metric='jaccard'),\n\n metrics.silhouette_score(x_selected, model.labels_, metric='russellrao'),\n metrics.silhouette_score(x_selected, model.labels_, metric='sokalsneath'),\n metrics.silhouette_score(x_selected, model.labels_, metric='yule'),\n\n metrics.silhouette_score(x_selected, model.labels_, metric='kulsinski'),\n metrics.silhouette_score(x_selected, model.labels_, metric='cityblock')\n ])\"\"\"\n\n y_predict = model.labels_\n\n for i in range(0, len(y_predict)):\n y_predict[i] = y_predict[i] + 1\n\n # inercia = k_means.inertia_\n inertia = model.inertia_\n\n # calculate NMI\n nmi = v_measure_score(y_true, y_predict)\n # nmi = 0\n\n # calculate corrected rand\n corrected_rand = adjusted_rand_score(y_true, y_predict)\n # corrected_rand = 0\n\n # calculate f-measure\n f_measure = f1_score(y_true, y_predict, average='micro')\n\n # calculate ACC\n\n label1 = np.unique(y_true)\n label2 = np.unique(y_predict)\n if len(label1) == len(label2):\n y_permuted_predict = best_map(y_true, y_predict)\n acc = accuracy_score(y_true, y_permuted_predict)\n else:\n acc = 0\n\n logger.log(\"KMeans model has\"\n \" avg_sil = \" + str(avg_sil) +\n \" and NMI = \" + str(nmi) +\n \" and CR = \" + str(corrected_rand) +\n \" and f-measure = \" + str(f_measure), True)\n\n # calculate cluster.stats\n # dgene = stats.dist(x_selected, method='euclidean')\n\n \"\"\" fpc_result = fpc.cluster_stats(dgene,\n model.labels_,\n G2=False,\n G3=False,\n silhouette=True,\n sepwithnoise=True,\n noisecluster=True,\n wgap=True)\n\n stats_fpc = pandas2ri.ri2py(fpc_result)\"\"\"\n\n # Compute Hopkins statistic for iris dataset\n # nrow = X_selected.shape[0]\n # res = factoextra.get_clust_tendency(X_selected, n=nrow - 1, graph=False)\n # print(\"hopkins test: \"+ str(res[0]))\n # hopkins_test = res\n\n # dunn = stats_fpc[24][0]\n # dunn2 = stats_fpc[25][0]\n # entropy = stats_fpc[26][0]\n # ch = stats_fpc[28][0]\n\n dunn = 0\n dunn2 = 0\n entropy = 0\n ch = 0\n\n # inertia, avg_sil, dunn, dunn2, entropy, ch, nmi, acc, corrected_rand, f_measure\n return ClusteringResults(max(y_predict), inertia, avg_sil, dunn, dunn2, entropy, ch, nmi, acc, corrected_rand, f_measure)","def test_subset_classification(p_df_subset, p_weather):\n X = p_df_subset.drop(\"Direction\", axis=1)\n y = p_df_subset[\"Direction\"]\n print(\"Scale Data...\")\n scaler = StandardScaler()\n X_scaled_train = scaler.fit_transform(X)\n print(\"Do PCA...\")\n pca = PCA(n_components=15)\n pca.fit(X_scaled_train)\n X_train_transformed = pca.transform(X_scaled_train)\n # Read Models\n dummy = io.read_object(\"Dummy_classifier_model\"+p_weather+\".pkl\")\n clf = io.read_object(\"KNearestNeighbours_classifier_model\"+p_weather+\".pkl\")\n # Predict\n print(\"Predict...\")\n dummy_y_prediction = dummy.predict(X_train_transformed)\n kn_y_prediction = clf.predict(X_train_transformed)\n # Evaluate Predict\n prediction.evaluate.direction_error_metrics(y, dummy_y_prediction, \"Dummy_Classifier\"+p_weather, \"Testing\")\n prediction.evaluate.direction_error_metrics(y, kn_y_prediction, \"KNeighbors_Classifier\"+p_weather, \"Testing\")","def subset_number_to_subset(\n set_size: int,\n subset_size: int,\n subset_number: int,\n order_matters: bool = False,\n can_reselect: bool = False\n) -> List[int]:\n # Sets can't have negative size\n if set_size < 0:\n raise ArithmeticError(f\"Can't have a set of {set_size} items\")\n if subset_size < 0:\n raise ArithmeticError(f\"Can't have a subset of {subset_size} items\")\n\n # Start with the empty set\n subset = []\n\n # The empty set is the only possible subset of size 0, so return it\n if subset_size == 0:\n # Subset number should be 0 for a subset size of 0\n if subset_number != 0:\n raise ArithmeticError(\n f\"0 is the only valid subset number for subsets of size 0, got {subset_number}\"\n )\n\n return subset\n\n # If there are no items to select from, the empty set is the only possible selection,\n # so any subsets of greater size are impossible\n if set_size == 0:\n raise ArithmeticError(\n f\"Can't select a non-empty subset (subset size = {subset_size}) from the empty set\"\n )\n\n # Special case for order-dependent\n if order_matters:\n # Ordered with reselection is shift-encoded, so simply shift-decode\n if can_reselect:\n while len(subset) < subset_size:\n subset.append(subset_number % set_size)\n subset_number //= set_size\n\n # Without reselection, the items available for selection reduces by 1 at each iteration\n else:\n factor = set_size - subset_size + 1\n while len(subset) < subset_size:\n next = subset_number % factor\n subset_number //= factor\n for index in range(len(subset)):\n if subset[index] >= next:\n subset[index] += 1\n subset.insert(0, next)\n factor += 1\n\n return subset\n\n # If reselect is allowed, we are expecting the equivalent binomial representation of the selection\n if can_reselect:\n set_size += subset_size - 1\n subset_size = set_size - subset_size\n\n # Decode the arithmetic encoding of the binomial representation\n num_subsets = number_of_subsets(set_size - 1, subset_size)\n k = subset_size\n for n in reversed(range(set_size)):\n if subset_number >= num_subsets:\n subset_number -= num_subsets\n subset.append(n)\n if len(subset) == subset_size:\n break\n num_subsets = num_subsets * k // n\n k -= 1\n elif n != 0:\n num_subsets = num_subsets * (n - k) // n\n\n # Convert the binomial representation back to the original multinomial one if reselection was enabled\n if can_reselect:\n subset.sort()\n subset_size = set_size - subset_size\n set_size -= subset_size - 1\n counts = {}\n total = 0\n for i in range(set_size - 1):\n last = -1 if i == 0 else subset[i - 1]\n count = subset[i] - last - 1\n total += count\n if count != 0:\n counts[i] = count\n if total < subset_size:\n counts[set_size - 1] = subset_size - total\n subset = []\n for value, count in counts.items():\n for i in range(count):\n subset.append(value)\n\n return subset","def select_fits_subset(self, pre_processing=None, binning=None,\n exposure=(None, 'max'), reduction=None,\n observatory=None, jd=(None, 'exact')):\n self.data_subset = self.all_data.copy()\n\n # Select on pre-processing if provided.\n if pre_processing:\n self.data_subset = self.data_subset.loc[\n self.data_subset['PreProcessing'] == pre_processing]\n\n # Select on binning if provided.\n if binning:\n self.data_subset = self.data_subset.loc[\n self.data_subset['Binning'] == binning]\n\n # Select on exposure if provided.\n if exposure[0]:\n if exposure[1] == 'exact':\n self.data_subset = self.data_subset.loc[\n self.data_subset['Exposure'] == exposure[0]]\n elif exposure[1] == 'min':\n self.data_subset = self.data_subset.loc[\n self.data_subset['Exposure'] > exposure[0]]\n elif exposure[1] == 'max':\n self.data_subset = self.data_subset.loc[\n self.data_subset['Exposure'] < exposure[0]]\n elif exposure[1] == 'between':\n self.data_subset = self.data_subset.loc[\n (self.data_subset['Exposure'] > exposure[0][0]) &\n (self.data_subset['Exposure'] < exposure[0][1])]\n\n # Select on reduction if provided.\n if reduction:\n self.data_subset = self.data_subset.loc[\n self.data_subset['Reduction'] == reduction]\n\n # Select on observatory if provided.\n if observatory:\n self.data_subset = self.data_subset.loc[\n self.data_subset['Observatory'] == observatory]\n\n # Select on jd if provided.\n if jd[0]:\n if jd[1] == 'exact':\n if isinstance(jd[0], list):\n self.data_subset = self.data_subset.loc[\n self.data_subset['JD'].isin(jd[0])]\n else:\n self.data_subset = self.data_subset.loc[\n self.data_subset['JD'] == jd[0]]\n elif jd[1] == 'except':\n if isinstance(jd[0], list):\n self.data_subset = self.data_subset.drop(\n self.data_subset[self.data_subset[\n 'JD'].isin(jd[0])].index)\n else:\n self.data_subset = self.data_subset.drop(\n self.data_subset[self.data_subset['JD']\n == jd[0]].index)\n elif jd[1] == 'after':\n self.data_subset = self.data_subset.loc[\n self.data_subset['JD'] > jd[0]]\n elif jd[1] == 'before':\n self.data_subset = self.data_subset.loc[\n self.data_subset['JD'] < jd[0]]\n elif jd[1] == 'between':\n self.data_subset = self.data_subset.loc[\n (self.data_subset['JD'] > jd[0][0]) &\n (self.data_subset['JD'] < jd[0][1])]\n\n # Sort by JD and reset index.\n self.data_subset = self.data_subset.sort_values(\n by=['JD'], ascending=True).reset_index(drop=True)\n\n # Check spectra found:\n if len(self.data_subset) == 0:\n raise FileExistsError(\n 'No spectra found for that location or subset.')\n\n print('Selecting {} spectra from fits dataset.'.format(\n len(self.data_subset)))","def score(label_dict, target, selection, n=50):\n\n # Remove the queried element\n selection = list(set(selection) - {target})\n\n # Fetch labels for queried image\n if target in label_dict.keys():\n target_dict = dict(label_dict[target])\n else:\n logging.error('Could not find %s in the dict keys' % target)\n\n target_dict = {}\n\n # Current score will accumulate the element-wise scores, before rescaling by scaling by 2/(k*n)\n current_score = 0.0\n\n # Calculate best possible score of image\n best_score = sum(target_dict.values())\n\n # Avoid problems with div zero. If best_score is 0.0 we will\n # get 0.0 anyway, then best_score makes no difference\n if best_score == 0.0:\n best_score = 1.0\n\n # Loop through all the selected elements\n for selected_element in selection:\n # If we have added a non-existing image we will not get\n # anything, and create a dict with no elements\n # Otherwise select the current labels\n if selected_element in label_dict.keys():\n selected_dict = dict(label_dict[selected_element])\n else:\n logging.error('Could not find %s in the dict keys' % selected_element)\n\n selected_dict = {}\n\n # Extract the shared elements\n common_elements = list(set(selected_dict.keys()) & set(target_dict.keys()))\n\n if len(common_elements) > 0:\n # for each shared element, the potential score is the\n # level of certainty in the element for each of the\n # images, multiplied together\n element_scores = [\n selected_dict[element] * target_dict[element] for element in common_elements\n ]\n\n # We sum the contributions, and that's it\n current_score += sum(element_scores) / best_score\n else:\n # If there are no shared elements,\n # we won't add anything\n pass\n\n # We are done after scaling\n return current_score * 2 / (len(selection) + n)","def negSamplingCostAndGradient(predicted, target, outputVectors, dataset, K=10):\n\t#sampling of indices\n\tindices = [target]\n\tindices.extend(getNegativeSamples(target, dataset, K))\n\n\tgrad = np.zeros(outputVectors.shape)\n\tgradPred = np.zeros(predicted.shape)\n\tcost = 0\n\t#a true pair\n\tz = sigmoid(np.dot(outputVectors[target], predicted))\n\n\tcost -= np.log(z)\n\tgrad[target] += predicted*(z-1.0)\n\tgradPred += outputVectors[target]*(z-1.0)\n\n\tfor k in range(K):\n\t\tsamp = indices[k+1]\n\t\tz = sigmoid(np.dot(outputVectors[samp], predicted))\t#real number\n\t\tcost -= np.log(1.0 - z)\n\t\tgrad[samp] += predicted*z \n\t\tgradPred += outputVectors[samp]*z \n\n\treturn cost, gradPred, grad","def regular_subsample(neuron):\n # select all the main points\n selected_index = get_main_points(neuorn)\n\n # Computing the parent id of the selected nodes\n neuron = neuron_with_selected_nodes(selected_index)\n return neuron","def random_sampling(self, n_subset):\n t = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n print(\"[INFO] {} - Random sampling with replacement ...\".format(t))\n subset_list = []\n training_set = self\n subset_size = math.ceil(training_set.n_samples / n_subset)\n # create subsets\n for i in range(n_subset):\n # run a permutation to mix all samples (sampling with replacement)\n self.permutation()\n # always draw the first samples\n start_idx = 0\n stop_idx = subset_size\n subset = deepcopy(training_set)\n subset.data = subset.data[start_idx:stop_idx][:]\n subset.labels = subset.labels[start_idx:stop_idx][:]\n subset.labels_onehot = subset.labels_onehot[start_idx:stop_idx][:]\n subset.n_samples = stop_idx - start_idx\n subset.true_distribution = subset._get_true_distribution()\n subset.set_batch_size(training_set.batch_size)\n subset_list.append(subset)\n print(\"\\tSubset shape {}\".format(subset.data.shape))\n return subset_list","def tournament_selection(\n fitness: List[float], n: int, size: Optional[int] = 2\n) -> np.array:\n\n selected = []\n for _ in range(n):\n step = [np.random.choice(fitness) for _ in range(size)]\n selected.append(np.where(min(step) == fitness)[0][0])\n\n return selected","def _mate_pool_select(self,pop,mp_size,fitness_rank):\n mp,_=self._tournament_select(pop,mp_size,fitness_rank,cap=2)\n\n return mp","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def select(self):\n best_num_components = self.n_constant\n return self.base_model(best_num_components)","def _prefit(self,costfunc,sample):\n # Here we obtain 10 initial candidates to best fitting\n #opt=100.\n if self.long_fitting[sample]:\n l1=np.linspace(-20,0,16)\n l2=np.linspace(-10,-0.3,16)\n l3=np.linspace(-0.5,0.5,16)\n l4=np.linspace(-0.015,0.015,16)\n else:\n l1=np.linspace(-20,0,5)\n l2=np.linspace(-10,-0.3,5)\n l3=np.linspace(-0.5,0.5,5)\n l4=np.linspace(-0.015,0.015,5)\n l1,l2,l3,l4=np.meshgrid(l1,l2,l3,l4)\n l1,l2,l3,l4=l1.ravel(),l2.ravel(),l3.ravel(),l4.ravel()\n #self._message(\"(%s) Prefitting data (grid search) - %d tests.\"%(sample,l1.size))\n costs=np.ones_like(l1)\n #optpar=np.array((l1[8],l2[8],l3[8],l4[8]))\n for j in range(l1.size):\n ll=np.array((l1[j],l2[j],l3[j],l4[j]))\n costs[j]=costfunc(ll)\n idx=np.argsort(costs)\n opt=costs[idx]\n optpars=np.column_stack((l1[idx],l2[idx],l3[idx],l4[idx]))\n #self._message(str(optpars.shape))\n #self._message(\"(%s) Prefitting done. Error achieved after prefitting: %s.\"%(sample,str(opt)))\n #self._message(\"(%s) Prefitting done. Error achieved after prefitting: %g.\"%(sample,opt[0]))\n if opt[0]>=1:\n self._message(\"Warning: (%s) Prefitting did not find a good initial condition (%g).\"%(sample,opt[0]))\n return optpars,opt","def query(self, X_train, Y_train, labeled_idx, amount):\n return NotImplemented","def prepare_evaluation(self):\n # this is called after the optimizer has discretized the graph\n cells = [self.edges[2, 3].op, self.edges[4, 5].op, self.edges[6, 7].op]\n\n self._expand()\n\n channels = [64, 128, 256]\n factor = 4\n\n for cell, c in zip(cells, channels):\n for _, _, data in cell.edges.data():\n data.op.update_nodes(\n lambda node, in_edges, out_edges: _set_comb_op_channels(\n node, in_edges, out_edges, c=c\n ),\n single_instances=False,\n )\n\n self.edges[1, 2].set(\"op\", ops.Stem(channels[0]))\n self.edges[2, 3].set(\"op\", cells[0].copy())\n self.edges[3, 4].set(\n \"op\",\n ops.SepConv(channels[0], channels[0], kernel_size=3, stride=1, padding=1),\n )\n self.edges[4, 5].set(\"op\", cells[0].copy())\n self.edges[5, 6].set(\n \"op\",\n ops.SepConv(channels[0], channels[1], kernel_size=3, stride=2, padding=1),\n )\n self.edges[6, 7].set(\"op\", cells[1].copy())\n self.edges[7, 8].set(\n \"op\",\n ops.SepConv(channels[1], channels[1], kernel_size=3, stride=1, padding=1),\n )\n self.edges[8, 9].set(\"op\", cells[1].copy())\n self.edges[9, 10].set(\n \"op\",\n ops.SepConv(channels[1], channels[2], kernel_size=3, stride=2, padding=1),\n )\n self.edges[10, 11].set(\"op\", cells[2].copy())\n self.edges[11, 12].set(\n \"op\",\n ops.SepConv(channels[2], channels[2], kernel_size=3, stride=1, padding=1),\n )\n self.edges[12, 13].set(\"op\", cells[2].copy())\n self.edges[13, 14].set(\n \"op\",\n ops.Sequential(\n ops.SepConv(\n channels[-1], channels[-1], kernel_size=3, stride=1, padding=1\n ),\n nn.AdaptiveAvgPool2d(1),\n nn.Flatten(),\n nn.Linear(channels[-1], 10),\n ),\n )\n\n self.update_edges(\n update_func=lambda edge: _increase_channels(edge, factor),\n scope=self.OPTIMIZER_SCOPE,\n private_edge_data=True,\n )","def sim_average_cost(self, dictionary):\n\t\tif toggles.DEBUG_FLAG:\n\t\t\tprint \"Running: sim_average_cost\"\n\t\tf = open(toggles.OUTPUT_PATH + toggles.RUN_NAME + '_estimated_costs.csv', 'a')\n\n\t\tfor p in toggles.CHOSEN_PREDS:\n\t\t\tpred_cost = 0.0\n\t\t\tpred = Predicate.objects.all().get(pk=p+1)\n\t\t\tf.write(pred.question.question_text + '\\n')\n\n\t\t\t#iterate through to find each ip cost\n\t\t\tfor ip in IP_Pair.objects.filter(predicate=pred):\n\t\t\t\titem_cost = 0.0\n\t\t\t\t# sample toggles.COST_SAMPLES times\n\t\t\t\tfor x in range(toggles.COST_SAMPLES):\n\t\t\t\t\t# running one sampling\n\t\t\t\t\twhile ip.status_votes < toggles.NUM_CERTAIN_VOTES:\n\t\t\t\t\t\t# get the vote\n\t\t\t\t\t\tvalue = choice(dictionary[ip])\n\t\t\t\t\t\tif value == True:\n\t\t\t\t\t\t\tip.value += 1\n\t\t\t\t\t\t\tip.num_yes += 1\n\t\t\t\t\t\telif value == False:\n\t\t\t\t\t\t\tip.value -= 1\n\t\t\t\t\t\t\tip.num_no +=1\n\n\t\t\t\t\t\tip.status_votes += 1\n\n\t\t\t\t\t\t# check if ip is done\n\t\t\t\t\t\tif ip.status_votes == toggles.NUM_CERTAIN_VOTES:\n\t\t\t\t\t\t\t\tif ip.value > 0:\n\t\t\t\t\t\t\t\t\tuncertaintyLevel = btdtr(ip.num_yes+1, ip.num_no+1, toggles.DECISION_THRESHOLD)\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tuncertaintyLevel = btdtr(ip.num_no+1, ip.num_yes+1, toggles.DECISION_THRESHOLD)\n\t\t\t\t\t\t\t\tif uncertaintyLevel < toggles.UNCERTAINTY_THRESHOLD:\n\t\t\t\t\t\t\t\t\titem_cost += (ip.num_yes + ip.num_no)\n\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\tip.status_votes -= 2\n\n\t\t\t\t\t# reset values\n\t\t\t\t\tip.value = 0\n\t\t\t\t\tip.num_yes = 0\n\t\t\t\t\tip.num_no = 0\n\t\t\t\t\tip.status_votes = 0\n\n\t\t\t\titem_cost = item_cost/float(toggles.COST_SAMPLES)\n\t\t\t\tpred_cost += item_cost\n\t\t\t\tf.write(ip.item.name + ': ' + str(item_cost) + \" \")\n\n\t\t\tpred_cost = float(pred_cost)/IP_Pair.objects.filter(predicate=pred).count()\n\t\t\tf.write('\\npredicate average cost: ' + str(pred_cost) + '\\n \\n')\n\t\tf.close()\n\t\tif toggles.DEBUG_FLAG:\n\t\t\tprint \"Wrote File: \" + toggles.OUTPUT_PATH + toggles.RUN_NAME + '_estimated_costs.csv'","def _select_sublist(lst, target):\n ln = len(lst)\n\n # Generate an array that indicates the decision bit for each element in the list.\n # If an element is deterministically true, then no decision bit is needed.\n choice_bits = [None] * ln\n x = 0\n for i in range(0, ln):\n if lst[i][1] not in (target.TRUE, target.FALSE):\n choice_bits[i] = x\n x += 1\n\n # We have 2^x distinct lists. Each can be represented as a number between 0 and 2^x-1=n.\n n = (1 << x) - 1\n\n while n >= 0:\n # Generate the list of positive values and node identifiers\n # noinspection PyTypeChecker\n sublist = [lst[i] for i in range(0, ln)\n if (choice_bits[i] is None and lst[i][1] == target.TRUE) or\n (choice_bits[i] is not None and n & 1 << choice_bits[i])]\n # Generate the list of negative node identifiers\n # noinspection PyTypeChecker\n sublist_no = tuple([target.negate(lst[i][1]) for i in range(0, ln)\n if (choice_bits[i] is None and lst[i][1] == target.FALSE) or (\n choice_bits[i] is not None and not n & 1 << choice_bits[i])])\n if sublist:\n terms, nodes = zip(*sublist)\n else:\n # Empty list.\n terms, nodes = (), ()\n yield terms, nodes + sublist_no + (0,)\n n -= 1","def __init__(self, cost_func):\n super().__init__(cost_func)\n\n self.support_for_bounds = True\n self._popt = None\n self._status = None\n self._maxiter = None","def __init__(self, cost_func):\n super(MinuitController, self).__init__(cost_func)\n self._popt = None\n self._initial_step = None\n self._minuit_problem = None\n self.algorithm_check = {\n 'all': ['minuit'],\n 'ls': [None],\n 'deriv_free': [None],\n 'general': ['minuit']}","def _reduce(self, x, y):\n ind = self.ind_\n n_samples, n_features = x.shape\n n_features_selected = sum(ind)\n\n for _ in range(self.iters, self.max_iter):\n if np.count_nonzero(ind) == 0:\n warnings.warn(\n \"Sparsity parameter is too big ({}) and eliminated all coeficients\".format(self.threshold)\n )\n coef = np.zeros_like(ind, dtype=float)\n break\n\n coef = self._regress(x[:, ind], y, self.alpha)\n coef, ind = self._sparse_coefficients(n_features, ind, coef, self.threshold)\n\n if sum(ind) == n_features_selected or self._no_change():\n # could not (further) select important features\n break\n else:\n warnings.warn(\n \"STRidge._reduce did not converge after {} iterations.\".format(self.max_iter),\n ConvergenceWarning,\n )\n try:\n coef\n except NameError:\n coef = self.coef_\n warnings.warn(\"STRidge._reduce has no iterations left to determine coef\", ConvergenceWarning)\n self.coef_ = coef\n self.ind_ = ind","def selection(self):\n\n # sort the generation according to fitness.\n self.sortByFitness()\n # get the fitness sum.\n fitnessSum = 0\n for outfit in self.currentGeneration:\n fitnessSum += self.applyFitness(outfit)\n # generate a random number\n stop = random.uniform(0, 1)\n accumulated = 0\n offset = 0\n for outfit in self.currentGenerationSorted:\n fitness = self.applyFitness(outfit) + offset\n probability = fitness / fitnessSum\n accumulated += probability\n\n if stop <= accumulated:\n return outfit","def optimize(opt):\n # load new target\n if opt.is_poly:\n target_mesh = om.read_polymesh(opt.model)\n else:\n target_mesh = om.read_trimesh(opt.model)\n target_shape_arr = target_mesh.points()\n target_shape = target_shape_arr.copy()\n target_shape = torch.from_numpy(\n target_shape[:, :3].astype(np.float32)).cuda()\n target_shape.unsqueeze_(0)\n\n target_faces_arr = target_mesh.face_vertex_indices()\n target_faces = target_faces_arr.copy()\n target_faces = torch.from_numpy(\n target_faces[:, :3].astype(np.int64)).cuda()\n target_faces.unsqueeze_(0)\n\n states = torch.load(opt.ckpt)\n if \"states\" in states:\n states = states[\"states\"]\n cage_v = states[\"template_vertices\"].transpose(1, 2).cuda()\n cage_f = states[\"template_faces\"].cuda()\n shape_v = states[\"source_vertices\"].transpose(1, 2).cuda()\n shape_f = states[\"source_faces\"].cuda()\n\n if os.path.isfile(opt.model.replace(os.path.splitext(opt.model)[1], \".picked\")) and os.path.isfile(opt.source_model.replace(os.path.splitext(opt.source_model)[1], \".picked\")):\n new_label_path = opt.model.replace(os.path.splitext(opt.model)[1], \".picked\")\n orig_label_path = opt.source_model.replace(os.path.splitext(opt.source_model)[1], \".picked\")\n logger.info(\"Loading picked labels {} and {}\".format(orig_label_path, new_label_path))\n new_label = pd.read_csv(new_label_path, delimiter=\" \",skiprows=1, header=None)\n orig_label = pd.read_csv(orig_label_path, delimiter=\" \",skiprows=1, header=None)\n orig_label_name = orig_label.iloc[:,5]\n new_label_name = new_label.iloc[:,5].tolist()\n new_to_orig_idx = []\n for i, name in enumerate(new_label_name):\n matched_idx = orig_label_name[orig_label_name==name].index\n if matched_idx.size == 1:\n new_to_orig_idx.append((i, matched_idx[0]))\n new_to_orig_idx = np.array(new_to_orig_idx)\n if new_label.shape[1] == 10:\n new_vidx = new_label.iloc[:,9].to_numpy()[new_to_orig_idx[:,0]]\n target_points = target_shape[:, new_vidx, :]\n else:\n new_label_points = torch.from_numpy(new_label.iloc[:,6:9].to_numpy().astype(np.float32))\n target_points = new_label_points.unsqueeze(0).cuda()\n target_points, new_vidx, _ = faiss_knn(1, target_points, target_shape, NCHW=False)\n target_points = target_points.squeeze(2) # B,N,3\n new_label[9] = new_vidx.squeeze(0).squeeze(-1).cpu().numpy()\n new_label.to_csv(new_label_path, sep=\" \", header=[str(new_label.shape[0])]+[\"\"]*(new_label.shape[1]-1), index=False)\n target_points = target_points[:, new_to_orig_idx[:,0], :]\n\n target_points = target_points.cuda()\n source_shape, _ = read_trimesh(opt.source_model)\n source_shape = torch.from_numpy(source_shape[None, :,:3]).float()\n if orig_label.shape[1] == 10:\n orig_vidx = orig_label.iloc[:,9].to_numpy()[new_to_orig_idx[:,1]]\n source_points = source_shape[:, orig_vidx, :]\n else:\n orig_label_points = torch.from_numpy(orig_label.iloc[:,6:9].to_numpy().astype(np.float32))\n source_points = orig_label_points.unsqueeze(0)\n # find the closest point on the original meshes\n source_points, new_vidx, _ = faiss_knn(1, source_points, source_shape, NCHW=False)\n source_points = source_points.squeeze(2) # B,N,3\n orig_label[9] = new_vidx.squeeze(0).squeeze(-1).cpu().numpy()\n orig_label.to_csv(orig_label_path, sep=\" \", header=[str(orig_label.shape[0])]+[\"\"]*(orig_label.shape[1]-1), index=False)\n source_points = source_points[:,new_to_orig_idx[:,1],:]\n\n _, source_center, _ = center_bounding_box(source_shape[0])\n source_points -= source_center\n source_points = source_points.cuda()\n # # shift target so that the belly match\n # try:\n # orig_bellyUp_idx = orig_label_name[orig_label_name==\"bellUp\"].index[0]\n # orig_bellyUp = orig_label_points[orig_bellyUp_idx, :]\n # new_bellyUp_idx = [i for i, i2 in new_to_orig_idx if i2==orig_bellyUp_idx][0]\n # new_bellyUp = new_label_points[new_bellyUp_idx,:]\n # target_points += (orig_bellyUp - new_bellyUp)\n # except Exception as e:\n # logger.warn(\"Couldn\\'t match belly to belly\")\n # traceback.print_exc(file=sys.stdout)\n\n # source_points[0] = center_bounding_box(source_points[0])[0]\n elif not os.path.isfile(opt.model.replace(os.path.splitext(opt.model)[1], \".picked\")) and \\\n os.path.isfile(opt.source_model.replace(os.path.splitext(opt.source_model)[1], \".picked\")):\n logger.info(\"Could not find {}. Assuming SMPL model\".format(opt.model.replace(os.path.splitext(opt.model)[1], \".picked\")))\n source_shape, source_faces = read_trimesh(opt.source_model)\n assert(source_faces.shape[0] == target_faces.shape[1]), \\\n \"opt.model must be a SMPL model with {} faces and {} vertices. Otherwise a correspondence file {} must be present.\".format(\n source_faces.shape[0], source_shape.shape[0], opt.model.replace(os.path.splitext(opt.model)[1], \".picked\"))\n # align faces not vertices\n orig_label_path = opt.source_model.replace(os.path.splitext(opt.source_model)[1], \".picked\")\n logger.info(\"Loading picked labels {}\".format(orig_label_path))\n orig_label = pd.read_csv(orig_label_path, delimiter=\" \",skiprows=1, header=None)\n source_shape = torch.from_numpy(source_shape[None, :, :3]).cuda().float()\n source_faces = torch.from_numpy(source_faces[None, :, :3]).cuda().long()\n idx = torch.from_numpy(orig_label.iloc[:,1].to_numpy()).long()\n source_points = torch.gather(source_shape.unsqueeze(1).expand(-1, idx.numel(), -1, -1), 2, source_faces[:, idx, :, None].expand(-1, -1, -1, 3))\n source_points = source_points.mean(dim=-2)\n target_points = torch.gather(target_shape.unsqueeze(1).expand(-1, idx.numel(), -1, -1), 2, target_faces[:, idx, :, None].expand(-1, -1, -1, 3))\n target_points = target_points.mean(dim=-2)\n\n _, source_center, _ = center_bounding_box(source_shape[0])\n source_points -= source_center\n elif not os.path.isfile(opt.model.replace(os.path.splitext(opt.model)[1], \".picked\")):\n logger.info(\"Could not find {}. Assuming SMPL model\".format(opt.model.replace(os.path.splitext(opt.model)[1], \".picked\")))\n source_shape, source_faces = read_trimesh(opt.source_model)\n assert(source_faces.shape[0] == target_faces.shape[1]), \\\n \"opt.model must be a SMPL model with {} faces and {} vertices. Otherwise a correspondence file {} must be present.\".format(\n source_faces.shape[0], source_shape.shape[0], opt.model.replace(os.path.splitext(opt.model)[1], \".picked\"))\n source_shape, source_faces = read_trimesh(opt.source_model)\n\n _, source_center, _ = center_bounding_box(source_shape[0])\n source_points -= source_center\n\n source_shape = torch.from_numpy(source_shape[None, :, :3]).cuda().float()\n source_faces = torch.from_numpy(source_faces[None, :, :3]).cuda().long()\n # select a subset of faces, otherwise optimization is too slow\n idx = torch.from_numpy(np.random.permutation(2048)).cuda().long()\n source_points = torch.gather(source_shape.unsqueeze(1).expand(-1, source_faces.shape[1], -1, -1), 2, source_faces[:, idx,:, None].expand(-1, -1, -1, 3))\n source_points = source_points.mean(dim=-2)\n target_points = torch.gather(target_shape.unsqueeze(1).expand(-1, source_faces.shape[1], -1, -1), 2, target_faces[:,idx,: None].expand(-1, -1, -1, 3))\n target_points = target_points.mean(dim=-2)\n\n\n target_points = target_points[:, idx]\n source_points = source_points[:, idx]\n\n\n target_shape[0], target_center, target_scale = center_bounding_box(target_shape[0])\n _, _, source_scale = center_bounding_box(shape_v[0])\n # scale according y axis (body height)\n target_scale_factor = (source_scale/target_scale)[0,1]\n target_shape *= target_scale_factor\n target_points -= target_center\n target_points = (target_points*target_scale_factor).detach()\n # make sure test use the normalized\n target_shape_arr[:] = target_shape[0].cpu().numpy()\n om.write_mesh(os.path.join(opt.log_dir, opt.subdir, os.path.splitext(\n os.path.basename(opt.model))[0]+\"_normalized.obj\"), target_mesh)\n opt.model = os.path.join(opt.log_dir, opt.subdir, os.path.splitext(\n os.path.basename(opt.model))[0]+\"_normalized.obj\")\n pymesh.save_mesh_raw(os.path.join(opt.log_dir, opt.subdir, \"template-initial.obj\"),\n shape_v[0].cpu().numpy(), shape_f[0].cpu().numpy())\n pymesh.save_mesh_raw(os.path.join(opt.log_dir, opt.subdir, \"cage-initial.obj\"),\n cage_v[0].cpu().numpy(), cage_f[0].cpu().numpy())\n save_ply(target_points[0].cpu().numpy(), os.path.join(\n opt.log_dir, opt.subdir, \"target_points.ply\"))\n save_ply(source_points[0].cpu().numpy(), os.path.join(\n opt.log_dir, opt.subdir, \"source_points.ply\"))\n logger.info(\"Optimizing for {} corresponding vertices\".format(\n target_points.shape[1]))\n\n cage_init = cage_v.clone().detach()\n lap_loss = MeshLaplacianLoss(torch.nn.MSELoss(reduction=\"none\"), use_cot=True,\n use_norm=True, consistent_topology=True, precompute_L=True)\n mvc_reg_loss = MVCRegularizer(threshold=50, beta=1.0, alpha=0.0)\n cage_v.requires_grad_(True)\n optimizer = torch.optim.Adam([cage_v], lr=opt.lr, betas=(0.5, 0.9))\n scheduler = torch.optim.lr_scheduler.StepLR(optimizer, int(opt.nepochs*0.4), gamma=0.5, last_epoch=-1)\n\n if opt.dim == 3:\n weights_ref = mean_value_coordinates_3D(\n source_points, cage_init, cage_f, verbose=False)\n else:\n raise NotImplementedError\n\n for t in range(opt.nepochs):\n optimizer.zero_grad()\n weights = mean_value_coordinates_3D(\n target_points, cage_v, cage_f, verbose=False)\n loss_mvc = torch.mean((weights-weights_ref)**2)\n # reg = torch.sum((cage_init-cage_v)**2, dim=-1)*1e-4\n reg = torch.tensor(0.0).cuda()\n if opt.clap_weight > 0:\n reg = lap_loss(cage_init, cage_v, face=cage_f)*opt.clap_weight\n reg = reg.mean()\n if opt.mvc_weight > 0:\n reg += mvc_reg_loss(weights)*opt.mvc_weight\n\n loss = loss_mvc + reg\n if (t+1) % 50 == 0:\n print(\"t {}/{} mvc_loss: {} reg: {}\".format(t, opt.nepochs, loss_mvc.item(), reg.item()))\n\n if loss_mvc.item() < 5e-6:\n break\n loss.backward()\n optimizer.step()\n scheduler.step()\n\n return cage_v, cage_f","def __init__(self, b=0, drop_rate=0.5, pretrained=True):\n\n # Calls the super for the nn.Module.\n super(SelectiveNet, self).__init__()\n\n # Loads the EfficientNet encoder.\n if pretrained:\n self.encoder = EfficientNet.from_pretrained(f\"efficientnet-b{str(b)}\")\n else:\n self.encoder = EfficientNet.from_name(f\"efficientnet-b{str(b)}\")\n self.encoder_pool = nn.AdaptiveAvgPool2d(1)\n\n # Defines a hidden layer.\n self.hidden = nn.Linear(2560, 512)\n\n # Initialises the classifier for generating predictions.\n self.classifier = nn.Linear(512, 2)\n\n # Initialises the selective branch for generating selection scores.\n self.selective_hidden = nn.Linear(512, 512)\n self.selective_batch_norm = nn.BatchNorm1d(512)\n self.selective_regression = nn.Linear(512, 1)\n\n # Initialises the auxiliary output used by the model during training.\n self.auxiliary_output = nn.Linear(512, 2)\n\n # Stores the dropout rate in the object.\n self.drop_rate = drop_rate","def _select(self):\n sel = []\n\n # choose randomly while favouring fit individuals\n lp = len(self.population) // 2\n for _ in range(lp):\n idx1 = idx2 = int(math.sqrt(random.randrange(lp**2+1)))\n while idx1 == idx2:\n idx2 = int(math.sqrt(random.randrange(lp**2+1)))\n\n p1, p2 = self.population[idx1], self.population[idx2]\n sel.append((p1, p2))\n\n return sel","def subset_trees(self, trees_take):\n assert self.is_fitted_\n trees_take = np.array(trees_take).reshape(-1).astype(ctypes.c_size_t)\n if not trees_take.shape[0]:\n raise ValueError(\"'trees_take' is empty.\")\n if trees_take.max() >= self._ntrees:\n raise ValueError(\"Attempting to take tree indices that the model does not have.\")\n new_cpp_obj = self._cpp_obj.subset_model(trees_take, self._is_extended_, self.build_imputer)\n old_cpp_obj = self._cpp_obj\n try:\n self._cpp_obj = None\n new_obj = deepcopy(self)\n new_obj._cpp_obj = new_cpp_obj\n finally:\n self._cpp_obj = old_cpp_obj\n return new_obj","def search(self):\n W = np.zeros((self.subsets.shape[0],)) \n for i,E in enumerate(self.subsets):\n self.graph.setV(E) # set the nodes to their values\n W[i] = self.graph.computeW()\n self.Ws = W","def feature_selection(x_train, y_train, nb_feats=150):\n cs = np.zeros(x_train.shape[1])\n for f in range(x_train.shape[1]):\n if np.isclose(np.sum(x_train[:, f]), 0):\n cs[f] = 0\n continue\n\n cs[f], p = spearmanr(x_train[:, f], np.mean(y_train, axis=1))\n select = np.argsort(np.abs(cs))[np.max([-nb_feats, -len(cs)]):]\n return select"],"string":"[\n \"def training_batch_selection(train_set_size, input_img):\\n\\n input_dims = input_img.shape\\n all_data_indices = np.arange(input_dims[0]*input_dims[1])\\n all_data_indices = all_data_indices.reshape(input_dims[:-1])\\n\\n conf = get_config()\\n inside = int(np.floor(conf[\\\"inside_part\\\"]))\\n outside = int(np.floor(conf[\\\"outside_part\\\"]))\\n cx = ii.image.c_x\\n cy = ii.image.c_y\\n\\n # Find the position of the crop in the image and determine part least affected by radial distortion\\n center_x = (conf[\\\"crop\\\"][\\\"left_top\\\"]['x'] + conf[\\\"crop\\\"][\\\"size\\\"][\\\"height\\\"]/2)*2/ii.image.height-1.\\n center_y = (conf[\\\"crop\\\"][\\\"left_top\\\"]['y'] + conf[\\\"crop\\\"][\\\"size\\\"][\\\"width\\\"]/2)*2/ii.image.width-1.\\n\\n left_right_center = max(min((center_y-cy)*2, 1), -1)\\n top_bot_center = max(min((center_x - cx) * 2, 1), -1)\\n\\n # DEBUG: set your own center\\n # left_right_center = 0\\n # top_bot_center = 0\\n\\n from_x = int(round(inside*(1.-top_bot_center)))\\n to_x = min(-int(round(inside*(1.+top_bot_center))), -1)\\n from_y = int(round(inside*(1.-left_right_center)))\\n to_y = min(-int(round(inside*(1.+left_right_center))), -1)\\n\\n # Exclude part that is minimally affected by radial distortion\\n selection_exclude = all_data_indices[from_x:to_x, from_y:to_y]\\n selection_exclude = selection_exclude.reshape(-1)\\n\\n # Exclude outer border in order to avoid index out of bounds\\n selection_include = all_data_indices[outside:-outside,\\n outside:-outside]\\n selection_include = selection_include.reshape(-1)\\n\\n selection = [x for x in selection_include if x not in selection_exclude]\\n selection = np.random.permutation(selection)\\n\\n # DEBUG: forcing larger training set\\n train_set_size = int(train_set_size*2)\\n\\n selection = selection[:train_set_size]\\n\\n # DEBUG: display image region for selection\\n image = input_img.reshape(-1)\\n image[:] = 0\\n image[selection_include] = input_img.reshape(-1)[selection_include]\\n image[selection_exclude] = 0\\n image = image.reshape(input_dims[0], input_dims[1])\\n Verbose.imshow(image, Verbose.debug)\\n\\n return selection\",\n \"def _selection(self, evaluations, selection, method=\\\"truncated\\\", best_rate=0.2):\\n\\n if selection:\\n end_range_for_parents = max(1, int(self.population_size * best_rate))\\n evaluations_sorted = torch.sort(evaluations)\\n population_sorted = self.population[evaluations_sorted[1]]\\n\\n if self.best_individual is None:\\n self.best_individual = population_sorted[0]\\n self.best_eval = evaluations_sorted[0][0]\\n elif self.best_eval > evaluations_sorted[0][0]:\\n self.best_individual = population_sorted[0]\\n self.best_eval = evaluations_sorted[0][0]\\n best_population = torch.zeros([end_range_for_parents, len(self.population[0])], device=self.device)\\n if method == \\\"truncated\\\":\\n \\\"\\\"\\\"\\n returns best individuals\\n \\\"\\\"\\\"\\n best_population = population_sorted[:end_range_for_parents]\\n elif method == \\\"fitness_based\\\":\\n \\\"\\\"\\\"\\n probability of each individual to be selected is proportional to its fitness value\\n \\\"\\\"\\\"\\n tot = sum(evaluations)\\n probabilities = evaluations / tot\\n for i in range(end_range_for_parents):\\n best_idx = torch.distributions.categorical.Categorical(\\n probabilities.clone().detach()).sample()\\n best_population[i] = self.population[best_idx]\\n # avoid repetitions\\n probabilities[best_idx] = 0\\n elif method == \\\"rank_based\\\":\\n \\\"\\\"\\\"\\n probability of each individual to be selected is proportional to its rank value\\n \\\"\\\"\\\"\\n tot = ((1 + len(evaluations)) / 2) * len(evaluations)\\n ranks = torch.linspace(1, len(evaluations), steps=len(evaluations), device=self.device)\\n sorted_probabilities = 1 - ranks / tot\\n for i in range(end_range_for_parents):\\n best_idx = torch.distributions.categorical.Categorical(\\n sorted_probabilities).sample()\\n best_population[i] = population_sorted[best_idx]\\n # avoid repetitions\\n sorted_probabilities[best_idx] = 0\\n if self.elitism:\\n best_population[end_range_for_parents - 1] = self.best_individual\\n else:\\n best_population = self.population\\n return best_population\",\n \"def select_model():\\r\\n from sklearn import tree\\r\\n import graphviz\\r\\n\\r\\n ValidationSetAndLabels = AllSets[1]\\r\\n ValLabels = ValidationSetAndLabels[:, [-1]] # extract labels (last column)\\r\\n ValSet = np.delete(ValidationSetAndLabels, -1, axis=1) # delete labels\\r\\n\\r\\n TrainingSetAndLabels = AllSets[2]\\r\\n TrainLabels = TrainingSetAndLabels[:, [-1]] # extract labels (last column)\\r\\n TrainSet = np.delete(TrainingSetAndLabels, -1, axis=1) # delete labels\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n This is the code to select the best hyperparameter (part b)\\r\\n\\r\\n for SplitCriterion in ['entropy', 'gini']:\\r\\n print \\\"Criterion: \\\" + SplitCriterion + '\\\\n'\\r\\n\\r\\n for MaxDepth in [int(depth) for depth in np.linspace(1, np.log2(TrainSet.shape[1]), 5)]:\\r\\n print \\\"max_depth: \\\" + str(MaxDepth) + '\\\\n'\\r\\n\\r\\n MyTree = tree.DecisionTreeClassifier(criterion=SplitCriterion, max_depth=MaxDepth)\\r\\n MyTree = MyTree.fit(TrainSet, TrainLabels)\\r\\n\\r\\n Predictions = MyTree.predict(ValSet)\\r\\n Result = np.abs(Predictions - ValLabels.flatten())\\r\\n\\r\\n Accuracy = 100 * float(np.count_nonzero(Result == 0)) / Predictions.shape[0]\\r\\n\\r\\n print \\\"Accuracy for this test is: %f %%\\\" %Accuracy\\r\\n print '\\\\n'\\r\\n\\r\\n print '\\\\n'\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n MyTree = tree.DecisionTreeClassifier(criterion='entropy', max_depth=12)\\r\\n\\r\\n MyTree = MyTree.fit(TrainSet, TrainLabels)\\r\\n\\r\\n Predictions = MyTree.predict(ValSet)\\r\\n Result = np.abs(Predictions - ValLabels.flatten())\\r\\n\\r\\n Accuracy = 100 * float(np.count_nonzero(Result == 0)) / Predictions.shape[0]\\r\\n\\r\\n dot_data = tree.export_graphviz(MyTree, out_file=None, max_depth=2,\\r\\n feature_names=AllSets[3], filled=True, rounded=True, special_characters=True,\\r\\n class_names=TrainLabels.flatten().astype(str))\\r\\n graph = graphviz.Source(dot_data)\\r\\n graph.render(\\\"output\\\")\",\n \"def feature_selection(train_features, test_features, train_similarity_target, test_similarity_target, regressor, used_features):\\n\\t# percentile selector\\n\\tpercentile_selector, percentile_score, percentile_train_features_selected, percentile_test_features_selected, percentile_mask = best_percentile_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor)\\n\\n\\t# model based selector\\n\\tmodel_based_selector, model_based_score, model_based_train_features_selected, model_based_test_features_selected, model_based_mask = best_model_based_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor)\\n\\n\\t# iterative based selector\\n\\titerative_based_selector, iterative_based_score, iterative_based_train_features_selected, iterative_based_test_features_selected, iterative_based_mask = best_iterative_based_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor)\\n\\n\\tall_scores = []\\n\\n\\tregressor.fit(train_features, train_similarity_target)\\n\\tprint(\\\"The score on all features: %.3f\\\" % regressor.score(test_features, test_similarity_target))\\n\\tall_scores.append(regressor.score(test_features, test_similarity_target))\\n\\n\\t# show results for the percentile selector\\n\\tall_scores.append(percentile_score)\\n\\n\\t# show results for the model based selector\\n\\tall_scores.append(model_based_score)\\n\\n\\t# show results for the iterative based selector\\n\\tall_scores.append(iterative_based_score)\\n\\n\\tmax_value_position = all_scores.index(max(all_scores))\\n\\n\\tif max_value_position == 0:\\n\\t\\tprint(\\\"Returning all features!\\\\n\\\")\\n\\t\\treturn train_features, test_features\\n\\telif max_value_position == 1:\\n\\t\\tpercentile_mask = build_mask(percentile_mask, used_features)\\n\\t\\tmask_save_path = os.path.join('feature_selection_masks', 'percentile_mask.txt')\\n\\t\\tdebug_data(percentile_mask, mask_save_path)\\n\\n\\t\\tprint(\\\"Returning features selected with the percentile selector!\\\\n\\\")\\n\\t\\treturn percentile_selector, percentile_train_features_selected, percentile_test_features_selected\\n\\telif max_value_position == 2:\\n\\t\\tmodel_based_mask = build_mask(model_based_mask, used_features)\\n\\t\\tmask_save_path = os.path.join('feature_selection_masks', 'model_based_mask.txt')\\n\\t\\tdebug_data(model_based_mask, mask_save_path)\\n\\n\\t\\tprint(\\\"Returning features selected with the model based selector!\\\\n\\\")\\n\\t\\treturn model_based_selector, model_based_train_features_selected, model_based_test_features_selected\\n\\telse:\\n\\t\\titerative_based_mask = build_mask(iterative_based_mask, used_features)\\n\\t\\tmask_save_path = os.path.join('feature_selection_masks', 'iterative_based_mask.txt')\\n\\t\\tdebug_data(iterative_based_mask, mask_save_path)\\n\\n\\t\\tprint(\\\"Returning features selected with the iterative based selector!\\\\n\\\")\\n\\t\\treturn iterative_based_selector, iterative_based_train_features_selected, iterative_based_test_features_selected\",\n \"def best_iterative_based_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor):\\n\\titerative_based_score = 0\\n\\t# given that all pairs use the same amount of features, the position 0 was arbitrarily selected to compute the number of features being used\\n\\tmin_number_features = int(0.15*len(train_features[0]))\\n\\tmax_number_features = int(0.85*len(train_features[0]))\\n\\n\\t# min_number_features = 19\\n\\t# max_number_features = 20\\n\\n\\titerative_based_selector = None\\n\\titerative_based_train_features_selected = None\\n\\titerative_based_test_features_selected = None\\n\\n\\tfor i in range(min_number_features, max_number_features):\\n\\t\\tprint(i)\\n\\t\\ttemp_iterative_based_selector = RFE(RandomForestRegressor(n_estimators=100), n_features_to_select=i)\\n\\t\\ttemp_iterative_based_selector.fit(train_features, train_similarity_target)\\n\\t\\ttemp_iterative_based_train_features_selected = temp_iterative_based_selector.transform(train_features)\\n\\t\\ttemp_iterative_based_test_features_selected = temp_iterative_based_selector.transform(test_features)\\n\\n\\t\\tregressor.fit(temp_iterative_based_train_features_selected, train_similarity_target)\\n\\n\\t\\ttemp_score = regressor.score(temp_iterative_based_test_features_selected, test_similarity_target)\\n\\t\\tprint(\\\"The score on the selected features (Iterative Based Selector): %.3f\\\" % temp_score)\\n\\n\\t\\tif temp_score > iterative_based_score:\\n\\t\\t\\titerative_based_score = temp_score\\n\\t\\t\\titerative_based_selector = temp_iterative_based_selector\\n\\t\\t\\titerative_based_train_features_selected = temp_iterative_based_train_features_selected\\n\\t\\t\\titerative_based_test_features_selected = temp_iterative_based_test_features_selected\\n\\n\\titerative_based_mask = iterative_based_selector.get_support()\\n\\tprint(\\\"This is the iterative based mask: \\\")\\n\\tprint(iterative_based_mask)\\n\\n\\treturn iterative_based_selector, iterative_based_score, iterative_based_train_features_selected, iterative_based_test_features_selected, iterative_based_mask\",\n \"def select(self, batch_size):\\n\\n #if self.tree.filled_size() < batch_size:\\n # print('CALLING REPLAY SAMPLING WHEN NOT FULL ENOUGH')\\n # #return None, None\\n\\n out = []\\n indices = []\\n #weights = []\\n priorities = []\\n avoid_resampling = False\\n for _ in range(batch_size):\\n r = random.random()\\n #return (idx, self.tree[idx], self.data[dataIdx])\\n data, priority, index = self.tree.find(r)\\n #index, priority, data = self.tree.find(r)\\n #print(index)\\n #print(\\\"d: {}, \\\\n priority: {}, \\\\n index: {}\\\".format(data, priority, index))\\n priorities.append(priority)\\n #weights.append((1. / self.memory_size / priority) ** beta if priority > 1e-16 else 0)\\n indices.append(index)\\n out.append(data)\\n if avoid_resampling: self.priority_update([index], [self.epsilon_priority]) # To avoid resampling same transition too much\\n\\n for i in range(len(priorities)):\\n if priorities[i] >= self.bonus_priority: # remove priority bonus\\n priorities[i] -= self.bonus_priority\\n self.priority_update([indices[i]],[priorities[i]])\\n\\n # avoid resampling part self.priority_update(indices, priorities) # Revert priorities\\n #weights /= max(weights) # Normalize for stability\\n return out, indices\",\n \"def evalute_subset(X_train, X_test, y_train, y_test):\\r\\n clf = KNeighborsClassifier(n_neighbors=3)\\r\\n clf.fit(X_train, y_train) \\r\\n y_pred = clf.predict(X_test)\\r\\n return accuracy_score(y_test, y_pred)\",\n \"def aux_best_percentile_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor, used_features):\\n\\tpercentile_score = 0\\n\\tpercentiles = [25, 35, 45, 50, 55, 65, 75]\\n\\t# percentiles = [45]\\n\\tpercentile_selector = None\\n\\tpercentile_train_features_selected = None\\n\\tpercentile_test_features_selected = None\\n\\n\\tfor percentile in percentiles:\\n\\t\\tprint(percentile)\\n\\t\\ttemp_percentile_selector = SelectPercentile(score_func=f_regression, percentile=percentile)\\n\\t\\ttemp_percentile_selector.fit(train_features, train_similarity_target)\\n\\t\\ttemp_percentile_train_features_selected = temp_percentile_selector.transform(train_features)\\n\\t\\ttemp_percentile_test_features_selected = temp_percentile_selector.transform(test_features)\\n\\n\\t\\tregressor.fit(temp_percentile_train_features_selected, train_similarity_target)\\n\\n\\t\\ttemp_score = regressor.score(temp_percentile_test_features_selected, test_similarity_target)\\n\\t\\tprint(\\\"The score on the selected features (Percentile Selector): %.3f\\\" % temp_score)\\n\\n\\t\\tif temp_score > percentile_score:\\n\\t\\t\\tpercentile_score = temp_score\\n\\t\\t\\tpercentile_selector = temp_percentile_selector\\n\\t\\t\\tpercentile_train_features_selected = temp_percentile_train_features_selected\\n\\t\\t\\tpercentile_test_features_selected = temp_percentile_test_features_selected\\n\\n\\tpercentile_mask = percentile_selector.get_support()\\n\\tprint(\\\"This is the percentile mask: \\\")\\n\\tprint(percentile_mask)\\n\\n\\tpercentile_mask = build_mask(percentile_mask, used_features)\\n\\tmask_save_path = os.path.join('feature_selection_masks', 'assin2_percentile_based_mask.txt')\\n\\tdebug_data(percentile_mask, mask_save_path)\\n\\n\\treturn percentile_train_features_selected, percentile_test_features_selected, percentile_selector\",\n \"def test_subset_imask_squeeze(self, model_data, imask_subset_config):\\n # foreach doesn't have this additional dimension\\n foreach = [\\\"techs\\\"]\\n imask = _imask_foreach(model_data, foreach)\\n assert imask.dims == (\\\"techs\\\",)\\n # on using 'where', the 'nodes' dimension is added\\n imask = _imask_where(model_data, \\\"foo\\\", [\\\"node_tech\\\"], imask, \\\"and_\\\")\\n assert sorted(imask.dims) == sorted([\\\"nodes\\\", \\\"techs\\\"])\\n imask_subset = _subset_imask(\\\"foo\\\", imask_subset_config(foreach), imask)\\n assert imask_subset.dims == (\\\"techs\\\",)\\n assert imask_subset.equals(imask.loc[{\\\"nodes\\\": \\\"foo\\\"}].drop_vars(\\\"nodes\\\"))\",\n \"def best_model_based_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor):\\n\\tmodel_based_score = 0\\n\\tscaling_factors = [\\\"0.25*mean\\\", \\\"0.5*mean\\\", \\\"median\\\", \\\"1.25*mean\\\", \\\"1.5*mean\\\"]\\n\\t# scaling_factors = [\\\"0.5*mean\\\", \\\"median\\\"]\\n\\tmodel_based_selector = None\\n\\tmodel_based_train_features_selected = None\\n\\tmodel_based_test_features_selected = None\\n\\n\\tfor factor in scaling_factors:\\n\\t\\tprint(factor)\\n\\t\\ttemp_model_based_selector = SelectFromModel(RandomForestRegressor(n_estimators=100), threshold=factor)\\n\\t\\ttemp_model_based_selector.fit(train_features, train_similarity_target)\\n\\t\\ttemp_model_based_train_features_selected = temp_model_based_selector.transform(train_features)\\n\\t\\ttemp_model_based_test_features_selected = temp_model_based_selector.transform(test_features)\\n\\n\\t\\tregressor.fit(temp_model_based_train_features_selected, train_similarity_target)\\n\\n\\t\\ttemp_score = regressor.score(temp_model_based_test_features_selected, test_similarity_target)\\n\\t\\tprint(\\\"The score on the selected features (Model Based Selector): %.3f\\\" % temp_score)\\n\\n\\t\\tif temp_score > model_based_score:\\n\\t\\t\\tmodel_based_score = temp_score\\n\\t\\t\\tmodel_based_selector = temp_model_based_selector\\n\\t\\t\\tmodel_based_train_features_selected = temp_model_based_train_features_selected\\n\\t\\t\\tmodel_based_test_features_selected = temp_model_based_test_features_selected\\n\\n\\tmodel_based_mask = model_based_selector.get_support()\\n\\tprint(\\\"This is the model based mask: \\\")\\n\\tprint(model_based_mask)\\n\\n\\treturn model_based_selector, model_based_score, model_based_train_features_selected, model_based_test_features_selected, model_based_mask\",\n \"def select(individuals, n):\\r\\n # return selBest(individuals, n)\\r\\n return individuals[:n]\",\n \"def negSamplingCostAndGradient(predicted, target, outputVectors, dataset,\\n K=10):\\n\\n # Sampling of indices is done for you. Do not modify this if you\\n # wish to match the autograder and receive points!\\n indices = [target]\\n indices.extend(getNegativeSamples(target, dataset, K))\\n\\n ### YOUR CODE HERE\\n #The cost now is maximize the predicted and target pair,\\n #minimizing the predicted and the sampled pairs\\n cost = 0\\n gradPred = np.zeros(predicted.shape[0])\\n grad = np.zeros(outputVectors.shape)\\n\\n for indice in indices:\\n target_vector = outputVectors[indice]\\n vector_product = np.dot(target_vector,predicted)\\n if indice != target:\\n cost += -np.log(sigmoid(-vector_product))\\n gradPred += sigmoid(vector_product)*target_vector\\n # use += in case of repeatance\\n grad[indice,:] += sigmoid(vector_product)*predicted\\n else:\\n cost += -np.log(sigmoid(vector_product))\\n gradPred += (sigmoid(vector_product) - 1)*target_vector\\n grad[indice,:] += (sigmoid(vector_product)-1)*predicted\\n ### END YOUR CODE\\n #print indices\\n\\n return cost, gradPred, grad\",\n \"def local_optimize(X, nrounds=1, cost_weights=(1.,1.,1.), use_all=True, use_subset=False):\\n\\n old_cost = cost_total(X, cost_weights=cost_weights)\\n\\n orig_cost = old_cost\\n\\n configs = [X.names_seats_dict.copy()]\\n\\n # loop through number of rounds\\n for ind1 in range(nrounds):\\n\\n # loop through randomly\\n for ind in np.random.choice(range(len(X.seats)), len(X.seats), replace=True):\\n # print(old_cost)\\n # get a candidate\\n\\n if not use_all:\\n neighbours_to_check = np.random.choice(X.seats_graph[X.seats[ind]],len(X.seats_graph[X.seats[ind]]), False)\\n else:\\n if use_subset:\\n neighbours_to_check = [st for st in X.seats if np.random.rand() > .5]\\n else:\\n neighbours_to_check = X.seats\\n\\n for ind_n in neighbours_to_check:\\n\\n X_new = X.copy()\\n X_new.update(swap_neighbour(X_new, p1=X.seats[ind], p2=ind_n))\\n\\n new_cost = cost_total(X_new, cost_weights=cost_weights)\\n\\n # accept if better\\n if new_cost < old_cost:\\n old_cost = new_cost\\n configs.append(X.names_seats_dict)\\n X = X_new.copy()\\n\\n return X, orig_cost, old_cost, configs\",\n \"def trainModelOnSubset(self, data, attributes, class_label, indices=None, startNode = None, max_depth=-1):\\n\\t\\t\\n\\t\\t#print (data)\\n\\t\\t#print(\\\"_________---_________\\\")\\n\\t\\t\\n\\t\\tif startNode == None:\\n\\t\\t\\tstartNode = self.root\\n\\t\\t\\n\\t\\t#print(startNode.name)\\n\\t\\t\\n\\t\\t#print(\\\"Attributes: \\\" + str(attributes))\\n\\t\\t\\n\\t\\tnew_attributes=attributes[:]\\n\\t\\t\\n\\t\\tif indices == None:\\n\\t\\t\\tsubset = data\\t\\t\\t\\n\\t\\telse:\\n\\t\\t\\tsubset = data.loc[indices]\\n\\t\\t\\n\\t\\t\\n\\t\\tif (len(new_attributes) > 0 and not subset.empty):\\n\\t\\t\\tbestAttribute_index = startNode.trainNode(data, new_attributes, class_label, indices)\\n\\t\\t\\tbestAttribute = new_attributes[bestAttribute_index]\\n\\t\\t\\tnew_attributes.pop(bestAttribute_index)\\n\\t\\t\\tvalues = attributes_full[bestAttribute]\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t\\tfor i in values:\\n\\t\\t\\t\\tnode = Node(i)\\n\\t\\t\\t\\tstartNode.add_child(node)\\n\\t\\t\\t\\t#print(node.get_name())\\n\\t\\t\\t\\t#print(bestAttribute)\\n\\t\\t\\t\\tindex = list(subset.index[subset[bestAttribute] == i])\\n\\t\\t\\t\\tself.trainModelOnSubset(subset, new_attributes, class_label, index, node)\\n\\t\\t\\t\\n\\t\\telse:\\n\\t\\t\\tbestAttribute=class_label\\n\\t\\t\\tvalues = attributes_full[bestAttribute]\\n\\t\\t\\tsublist = data[bestAttribute].tolist()\\n\\t\\t\\ttop = 0\\n\\t\\t\\tname = \\\"test\\\"\\n\\t\\t\\tfor i in values:\\n\\t\\t\\t\\tif sublist.count(i) > top:\\n\\t\\t\\t\\t\\tname = i\\n\\t\\t\\t\\t\\ttop = sublist.count(i)\\n\\t\\t\\tnode = Node(name)\\n\\t\\t\\tstartNode.add_child(node)\",\n \"def _select(self):\\n # The order of adding mutants and babies is important.\\n # Later the statistics are computed assuming this addition order.\\n self._add_newpop(self._mutants, self._babies)\\n last_idx = min(self.pop_size, len(self._curr_pop))\\n # Make sure the best and the worst chromos\\n # after the selection are correctly placed.\\n self._selects = np.argpartition(self._errors, 0)\\n self._selects = self._selects[0:last_idx]\\n self._curr_pop = self._curr_pop[self._selects]\\n self._diffs = self._diffs[self._selects]\\n self._errors = self._errors[self._selects]\\n best = self._errors[0]\\n if best < self._best_error:\\n self._best_error = best\\n self._best_gen = self._gen_idx\",\n \"def best_percentile_selector(train_features, test_features, train_similarity_target, test_similarity_target, regressor):\\n\\tpercentile_score = 0\\n\\tpercentiles = [25, 35, 45, 50, 55, 65, 75]\\n\\t# percentiles = [45]\\n\\tpercentile_selector = None\\n\\tpercentile_train_features_selected = None\\n\\tpercentile_test_features_selected = None\\n\\n\\tfor percentile in percentiles:\\n\\t\\tprint(percentile)\\n\\t\\ttemp_percentile_selector = SelectPercentile(score_func=f_regression, percentile=percentile)\\n\\t\\ttemp_percentile_selector.fit(train_features, train_similarity_target)\\n\\t\\ttemp_percentile_train_features_selected = temp_percentile_selector.transform(train_features)\\n\\t\\ttemp_percentile_test_features_selected = temp_percentile_selector.transform(test_features)\\n\\n\\t\\tregressor.fit(temp_percentile_train_features_selected, train_similarity_target)\\n\\n\\t\\ttemp_score = regressor.score(temp_percentile_test_features_selected, test_similarity_target)\\n\\t\\tprint(\\\"The score on the selected features (Percentile Selector): %.3f\\\" % temp_score)\\n\\n\\t\\tif temp_score > percentile_score:\\n\\t\\t\\tpercentile_score = temp_score\\n\\t\\t\\tpercentile_selector = temp_percentile_selector\\n\\t\\t\\tpercentile_train_features_selected = temp_percentile_train_features_selected\\n\\t\\t\\tpercentile_test_features_selected = temp_percentile_test_features_selected\\n\\n\\tpercentile_mask = percentile_selector.get_support()\\n\\tprint(\\\"This is the percentile mask: \\\")\\n\\tprint(percentile_mask)\\n\\n\\treturn percentile_selector, percentile_score, percentile_train_features_selected, percentile_test_features_selected, percentile_mask\",\n \"def finish_sensitivity(self):\\n # do at most 1000 features\\n idx = torch.randperm(self._features.shape[1])[:100]\\n self._features = self._features[:, idx]\\n\\n weight = self.module.weight.data\\n num_features_in = weight.shape[1]\\n selected_in = torch.zeros(num_features_in).bool()\\n\\n # greedy approach to rank in features\\n for rank in reversed(range(num_features_in)):\\n error_best = torch.Tensor([np.Inf])\\n best = None\\n\\n # loop through remaining features to see which to add next\\n for idx_in in range(num_features_in):\\n # it's already in the set, no need trying to add it...\\n if selected_in[idx_in]:\\n continue\\n\\n # try adding in feature j and compute error\\n selected_in[idx_in] = 1\\n error_with_j = (\\n self._features[selected_in].sum(dim=0) ** 2\\n ).sum()\\n\\n # see if it's better than previous best\\n if error_with_j < error_best:\\n error_best = error_with_j\\n best = idx_in\\n\\n # remove j from selectedIn for now\\n selected_in[idx_in] = 0\\n\\n # add best one from this round to selectedIn\\n selected_in[best] = 1\\n\\n # also note the rank of best in the sensitivities\\n self.sensitivity_in[best] = rank\",\n \"def runNN(selectables_interests=[[0.0, 0.1, 0.6, 0.7], [0.0, 0.5, 0.6, 1]], profile_interests = [0.0, 0.1, 0.2, 0.3]):\\n #Intialise a single neuron neural network.\\n # Apply vertical normalisation for the pageobject interests\\n if len(selectables_interests)>0:\\n selectables_interests = normalize(selectables_interests, axis=0, norm='l1')\\n else:\\n # If there is nothing to compare it to, return the current profile.\\n return profile_interests\\n # For the given size of the first element in the array (number of interests) add a dimension of such size\\n Interest_Array_Inputs = [[] for i in range(len(selectables_interests[0]))]\\n Interest_Array_Outputs = [[] for i in range(len(selectables_interests[0]))]\\n # Creating instances of 3 dimensional Inputs/Outputs sets\\n for ida, ll in enumerate(selectables_interests):\\n # For the number of permutations\\n current_fuzzy_element_permutation = fuzzy_permutation(ll)\\n for index in range(len(current_fuzzy_element_permutation[0])):\\n # Insert array inside column Interest for the input, output.\\n Interest_Array_Inputs[current_fuzzy_element_permutation[0][index][0]].append(current_fuzzy_element_permutation[0][index][1][:])\\n Interest_Array_Outputs[current_fuzzy_element_permutation[1][index][0]].append([current_fuzzy_element_permutation[1][index][1]])\\n profile_Interest_Inputs = []\\n # Creating the list of inputs (Leaving out an interest to be predicted)\\n for index, inputList in enumerate(fuzzy_permutation(profile_interests)[0]):\\n profile_Interest_Inputs.append(inputList[1])\\n\\n collected_interests = []\\n # Training on each individual interest\\n for i in range(len(profile_interests)):\\n collected_interests.append(initialise_train_result(Interest_Array_Inputs[i], Interest_Array_Outputs[i], profile_Interest_Inputs[i]))\\n well_ordered_interests = collected_interests[::-1]\\n # Returns the outcoming interests.\\n return well_ordered_interests\",\n \"def index_subset(subset, numTestClasses=7, randomSeed=123 ):\\n print(\\\"datasets.py is ingesting the DF dataset from data/SETA.npz\\\")\\n npzfile = np.load(\\\"data/SETA.npz\\\", allow_pickle=True)\\n data = npzfile[\\\"data\\\"]\\n labels = npzfile[\\\"labels\\\"]\\n npzfile.close()\\n distinctLabelCount= len(set(labels))\\n \\n\\n #print(\\\"distinctLabelCount\\\", distinctLabelCount)\\n \\n #random.seed(randomSeed)\\n testClasses = random.sample(range(0,distinctLabelCount),numTestClasses)\\n\\n # Test the overrides \\n \\n # WORST \\n #testClasses = np.array([18.0,16.0,14.0,11.0,10.0,9.0,7.0]).tolist()\\n # BEST\\n #testClasses = np.array([5.0,6.0,8.0,12.0,13.0,14.0,19.0]).tolist()\\n \\n testClasses = [np.float64(i) for i in testClasses]\\n\\n mask = np.isin(labels,testClasses)\\n \\n \\n X_test = data[np.where(mask)]\\n X_train = data[np.where(~mask)]\\n y_test = labels[np.where(mask)]\\n y_train = labels[np.where(~mask)]\\n \\n if subset==\\\"background\\\":\\n \\n print(\\\"SETA data\\\", data.shape)\\n print(\\\"labels\\\", labels.shape)\\n print(testClasses)\\n \\n print(\\\"Current working directory is \\\", os.getcwd())\\n X = X_train\\n y = y_train\\n print(\\\"SETA background data shape\\\", X.shape)\\n elif subset==\\\"evaluation\\\":\\n X = X_test\\n y = y_test\\n print(\\\"SETA evaluation data shape\\\", X.shape)\\n images = []\\n \\n #print(\\\"y shape\\\", y.shape)\\n \\n \\n for i in range(y.shape[0]):\\n images.append({\\n 'subset': subset,\\n 'class_name': y[i],\\n 'data': X[i].reshape(1,X[1].shape[0]) # This is the shape needed for Matching Networks\\n #'data': X[i] #.reshape(X[1].shape[0]) # This is the shape needed for MAML\\n })\\n \\n return images\",\n \"def create_valid_subset(model_data, name, config):\\n\\n # Start with a mask that is True where the tech exists at a node (across all timesteps and for a each carrier and cost, where appropriate)\\n imask = _imask_foreach(model_data, config.foreach)\\n if imask is False: # i.e. not all of 'foreach' are in model_data\\n return None\\n # Add \\\"where\\\" info as imasks\\n where_array = config.get_key(\\\"where\\\", default=[])\\n if where_array:\\n imask = _imask_where(model_data, name, where_array, imask, \\\"and_\\\")\\n\\n # Add imask based on subsets\\n imask = _subset_imask(name, config, imask)\\n\\n # Only build and return imask if there are some non-zero elements\\n if isinstance(imask, xr.DataArray) and imask.sum() != 0:\\n # Squeeze out any unwanted dimensions\\n if len(imask.dims) > len(config.foreach):\\n imask = imask.sum([i for i in imask.dims if i not in config.foreach]) > 0\\n # We have a problem if we have too few dimensions at this point...\\n if len(imask.dims) < len(config.foreach):\\n raise ValueError(f\\\"Missing dimension(s) in imask for set {name}\\\")\\n\\n valid_subset = _get_valid_subset(\\n reorganise_xarray_dimensions(imask).astype(bool)\\n )\\n\\n return valid_subset\\n\\n else:\\n return None\",\n \"def TSP(noOfCities, cityIndicesExcluding1, citiesDistance):\\r\\n\\r\\n # Initializing the DP Matrix\\r\\n # Dictionary because the subset is also to be saved alongwith end vertex as index of dictionary\\r\\n dpMatrixDict = {}\\r\\n\\r\\n # Base case\\r\\n dpMatrixDict[ ( 1, ), 1 ] = 0\\r\\n\\r\\n # Iterating to solve bigger subproblems using dynamic programming\\r\\n for subsetSizeWithout1 in range(1, noOfCities):\\r\\n\\r\\n # Subset is of size subsetSizeWithout1 + 1\\r\\n print(\\\"COMPUTING. ON ITERATION NUMBER : \\\" + str(subsetSizeWithout1) + \\\" OUT OF \\\" + str(noOfCities - 1) )\\r\\n\\r\\n # Reducing computation by ignoring off the smaller subproblems solutions no longer required\\r\\n if subsetSizeWithout1 > 3:\\r\\n smallerEfficientDpMatrixDict = {}\\r\\n for key in dpMatrixDict:\\r\\n if len(key[0]) == subsetSizeWithout1:\\r\\n smallerEfficientDpMatrixDict[key] = dpMatrixDict[key]\\r\\n dpMatrixDict = smallerEfficientDpMatrixDict\\r\\n\\r\\n # Getting the subsets reuired\\r\\n sizeSpecificSubsets = getSubsets(cityIndicesExcluding1, subsetSizeWithout1)\\r\\n\\r\\n # Base cases\\r\\n for subset in sizeSpecificSubsets:\\r\\n dpMatrixDict[subset, 1] = 99999999\\r\\n\\r\\n\\r\\n for subset in sizeSpecificSubsets:\\r\\n\\r\\n # Computing through each possible end vertex\\r\\n for j in subset[1:]:\\r\\n\\r\\n # List to store the candidates for minimums\\r\\n possibilities = []\\r\\n\\r\\n # Computing through each possible last hop\\r\\n for k in subset:\\r\\n\\r\\n # Storing possibilities alongwith the end vertex\\r\\n if k != j:\\r\\n tupleCopy = tupleCopyWithoutElement(subset, j)\\r\\n possibilities.append( dpMatrixDict[tupleCopy, k] + citiesDistance[k, j] )\\r\\n\\r\\n # Getting the minimum path from the possible minimum candidates\\r\\n try:\\r\\n minimumPath = min(possibilities)\\r\\n dpMatrixDict[subset, j] = minimumPath\\r\\n except:\\r\\n continue\\r\\n\\r\\n\\r\\n # List for storing all final possible path candidates containing all the vertices\\r\\n # and a last hop between the start and end vertex to make a cycle\\r\\n finalHamiltonianPathCandidates = []\\r\\n\\r\\n # Final Set(and/or Subset) including all the vertices\\r\\n almostCompletePath = tuple(range(1, noOfCities + 1))\\r\\n\\r\\n # Adding the last hop of the cycle of hamiltonian path between the end and start vertex\\r\\n for j in cityIndicesExcluding1:\\r\\n finalHamiltonianPathCandidates.append( dpMatrixDict[almostCompletePath, j] + citiesDistance[j, 1] )\\r\\n\\r\\n # Getting the final minimum solution\\r\\n hamiltonianPathSolution = min(finalHamiltonianPathCandidates)\\r\\n\\r\\n # Printing the solution\\r\\n print(\\\"The optimal(minimum) length Hamiltonian path distance is : \\\" + str( hamiltonianPathSolution ) )\\r\\n\\r\\n return\",\n \"def set_subset(self):\\r\\n if self._random_subset:\\r\\n perm = torch.randperm(len(self._indices))\\r\\n self._subset = self._indices[perm][:self._subset_size]\\r\\n else:\\r\\n self._subset = torch.Tensor(self._indices[:self._subset_size])\",\n \"def worker(selection_idx, results_table):\\n randgen = np.random.RandomState()\\n \\n # Data-specific positive set partition (the real-world dataset consists of multiple motif classes, always exactly 3 instances of each class stored consequently).\\n # The partition assures that the training and test sets do not share instances of the same motif class\\n positive_n_train = round(0.8 * len(positive_set_) / 3) * 3\\n block_start_idx = randgen.randint(positive_n_train / 3 + 1) * 3 \\n block_end_idx = block_start_idx + len(positive_set_) - positive_n_train\\n positive_set_part_train, positive_set_part_test = (np.concatenate((positive_set_[: block_start_idx], positive_set_[block_end_idx: ])), positive_set_[block_start_idx: block_end_idx])\\n \\n # Negative set partition with random selection of elements to match the size of the positive set\\n negative_set = negative_set_[randgen.choice(len(negative_set_), size = positive_set_.shape[0], replace = False)]\\n negative_n = len(negative_set)\\n negative_n_train = round(negative_n * 0.8)\\n negative_set_part_train, negative_set_part_test = (negative_set[: negative_n_train], negative_set[negative_n_train: ])\\n \\n data_part_train = np.float64(np.concatenate((positive_set_part_train, negative_set_part_train)))\\n labels_part_train = np.concatenate((np.ones(len(positive_set_part_train), dtype = 'i1'), np.zeros(len(negative_set_part_train), dtype = 'i1')))\\n data_part_test = np.float64(np.concatenate((positive_set_part_test, negative_set_part_test)))\\n labels_part_test = np.concatenate((np.ones(len(positive_set_part_test), dtype = 'i1'), np.zeros(len(negative_set_part_test), dtype = 'i1')))\\n \\n # Specifying the pipeline and the CV structure\\n pruner = feature_selection.VarianceThreshold()\\n scaler = preprocessing.StandardScaler()\\n feature_selector = feature_selection.SelectKBest(feature_selection.f_classif)\\n classifier = svm.SVC(kernel = 'rbf', gamma = 0.01, class_weight = 'balanced')\\n pipeline0 = pipeline.Pipeline([\\n ('pruning', pruner),\\n ('scaling', scaler),\\n ('selection', feature_selector),\\n ('classification', classifier)\\n ])\\n cv_structure = model_selection.StratifiedShuffleSplit(n_splits = 10, test_size = 0.2)\\n scoring = 'recall_macro' #same as balanced accuracy\\n grid = model_selection.GridSearchCV(pipeline0, scoring = scoring, param_grid = param_grid, cv = cv_structure, n_jobs = 1)\\n \\n # Training the pipeline, saving the data\\n grid.fit(data_part_train, labels_part_train)\\n results_table[selection_idx][0] = np.log10(grid.best_params_['classification__C'])\\n results_table[selection_idx][1] = grid.best_params_['selection__k']\\n results_table[selection_idx][2] = grid.best_score_\\n \\n # Testing the pipeline, saving the data\\n results_table[selection_idx][3] = grid.score(data_part_test, labels_part_test)\",\n \"def run_forward_selection(\\n training_predictor_table, validation_predictor_table,\\n training_target_table, validation_target_table, sklearn_model_object,\\n min_fractional_cost_decrease=0.0033):\\n\\n assert min_fractional_cost_decrease > 0.\\n assert min_fractional_cost_decrease < 1.\\n\\n selected_predictor_names = []\\n max_auc_values = [-numpy.inf]\\n remaining_predictor_names = list(training_predictor_table)\\n\\n while len(remaining_predictor_names) > 0:\\n num_selected_predictors = len(selected_predictor_names)\\n num_remaining_predictors = len(remaining_predictor_names)\\n\\n print((\\n 'Step {0:d} of forward selection: {1:d} predictors selected, '\\n '{2:d} remaining...'\\n ).format(\\n num_selected_predictors + 1, num_selected_predictors,\\n num_remaining_predictors\\n ))\\n\\n new_max_auc, best_predictor_name = _forward_selection_step(\\n training_predictor_table=training_predictor_table,\\n validation_predictor_table=validation_predictor_table,\\n training_target_table=training_target_table,\\n validation_target_table=validation_target_table,\\n remaining_predictor_names=remaining_predictor_names,\\n sklearn_model_object=sklearn_model_object\\n )\\n\\n print((\\n 'Max validation AUC ({0:.4f}) given by adding {1:s} '\\n '(previous max AUC = {2:.4f})'\\n ).format(\\n new_max_auc, best_predictor_name, max_auc_values[-1]\\n ))\\n\\n stopping_criterion = max_auc_values[-1] * (\\n 1. + min_fractional_cost_decrease\\n )\\n\\n if new_max_auc < stopping_criterion:\\n break\\n\\n selected_predictor_names.append(best_predictor_name)\\n max_auc_values.append(new_max_auc)\\n\\n remaining_predictor_names = list(\\n set(list(training_predictor_table)) -\\n set(selected_predictor_names)\\n )\\n\\n return selected_predictor_names, numpy.array(max_auc_values[1:])\",\n \"def SelectWorkingSet(L, q):\\n i = 0\\n index = 0\\n while i < int(q/2):\\n if L[index, 1] > 0 and L[index, 1] < C:\\n WorkingSet[i, 0] = L[index, 0]\\n WorkingSet[i, 1] = L[index, 1]\\n WorkingSet[i, 2] = index\\n i = i + 1\\n elif y_train[int(L[index, 0])] == -1 and L[index, 1] <= 0:\\n WorkingSet[i, 0] = L[index, 0]\\n WorkingSet[i, 1] = L[index, 1]\\n WorkingSet[i, 2] = index\\n i = i + 1\\n elif y_train[int(L[index, 0])] == 1 and L[index, 1] == 100:\\n WorkingSet[i, 0] = L[index, 0]\\n WorkingSet[i, 1] = L[index, 1]\\n WorkingSet[i, 2] = index\\n i = i + 1\\n index = index + 1\\n # print(WorkingSet)\\n # print(index)\\n\\n index = len(y_train) - 1\\n while i < int(q):\\n j = 0\\n while j < (int(q/2)):\\n if index == int(WorkingSet[j, 2]):\\n # print(\\\"Hello cunt\\\")\\n # print(index)\\n index = index - 1\\n # print(index)\\n if j > 0:\\n j = 0\\n else:\\n j = j + 1\\n if L[index, 1] > 0 + error and L[index, 1] < C:\\n WorkingSet[i, 0] = L[index, 0]\\n WorkingSet[i, 1] = L[index, 1]\\n WorkingSet[i, 2] = index\\n i = i + 1\\n elif y_train[int(L[index, 0])] == 1 and L[index, 1] <= 0:\\n WorkingSet[i, 0] = L[index, 0]\\n WorkingSet[i, 1] = L[index, 1]\\n WorkingSet[i, 2] = index\\n i = i + 1\\n elif y_train[int(L[index, 0])] == -1 and L[index, 1] == 100:\\n WorkingSet[i, 0] = L[index, 0]\\n WorkingSet[i, 1] = L[index, 1]\\n WorkingSet[i, 2] = index\\n i = i + 1\\n index = index - 1\\n # print(WorkingSet)\\n return WorkingSet\",\n \"def KS_algorithm(dataset_x, dataset_y, train_size = 0.7, return_dataset = True):\\n #Decide number of total samples\\n n = dataset_x.shape[0]\\n \\n #Turn into train_size to float\\n try: \\n train_size = float(train_size)\\n except Expection as e:\\n print(e)\\n \\n #Jusge if the train_size is by ratio or quantity\\n if 0 < train_size < 1: \\n num_of_samples = round(n*train_size)\\n elif 1 < train_size < 2: \\n return \\\"Train size must be between 1 to 0 or 2 to number of total samples\\\" \\n elif train_size == n or train_size == 1:\\n return [x for x in range(n)]\\n elif 2 <= train_size < n:\\n num_of_samples = round(train_size)\\n elif train_size > n:\\n return \\\"Num_of_samples must be less than or equal to original number of samples\\\"\\n \\n #Create original sample index\\n samples = [x for x in range(n)]\\n \\n #Create distance matrix\\n print('Building distance matrix')\\n dist_matrix = create_dist_matrix(dataset_x)\\n\\n #Pick first two furthest away data points\\n print('Picking two furthest away samples')\\n max_array = np.argmax(dist_matrix == np.max(dist_matrix), axis = 1)\\n ind1 = max_array[max_array != 0][0]\\n ind2 = max_array[ind1]\\n\\n #Initiate chosen sample list, append first two samples and remove from remaining sample list\\n chosen_samples = [ind1, ind2]\\n samples.remove(ind1)\\n samples.remove(ind2) \\n remaining_samples = num_of_samples - 2\\n\\n #Continue picking samples if not yet reaching target number of samples\\n while remaining_samples > 0:\\n sub_array = np.min(dist_matrix[:,chosen_samples], axis=1)\\n chosen = np.argmax(sub_array)\\n chosen_samples.append(chosen)\\n samples.remove(chosen)\\n remaining_samples -= 1\\n \\n #See if this function should return train and test set or simply index of chosen samples\\n if return_dataset == True:\\n not_chosen_samples = [x for x in range(n) if x not in chosen_samples]\\n return dataset_x.iloc[chosen_samples,:], dataset_x.iloc[not_chosen_samples,:], dataset_y.iloc[chosen_samples,:], dataset_y.iloc[not_chosen_samples,:] \\n else:\\n return chosen_samples\",\n \"def test_cost_consideration():\\n # input\\n net = create_test_net()\\n idx = pp.create_sgen(net, 1, 1.3, index=2)\\n pp.create_poly_cost(net, idx, \\\"sgen\\\", 2.3, index=4)\\n pp.runpp(net)\\n assert all(net.sgen.index.values == np.array([0, 5, 2]))\\n assert all(net.poly_cost.element == np.array([0, 0, 5, 2]))\\n\\n for cost_type in [\\\"poly_cost\\\", \\\"pwl_cost\\\"]:\\n\\n if cost_type == \\\"pwl_cost\\\":\\n for poly in net.poly_cost.itertuples():\\n net.poly_cost.drop(poly.Index, inplace=True)\\n pp.create_pwl_cost(net, poly.element, poly.et, [[0, 20, 1]], index=poly.Index)\\n\\n # eq generation\\n boundary_buses = [0, 2]\\n internal_buses = [1]\\n eq_net1 = pp.grid_equivalents.get_equivalent(net, \\\"rei\\\", boundary_buses, internal_buses)\\n eq_net2 = pp.grid_equivalents.get_equivalent(net, \\\"rei\\\", boundary_buses, internal_buses,\\n return_internal=False)\\n\\n # check elements\\n check_elements_amount(eq_net1, {\\\"bus\\\": 6, \\\"load\\\": 3, \\\"sgen\\\": 3, \\\"shunt\\\": 5, \\\"ext_grid\\\": 1,\\n \\\"line\\\": 2, \\\"impedance\\\": 10, cost_type: 4},\\n check_all_pp_elements=True)\\n check_elements_amount(eq_net2, {\\\"bus\\\": 5, \\\"load\\\": 3, \\\"sgen\\\": 2, \\\"shunt\\\": 5, \\\"ext_grid\\\": 1,\\n \\\"impedance\\\": 10, cost_type: 3},\\n check_all_pp_elements=True)\\n assert all(eq_net1.sgen.index.values == np.array([0, 1, 2])) # simple create_sgen()\\n # without index=... expected\\n assert all(eq_net2.sgen.index.values == np.array([0, 1]))\\n\\n # --- check poly cost\\n # eq_net1\\n assert np.all(net[cost_type].loc[net[cost_type].et == \\\"ext_grid\\\"].values ==\\n eq_net1[cost_type].loc[eq_net1[cost_type].et == \\\"ext_grid\\\"])\\n for i in range(3):\\n idx_net = net.sgen.sort_values(\\\"p_mw\\\").index[i]\\n idx_eq_net = eq_net1.sgen.sort_values(\\\"p_mw\\\").index[i]\\n assert np.all(net[cost_type].loc[(net[cost_type].element == idx_net) &\\n (net[cost_type].et == \\\"sgen\\\")].drop(\\n columns=[\\\"element\\\"]).values ==\\n eq_net1[cost_type].loc[(eq_net1[cost_type].element == idx_eq_net) &\\n (eq_net1[cost_type].et == \\\"sgen\\\")].drop(\\n columns=[\\\"element\\\"]).values)\\n\\n # eq_net2\\n assert np.all(net[cost_type].loc[net[cost_type].et == \\\"ext_grid\\\"].values ==\\n eq_net2[cost_type].loc[eq_net2[cost_type].et == \\\"ext_grid\\\"])\\n for i in range(2):\\n idx_net = net.sgen.loc[~net.sgen.bus.isin(boundary_buses+internal_buses)].sort_values(\\n \\\"p_mw\\\").index[i]\\n idx_eq_net = eq_net2.sgen.sort_values(\\\"p_mw\\\").index[i]\\n assert np.all(net[cost_type].loc[(net[cost_type].element == idx_net) &\\n (net[cost_type].et == \\\"sgen\\\")].drop(\\n columns=[\\\"element\\\"]).values ==\\n eq_net2[cost_type].loc[(eq_net2[cost_type].element == idx_eq_net) &\\n (eq_net2[cost_type].et == \\\"sgen\\\")].drop(\\n columns=[\\\"element\\\"]).values)\",\n \"def training_batch_selection_affine(train_set_size, input_dims):\\n all_data_indices = np.arange(input_dims[0]*input_dims[1])\\n all_data_indices = all_data_indices.reshape(input_dims)\\n max_misplacement = int(np.floor(get_config()[\\\"expected_max_px_misplacement\\\"]))\\n selection = all_data_indices[max_misplacement:-max_misplacement,\\n max_misplacement:-max_misplacement]\\n selection = selection.reshape(-1)\\n selection = np.random.permutation(selection)\\n selection = selection[:train_set_size]\\n\\n return selection\",\n \"def runRandom(self):\\n \\n # Implementing Random Selection\\n\\n N = self.myDS.shape[0] \\n d = self.myDS.shape[1] \\n self.opt_selected = []\\n total_reward = 0\\n for n in range(0, N):\\n ad = random.randrange(d)\\n self.opt_selected.append(ad)\\n reward = self.myDS.values[n, ad]\\n total_reward = total_reward + reward\\n \\n return total_reward\",\n \"def select_sweepstakes(self):\\n pass\",\n \"def diophantine_subset_sum(number_list, target, time_limit=TIME_LIMIT):\\n started_at = time.time()\\n\\n # Sort numbers list.\\n number_list = sorted(number_list)\\n\\n # Build sums list.\\n sums_list = [number_list[0]]\\n for n in range(1, len(number_list)):\\n sums_list.append(number_list[n] + sums_list[n-1])\\n\\n # Sanity check target.\\n if number_list[0] > target or target > sums_list[-1]:\\n return []\\n\\n # Add first subset to subset stack.\\n subset_stack = [(len(number_list)-1, target, ())]\\n\\n # Process subset stack.\\n while subset_stack:\\n # Enforce time constraint.\\n runtime = time.time() - started_at\\n if runtime > time_limit:\\n raise SummerTimeoutError('No solution found in %d seconds.' % (time_limit))\\n\\n # Pop first subset off queue\\n offset, subtarget, subset = subset_stack.pop()\\n\\n # Keeps only sums less than subset target.\\n sumlist_offset = 0\\n while sums_list[sumlist_offset] < subtarget and sumlist_offset < len(sums_list)-1:\\n sumlist_offset += 1\\n\\n # If next sums list value matches subset target, we have a solution.\\n if sums_list[sumlist_offset] == subtarget:\\n return subset + tuple(number_list[0:sumlist_offset+1])\\n\\n # Keep only numbers in list less than subset target.\\n while number_list[offset] > subtarget and offset > 0:\\n offset = offset - 1\\n\\n # If next number in list matches subset target, we have a solution.\\n if number_list[offset] == subtarget:\\n return subset + tuple([number_list[offset]])\\n\\n # Add subsets to queue for any number list values falling between sums list\\n # offset and numbers list offset\\n step = (sumlist_offset <= offset) and 1 or -1\\n for new_offset in range(sumlist_offset, offset+step, step):\\n\\n new_subset = subset + tuple([number_list[new_offset]])\\n new_subtarget = subtarget - number_list[new_offset]\\n\\n if number_list[0] > new_subtarget:\\n break\\n\\n subset_stack.append((new_offset-1, new_subtarget, new_subset))\\n\\n # Solution not found\\n return []\",\n \"def test_subset_imask_non_iterable_subset(self, model_data, imask_subset_config):\\n foreach = [\\\"nodes\\\", \\\"techs\\\"]\\n imask = _imask_foreach(model_data, foreach)\\n\\n with pytest.raises(TypeError) as excinfo:\\n _subset_imask(\\n \\\"foo\\\", AttrDict({\\\"foreach\\\": foreach, \\\"subset.nodes\\\": \\\"bar\\\"}), imask\\n )\\n assert check_error_or_warning(\\n excinfo,\\n \\\"set `foo` must subset over an iterable, instead got non-iterable `bar` for subset `nodes`\\\",\\n )\",\n \"def scan(\\n self,\\n clean_x: np.ndarray,\\n adv_x: np.ndarray,\\n clean_size: Optional[int] = None,\\n advs_size: Optional[int] = None,\\n run: int = 10,\\n ) -> Tuple[list, list, float]:\\n clean_pvalranges = self.calculate_pvalue_ranges(clean_x)\\n adv_pvalranges = self.calculate_pvalue_ranges(adv_x)\\n\\n clean_scores = []\\n adv_scores = []\\n\\n if clean_size is None and advs_size is None:\\n # Individual scan\\n with tqdm(\\n len(clean_pvalranges) + len(adv_pvalranges), desc=\\\"Subset scanning\\\", disable=not self.verbose\\n ) as pbar:\\n for j, c_p in enumerate(clean_pvalranges):\\n best_score, _, _, _ = Scanner.fgss_individ_for_nets(c_p)\\n clean_scores.append(best_score)\\n pbar.update(1)\\n for j, a_p in enumerate(adv_pvalranges):\\n best_score, _, _, _ = Scanner.fgss_individ_for_nets(a_p)\\n adv_scores.append(best_score)\\n pbar.update(1)\\n\\n else:\\n len_adv_x = len(adv_x)\\n len_clean_x = len(clean_x)\\n\\n for _ in trange(run, desc=\\\"Subset scanning\\\", disable=not self.verbose):\\n np.random.seed()\\n\\n advchoice = np.random.choice(range(len_adv_x), advs_size, replace=False)\\n cleanchoice = np.random.choice(range(len_clean_x), clean_size, replace=False)\\n\\n combined_pvals = np.concatenate((clean_pvalranges[cleanchoice], adv_pvalranges[advchoice]), axis=0)\\n\\n best_score, _, _, _ = Scanner.fgss_for_nets(clean_pvalranges[cleanchoice])\\n clean_scores.append(best_score)\\n best_score, _, _, _ = Scanner.fgss_for_nets(combined_pvals)\\n adv_scores.append(best_score)\\n\\n y_true = np.append([np.ones(len(adv_scores))], [np.zeros(len(clean_scores))])\\n all_scores = np.append([adv_scores], [clean_scores])\\n\\n fpr, tpr, _ = metrics.roc_curve(y_true, all_scores)\\n roc_auc = metrics.auc(fpr, tpr)\\n detectionpower = roc_auc\\n\\n return clean_scores, adv_scores, detectionpower\",\n \"def index_subset(subset, numTestClasses=3, randomSeed=123):\\n print(\\\"datasets.py is ingesting the DF dataset from data/DC.npz\\\")\\n npzfile = np.load(\\\"data/DC.npz\\\", allow_pickle=True)\\n data = npzfile[\\\"data\\\"]\\n labels = npzfile[\\\"labels\\\"]\\n npzfile.close()\\n distinctLabelCount= len(set(labels))\\n \\n #print(\\\"data\\\", data.shape)\\n #print(\\\"labels\\\", labels.shape)\\n #print(\\\"distinctLabelCount\\\", distinctLabelCount)\\n \\n #random.seed(randomSeed)\\n testClasses = random.sample(range(0,distinctLabelCount),numTestClasses)\\n testClasses = [np.float64(i) for i in testClasses]\\n \\n \\n mask = np.isin(labels,testClasses)\\n\\n X_test = data[np.where(mask)]\\n X_train = data[np.where(~mask)]\\n y_test = labels[np.where(mask)]\\n y_train = labels[np.where(~mask)]\\n \\n if subset==\\\"background\\\":\\n print(\\\"Current working directory is \\\", os.getcwd())\\n X = X_train\\n y = y_train\\n print(\\\"DC background data shape\\\", X.shape)\\n elif subset==\\\"evaluation\\\":\\n X = X_test\\n y = y_test\\n print(\\\"DC evaluation data shape\\\", X.shape)\\n images = []\\n \\n #print(\\\"y shape\\\", y.shape)\\n \\n \\n for i in range(y.shape[0]):\\n images.append({\\n 'subset': subset,\\n 'class_name': y[i],\\n 'data': X[i].reshape(1,X[1].shape[0]) # This is the shape needed for Matching Networks\\n #'data': X[i] #.reshape(X[1].shape[0]) # This is the shape needed for MAML\\n })\\n \\n return images\",\n \"def trainNet():\",\n \"def eval(self, dataset, use_subset=False, subset_size=100, verbose=False,\\r\\n nms_thresh=0.45, nms_topk=400, post_nms=100):\\r\\n autograd.set_training(False)\\r\\n # NOTE: multi-gpu is a little bugged\\r\\n if 'cuda' in self.device:\\r\\n if mx.context.num_gpus() > 0:\\r\\n if self.device == 'cuda':\\r\\n ctx = [mx.gpu(0)]\\r\\n else:\\r\\n ctx = [mx.gpu(int(self.device.split(':')[1]))]\\r\\n else:\\r\\n ctx = [mx.cpu()]\\r\\n else:\\r\\n ctx = [mx.cpu()]\\r\\n print(self.device, ctx)\\r\\n\\r\\n with warnings.catch_warnings(record=True):\\r\\n warnings.simplefilter(\\\"always\\\")\\r\\n self._model.initialize()\\r\\n self._model.collect_params().reset_ctx(ctx)\\r\\n self._model.hybridize(static_alloc=True, static_shape=True)\\r\\n self._model.set_nms(nms_thresh=nms_thresh, nms_topk=nms_topk, post_nms=post_nms)\\r\\n\\r\\n dataset, eval_metric = self.__prepare_val_dataset(dataset, data_shape=self.img_size)\\r\\n\\r\\n eval_metric.reset()\\r\\n\\r\\n val_transform = presets.ssd.SSDDefaultValTransform(self.img_size, self.img_size)\\r\\n dataset = dataset.transform(val_transform)\\r\\n\\r\\n val_batchify_fn = Tuple(Stack(), Pad(pad_val=-1))\\r\\n if not use_subset:\\r\\n if verbose:\\r\\n print('Evaluation on entire dataset...')\\r\\n val_loader = gluon.data.DataLoader(\\r\\n dataset, self.batch_size, shuffle=False, batchify_fn=val_batchify_fn, last_batch='keep',\\r\\n num_workers=self.num_workers)\\r\\n else:\\r\\n print('Evaluation on subset of dataset...')\\r\\n val_loader = gluon.data.DataLoader(\\r\\n dataset, self.batch_size, sampler=gluon.data.RandomSampler(subset_size),\\r\\n batchify_fn=val_batchify_fn, last_batch='keep',\\r\\n num_workers=self.num_workers\\r\\n )\\r\\n\\r\\n for batch in tqdm(val_loader, total=len(val_loader)):\\r\\n data = gluon.utils.split_and_load(batch[0], ctx_list=ctx, batch_axis=0, even_split=False)\\r\\n label = gluon.utils.split_and_load(batch[1], ctx_list=ctx, batch_axis=0, even_split=False)\\r\\n det_bboxes = []\\r\\n det_ids = []\\r\\n det_scores = []\\r\\n gt_bboxes = []\\r\\n gt_ids = []\\r\\n gt_difficults = []\\r\\n for x, y in zip(data, label):\\r\\n # get prediction results\\r\\n ids, scores, bboxes = self._model(x)\\r\\n det_ids.append(ids)\\r\\n det_scores.append(scores)\\r\\n # clip to image size\\r\\n det_bboxes.append(bboxes.clip(0, batch[0].shape[2]))\\r\\n # split ground truths\\r\\n gt_ids.append(y.slice_axis(axis=-1, begin=4, end=5))\\r\\n gt_bboxes.append(y.slice_axis(axis=-1, begin=0, end=4))\\r\\n gt_difficults.append(y.slice_axis(axis=-1, begin=5, end=6) if y.shape[-1] > 5 else np.zeros(ids.shape))\\r\\n\\r\\n # update metric\\r\\n eval_metric.update(det_bboxes, det_ids, det_scores, gt_bboxes, gt_ids, gt_difficults)\\r\\n map_name, mean_ap = eval_metric.get()\\r\\n\\r\\n if verbose:\\r\\n val_msg = '\\\\n'.join(['{}={}'.format(k, v) for k, v in zip(map_name, mean_ap)])\\r\\n print(val_msg)\\r\\n eval_dict = {k.lower(): v for k, v in zip(map_name, mean_ap)}\\r\\n return eval_dict\",\n \"def __call__(self, graph: Data, n_min: int, nodes_to_keep: List[int] = None, exhaustive: bool = False):\\n nodes_to_keep = nodes_to_keep if nodes_to_keep is not None else []\\n mcts = self._get_mcts(graph, n_min, nodes_to_keep, exhaustive)\\n\\n for iteration in range(self.m):\\n mcts.search_one_iteration()\\n\\n explanation = mcts.best_leaf_node()\\n\\n return explanation.node_set, mcts\",\n \"def fit(self):\\n if self.minimizer == \\\"differential_evolution\\\":\\n kwargs = {\\\"maxiter\\\": self._maxiter}\\n elif self.minimizer == \\\"shgo\\\":\\n kwargs = {\\\"options\\\": {\\\"maxiter\\\": self._maxiter,\\n \\\"jac\\\": self.cost_func.jac_cost}}\\n elif self.minimizer == \\\"dual_annealing\\\":\\n kwargs = {\\\"maxiter\\\": self._maxiter, \\\"local_search_options\\\": {\\n \\\"jac\\\": self.cost_func.jac_cost}}\\n fun = self.cost_func.eval_cost\\n bounds = self.value_ranges\\n algorithm = getattr(optimize, self.minimizer)\\n result = algorithm(fun, bounds, **kwargs)\\n self._popt = result.x\\n if result.success:\\n self._status = 0\\n elif \\\"Maximum number of iteration\\\" in result.message:\\n self._status = 1\\n else:\\n self._status = 2\",\n \"def sel_sus(fitness, size):\\r\\n # Sort fitness in descending order\\r\\n sorted_fitness, sorted_index = extra.sort_lists(fitness, list(range(len(fitness))), descending=True)\\r\\n # Total fitness\\r\\n total_fitness = sum(sorted_fitness)\\r\\n # Normalize fitness (i.e map fitness values to the interval [0, 1])\\r\\n sorted_fitness[:] /= total_fitness\\r\\n # Distance between the pointers to create\\r\\n distance = 1 / size\\r\\n # Initial pointer start\\r\\n start = random.uniform(0, distance)\\r\\n # Pointers\\r\\n pointers = [start + i * distance for i in range(size)]\\r\\n\\r\\n # Perform selection\\r\\n sel_individuals = []\\r\\n for pointer in pointers:\\r\\n i = 0\\r\\n tmp_sum = sorted_fitness[i]\\r\\n while tmp_sum < pointer:\\r\\n i += 1\\r\\n tmp_sum += sorted_fitness[i]\\r\\n sel_individuals.append(sorted_index[i])\\r\\n\\r\\n return sel_individuals\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE IF YOU WANT TO PRACTICE ***\\\"\\n aStarSearch(problem)\",\n \"def index_subset(subset, numTestClasses=100, randomSeed=123):\\n print(\\\"datasets.py is ingesting the AWF dataset from data/AWF.npz\\\")\\n npzfile = np.load(\\\"data/AWF.npz\\\", allow_pickle=True)\\n data = npzfile[\\\"data\\\"]\\n \\n labels = npzfile[\\\"labels\\\"]\\n \\n print(\\\"The dataset shape is\\\", data.shape)\\n print(\\\"The labels shape is\\\", labels.shape)\\n npzfile.close()\\n distinctLabelCount= len(set(labels))\\n print(\\\"The total labels are\\\", distinctLabelCount)\\n \\n \\n distinctLabels= set(labels)\\n #random.seed(randomSeed)\\n selectedClasses = random.choices(tuple(distinctLabels), k=numTestClasses)\\n \\n \\n dfLabels = pd.DataFrame(labels)\\n mask = dfLabels[0].isin(selectedClasses)\\n \\n X_test = data[np.where(mask)]\\n X_train = data[np.where(~mask)]\\n y_test = labels[np.where(mask)]\\n y_train = labels[np.where(~mask)]\\n \\n if subset==\\\"background\\\":\\n print(\\\"\\\\nCurrent working directory is \\\", os.getcwd())\\n print(\\\"\\\\n\\\\n________________________________\\\")\\n print(\\\"Assembling the training dataset\\\")\\n print(\\\"________________________________\\\")\\n X = X_train\\n y = y_train\\n print(\\\"\\\\n\\\\nAWF X_train data shape\\\", X.shape)\\n print(\\\"AWF y_train data shape\\\", y.shape)\\n \\n elif subset==\\\"evaluation\\\":\\n print(\\\"\\\\n\\\\n________________________________\\\")\\n print(\\\"Assembling the test dataset\\\")\\n print(\\\"________________________________\\\") \\n print(\\\"\\\\nThe number of test classes is:\\\", len(selectedClasses))\\n print(\\\"\\\\n\\\\nThe test classes are:\\\\n\\\\n\\\", selectedClasses)\\n \\n X = X_test\\n y = y_test\\n print(\\\"\\\\n\\\\nAWF X_test data shape\\\", X.shape)\\n print(\\\"AWF y_test data shape\\\", y.shape)\\n images = []\\n \\n #print(\\\"y shape\\\", y.shape)\\n \\n \\n for i in range(y.shape[0]):\\n images.append({\\n 'subset': subset,\\n 'class_name': y[i],\\n 'data': X[i].reshape(1,X[1].shape[0]) # This is the shape needed for Matching Networks\\n #'data': X[i] #.reshape(X[1].shape[0]) # This is the shape needed for MAML\\n })\\n \\n return images\",\n \"def filter_by_subset(self, *args):\\n self.subset_labels = sorted(set(self.subset_labels + list(args)))\\n return self\",\n \"def index_subset(subset, numTestClasses=33, randomSeed=123):\\n print(\\\"datasets.py is ingesting the DF dataset from data/DF.npz\\\")\\n npzfile = np.load(\\\"data/DF.npz\\\", allow_pickle=True)\\n data = npzfile[\\\"data\\\"]\\n labels = npzfile[\\\"labels\\\"]\\n npzfile.close()\\n distinctLabelCount= len(set(labels))\\n \\n print(\\\"\\\\ndata\\\", data.shape)\\n print(\\\"labels\\\", labels.shape)\\n print(\\\"Total distinct class labels in the DF.npz dataset: \\\", distinctLabelCount)\\n \\n #random.seed(randomSeed)\\n testClasses = random.sample(range(0,distinctLabelCount),numTestClasses)\\n testClasses = [np.float64(i) for i in testClasses]\\n \\n \\n mask = np.isin(labels,testClasses)\\n\\n X_test = data[np.where(mask)]\\n X_train = data[np.where(~mask)]\\n y_test = labels[np.where(mask)]\\n y_train = labels[np.where(~mask)]\\n \\n if subset==\\\"background\\\":\\n print(\\\"Current working directory is \\\", os.getcwd())\\n X = X_train\\n y = y_train\\n print(\\\"DF background data shape\\\", X.shape)\\n elif subset==\\\"evaluation\\\":\\n X = X_test\\n y = y_test\\n print(\\\"DF evaluation data shape\\\", X.shape)\\n images = []\\n \\n #print(\\\"y shape\\\", y.shape)\\n \\n \\n for i in range(y.shape[0]):\\n images.append({\\n 'subset': subset,\\n 'class_name': y[i],\\n 'data': X[i].reshape(1,X[1].shape[0]) # This is the shape needed for Matching Networks\\n #'data': X[i] #.reshape(X[1].shape[0]) # This is the shape needed for MAML\\n })\\n \\n return images\",\n \"def select(self):\\n\\t\\tbest_num_components = self.n_constant\\n\\t\\treturn self.base_model(best_num_components)\",\n \"def select(self):\\n\\t\\twarnings.filterwarnings(\\\"ignore\\\", category=DeprecationWarning)\\n\\t\\tscore_best = float(\\\"inf\\\")\\n\\t\\tbest_model = None\\n\\t\\tfor numStates in range(self.min_n_components, self.max_n_components + 1):\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tmodel = self.base_model(numStates)\\n\\t\\t\\t\\tlog_l = model.score(self.X, self.lengths)\\n\\t\\t\\t\\tp = numStates\\n\\t\\t\\t\\tlog_n = np.log(len(self.lengths))\\n\\t\\t\\t\\tscore = -2 * log_l + p * log_n\\n\\t\\t\\t\\tif score < score_best:\\n\\t\\t\\t\\t\\tscore_best = score\\n\\t\\t\\t\\t\\tbest_model = model\\n\\t\\t\\texcept Exception as e:\\n\\t\\t\\t\\tpass\\n\\n\\t\\twhile best_model is None:\\n\\t\\t\\tbest_model = self.base_model(np.random.randint(self.min_n_components, self.max_n_components + 1))\\n\\n\\t\\treturn best_model\",\n \"def get_optimal_submesh_assignments(\\n best_n_stages, F_argmin, n_devices, n_ops, submesh_sizes\\n):\\n current_s = best_n_stages\\n current_layer = 0\\n current_devices = n_devices\\n\\n optimal_layer_submesh_assignments = []\\n while current_s > 0 and current_layer < n_ops and current_devices > 0:\\n next_start_layer, submesh_shape_idx, sharding_config_idx = F_argmin[\\n current_s, current_layer, current_devices\\n ]\\n assert next_start_layer != -1 and current_devices != -1\\n optimal_layer_submesh_assignments.append(\\n ((current_layer, next_start_layer), submesh_shape_idx, sharding_config_idx)\\n )\\n current_s -= 1\\n current_layer = next_start_layer\\n current_devices -= submesh_sizes[submesh_shape_idx]\\n\\n assert current_s == 0 and current_layer == n_ops and current_devices == 0\\n\\n return optimal_layer_submesh_assignments\",\n \"def test_non_it(self):\\n self.idx = [9, 11, 6, 10, 12, 2, 8, 1, 5, 0, 7, 4, 3]\\n selector = PCovCUR(n_to_select=12, iterative=False)\\n selector.fit(self.X, self.y)\\n\\n self.assertTrue(np.allclose(selector.selected_idx_, self.idx[:-1]))\",\n \"def nn(data):\\n training_set = SupervisedDataSet*\\n\\n\\n input_nodes = 3\\n hidden_layer_1 = 10\\n hidden_layer_2 = 10\\n output_layer = 5\\n\\n net = buildNetwork(input_nodes, hidden_layer_1, hidden_layer_2, output_layer, bias=True, hiddenclass=TanhLayer)\",\n \"def selectFeatures(k_features=5, *args):\\n X, y = args\\n skb = SelectKBest(k=k_features)\\n return skb.fit_transform(X, y)\",\n \"def select_candidates(self, X, y, candidate_mask, train_mask):\\n\\n return self.best_heuristic(X=X, y=y, candidate_mask=candidate_mask,\\n train_mask=train_mask, classifier=self.classifier,\\n n_candidates=self.n_candidates, random_state=self.pool_rng.randint(1000),\\n **self.h_kwargs)\",\n \"def get_pool_subset(X_pool, Y_pool, subset_size=2000):\\n subset_indices = np.asarray(random.sample(range(0,X_pool.shape[0]), subset_size))\\n X_pool_subset = X_pool[subset_indices]\\n Y_pool_subset = Y_pool[subset_indices]\\n X_pool = np.delete(X_pool, subset_indices, axis=0)\\n Y_pool = np.delete(Y_pool, subset_indices, axis=0)\\n return (X_pool, Y_pool), (X_pool_subset, Y_pool_subset)\",\n \"def select(self):\\n warnings.filterwarnings(\\\"ignore\\\", category=DeprecationWarning)\\n\\n best_bic_score = float(\\\"inf\\\")\\n best_model = self.base_model(self.n_constant)\\n for n in range(self.min_n_components, self.max_n_components + 1):\\n try:\\n # bic = - 2*log(likelihood) + p*log(N)\\n # N is number of data points\\n # p => number of parameters\\n # p = initial state occupation probabilities\\n # + transition probabilities\\n # + emission probabilities\\n # initial state occupation probabilities, can be obtained from n,\\n # as the probabilities add up to 1.0 => initial state occupation probabilities = n - 1\\n # transition probabilities => n*(n - 1)\\n # emission probabilities => n * num_features * 2 = num_means + num_covar\\n # Hence, p = n - 1 + n*(n - 1) + 2* n * num_features\\n # p = n*n + 2*n*num_features - 1\\n\\n model = self.base_model(n)\\n log_likelihood = model.score(self.X, self.lengths)\\n num_features = len(self.X[0])\\n log_n = math.log(self.X.shape[0])\\n\\n p = n*n + 2*n*num_features - 1\\n bic = -2 * log_likelihood + p * log_n\\n if bic < best_bic_score:\\n best_bic_score = bic\\n best_model = model\\n except:\\n continue\\n\\n return best_model\",\n \"def negSamplingCostAndGradient(predicted, target, outputVectors, dataset,\\n K=10):\\n\\n # Sampling of indices is done for you. Do not modify this if you\\n # wish to match the autograder and receive points!\\n indices = [target]\\n indices.extend(getNegativeSamples(target, dataset, K))\\n\\n ### YOUR CODE HERE\\n # Similar to softmax, we find the target matrix\\n # v_c structured as 1xD matrix\\n # u_o assume to be 1xD matrix\\n # u_k assume to be K x D matrix\\n # we pull the data assuming that each row represent one vector\\n v_c = predicted\\n u_o = outputVectors[target]\\n u_k = outputVectors[indices]\\n\\n\\n # The intermediary matrix outputs\\n # z_o, h_o: single scalar number\\n # z_k, h_k: K x 1 vector, wich each number associated with a neg sample\\n z_o = np.dot(u_o, v_c)\\n h_o = sigmoid(z_o)\\n z_k = np.dot(u_k, v_c)\\n h_k = sigmoid( - z_k)\\n\\n J_1 = - np.log(h_o)\\n J_2 = - np.sum( np.log(h_k) )\\n cost = J_1+ J_2\\n\\n # Return the gradient for the prediction function\\n # the prediction vector interacts with both the predicted vector\\n # the negative sample vectors so below are both parts of the gradient\\n # here we are trying to increase the prediction matrix to maximize\\n # the similarity with the predicted vector\\n # output is a 1 x D matrix\\n grad_pred_o = - (1 - h_o)*u_o\\n\\n # the second part is tyring to decrease\\n # similarity with the negative sample vectors\\n # K x 1 multiply be input is a k x D matrix, we will need to sum all negative samples\\n # along the rows. output is a 1 x D matrix\\n # reshape h_k so that it can multiple\\n grad_pred_k = np.dot(( 1 - h_k).T, u_k)\\n # find the predicted matrix gradient\\n # output is a 1 x D matrix\\n gradPred = grad_pred_o + grad_pred_k\\n\\n\\n # Return the gradient of the output vector\\n # create a matrix the same shape as outputVector\\n grad = np.zeros(outputVectors.shape)\\n # first find the gradient wrt to the target output vector\\n # here we want to increase the similarity between\\n # the target output vector and the center vector\\n # outputs is a 1 x D matrix\\n grad_u_o = - (1-h_o)*v_c\\n\\n # print('***************grad_u_o************')\\n # print(grad_u_o)\\n # print(grad_u_o.shape)\\n # replace the target row in output vector gradient\\n grad[target, ] = grad_u_o\\n # then find the gradient descent of all the u_k matrices\\n # K x 1 matrix multiply by 1 x 3\\n # K x D\\n grad_uk = - np.outer((h_k - 1), v_c)\\n # print('***************grad_uk************')\\n # print(grad_uk)\\n # for each token (row) replace gradient\\n for k in xrange(u_k.shape[0]):\\n index = indices[k]\\n grad[index] += grad_uk[k]\\n\\n ### END YOUR CODE\\n return cost, gradPred, grad\",\n \"def selection(population: list, weights: list):\\n\\n new_population = list()\\n\\n for individual in population:\\n new_population.append(individual[1])\\n\\n individuals = choices(new_population, weights=weights, k=2)\\n\\n return individuals[0], individuals[1]\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n util.raiseNotDefined()\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n util.raiseNotDefined()\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n util.raiseNotDefined()\",\n \"def slice(self, evidence={}):\\n return self.condition(evidence)\\n \\n \\n\\n# def eliminate(self, elimVars, elimOp):\\n # TODO: awkward way to define this; convert to more direct implementation?\\n for v in elimVars:\\n if len(self.markovBlanket(v)) > 2: raise ValueError(\\\"Cannot eliminate {} with {} (>2) neighbors\\\".format(v,len(self.markovBlanket(v))))\\n flist = self.factorsWith(v)\\n gm_model = GraphModel(flist); print(gm_model); gm_model.eliminate([v],elimOp)\\n fnew = gm_model.factors[0]\\n self.removeFactors(flist); # doesn't quite work? numerical roundoff issues?\\n self.L[v,:] = 0; self.L[:,v] = 0; self.h[v] = 0; # TODO: better to mark as removed? how?\\n self.addFactors([fnew])\\n # TODO: \\\"remove\\\" variable by setting states = 0? \\\"known value\\\" = 0?\",\n \"def check_subset(P1,P2,k=-1):\",\n \"def main():\\n create_sets()\\n optimal_weights = genetic_algorithm()\\n obtain_best_model(optimal_weights)\",\n \"def get_umap_subsets(self, nn=100, md=0.1, **kwargs):\\n # First get umap results:\\n results = Table.read(\\\"../data/dimred_results/apogee_rc_dimred_hyperparametertest.fits\\\")\\n self.Xu = results[\\\"X_umap_euclidean_nn\\\"+str(nn) + \\\"_md\\\"+str(md)]\\n self.Yu = results[\\\"Y_umap_euclidean_nn\\\"+str(nn) + \\\"_md\\\"+str(md)]\\n \\n # Now run HDBSCAN to define the subsets\\n import hdbscan\\n clusterer = hdbscan.HDBSCAN(**kwargs)\\n clusterer.fit( np.vstack((self.Xu, self.Yu)).T )\\n self.classcol = clusterer.labels_\\n self.classprob= clusterer.probabilities_\\n self.subsets = np.unique(clusterer.labels_)\\n #self.classcol= np.char.rstrip(self.data[\\\"tsne_class_teffcut40\\\"],b' ')#.decode('utf8').strip()\\n #self.subsets = [\\\"thin\\\", \\\"thick1\\\", \\\"thick2\\\", \\\"thick3\\\", \\\"thick4\\\",\\n # \\\"mpthin\\\", \\\"mpthintrans\\\", \\\"smr\\\", \\\"t4trans\\\", \\\"youngthin\\\",\\n # \\\"debris1\\\", \\\"debris2\\\", \\\"debris3\\\", \\\"debris4\\\", \\\"debris5\\\", \\n # \\\"smr2\\\", \\\"t2trans1\\\", \\\"highTi\\\",\\\"lowMg\\\",\\\"highAlMg?\\\"]\\n self.names = [\\\"\\\", \\\"\\\", \\\"\\\", \\\"\\\",\\n \\\"\\\", \\\"\\\", \\\"Transition group\\\", \\\"\\\", \\\"\\\",\\n \\\"Young local disc\\\", \\\"\\\", \\\"\\\", \\\"[s/Fe]-enhanced\\\", \\\"\\\", \\\"\\\", r\\\"\\\", \\\"Debris candidate\\\", \\n r\\\"Extreme-Ti star\\\", r\\\"Low-[Mg/Fe] star\\\", \\\"High-[Al/Mg] star\\\"]\\n self.Xcoords = [10, 11, 4.5, -12, 18, -31, 22, 26,-22.5, -14, -2, -25]\\n self.Ycoords = [5.5,.5, -2, -4, 6, 0, 1.5, -.5, -7, -2, -6, 14]\\n self.fsize = [20 , 16, 12, 12, 15, 13, 11, 11, 11, 11, 11, 11]\\n self.sym = [\\\"o\\\", \\\"v\\\", \\\"^\\\", \\\">\\\", \\\"<\\\", \\\"s\\\", \\\"o\\\", \\\"*\\\", \\\"<\\\", \\\"o\\\",\\n \\\"h\\\", \\\"d\\\", \\\"D\\\", \\\"v\\\", \\\"p\\\", \\\"*\\\", \\\"D\\\", \\\"p\\\", \\\"s\\\", \\\"8\\\"]\\n self.al = [.6, .8, .8, .8, .8, .8, .8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]\\n self.lw = [0,.5,.5,.5, .5, .5, .5, .5, .5, .5, .5, .5, .5, .5, .5, .5, .5, .5, .5, .5, .5]\\n self.size= [7,12,12,12,12,15,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18,18]\\n self.col = [\\\"grey\\\", \\\"m\\\", \\\"hotpink\\\", \\\"crimson\\\", \\\"r\\\",\\n \\\"g\\\", \\\"brown\\\", \\\"orange\\\", \\\"gold\\\", \\\"k\\\",\\n \\\"yellow\\\", \\n \\\"gold\\\", \\\"lime\\\", \\\"k\\\", \\\"royalblue\\\"]\",\n \"def selection(self):\\n\\n for i in range(self.pop_num*3): # It is important. Next, we will rank the array of parents and children in ascending order of survivability (sum (fit)).\\n self.par_and_sons[i].fit = SimpleSegmentationGA.fitness_function(self.gray, self.delta_x, self.length, self.par_and_sons[i].A)\\n\\n # Sort.\\n self.par_and_sons = sorted(self.par_and_sons, key=lambda individ: individ.fit) \\n self.population=self.par_and_sons[:self.pop_num].copy()\",\n \"def get_selected_subsamples(sample_func, clusters, trajs_dict, visit_profile, Nsample, false_rate=80):\\n print('The desired false rate is %f'%(false_rate/Nsample))\\n crter = 0\\n done_first_round = False\\n nclusters = len(clusters)\\n \\n print('Start the first selection until the number of potential profiles is more than Nsample')\\n while crter < Nsample:\\n i = np.random.choice(range(nclusters))\\n if len(clusters[i]) > Nsample*5 or len(clusters[i]) < Nsample: continue\\n # try sampling\\n selected_spl, plist_spl = sample_func(trajs_dict, plist=None, usrs=clusters[i])\\n # do the deterministic attack\\n a2 = get_trick_mat(clusters[i] , selected_spl, visit_profile)\\n nonzero_list = [np.sum(np.count_nonzero(ai))>=1 for ai in make_sym_mat(a2)] \\n crter = np.sum(nonzero_list)\\n \\n print('Finish the first round selection, %d candidates are selected from cluster %d'%(crter, i))\\n round_one_usrs = np.array(clusters[i])[nonzero_list]\\n \\n crter2 = 0; len_rone = len(round_one_usrs)\\n print('Start the second selection until false rate %f'%(false_rate/Nsample))\\n while crter2 < false_rate:\\n final_selected_usrs = round_one_usrs[np.random.choice(len_rone, Nsample, replace=False)]\\n tmp = get_trick_mat(final_selected_usrs, selected_spl, visit_profile)\\n crter2 = np.sum([np.sum(np.count_nonzero(ai))>=1 for ai in make_sym_mat(tmp)])\\n print('Final false rate for deterministic attack%f'%(crter2/Nsample))\\n return selected_spl, final_selected_usrs, plist_spl\",\n \"def cost(self, output, labels, weights):\\n raise NotImplementedError('Must be overridden by concrete subclass')\",\n \"def reduced_cost(data, indexing, cf, cf_prime, v, k, uw_sample_count=None):\\n # copy indexing and move v to k\\n cpy = indexing.copy()\\n cpy[v] = k\\n vs = np.arange(data.shape[0])\\n points = None\\n if uw_sample_count is None:\\n # compute all possible 3-ary subsets that contain v\\n points = np.array(np.meshgrid(v,vs,vs)).T.reshape(-1,3)\\n points = points[ (points[:,0] != points[:,1]) & \\n (points[:,0] != points[:,2]) & \\n (points[:,1] < points[:,2]) ]\\n else:\\n # sample 3-ary subsets that contain v\\n pointsv = np.ones((uw_sample_count,1), dtype=np.int)*v\\n allowed = np.arange(indexing.shape[0])[np.arange(indexing.shape[0]) != v]\\n pointsuw = sample_noreplace(allowed, uw_sample_count, 2)\\n points = np.concatenate((pointsv, pointsuw), axis=1)\\n # the result is the difference between the original indexing\\n # and the indexing after the move-operation\\n result = (partial_cost(data, indexing, points, cf, cf_prime) -\\n partial_cost(data, cpy, points, cf, cf_prime))\\n return result\",\n \"def nonlocality_test(self, \\n source: str = 'meas', \\n rows: Optional[Sequence[int]] = None, \\n nosignaling: bool = False,\\n min_size: Optional[Union[int, Sequence[int]]] = None, \\n max_size: Optional[int] = None, \\n step: Optional[int] = None, \\n progressbar: bool = False):\\n \\n (rows, min_size, max_size, step, subset) = self.__handle_args(\\n source=source, rows=rows, nosignaling=nosignaling, \\n min_size=min_size, max_size=max_size, step=step)\\n \\n self.new_LP('feasibility') \\n \\n subset_size = len(subset)\\n if subset_size > 0: \\n for row in subset: \\n rows.remove(row) \\n self.populate_LP('feasibility', source, subset)\\n \\n if progressbar: \\n pbar = tqdm(initial=0, total=max_size) \\n for size in itertools.chain(range(min_size, max_size, step), [max_size]):\\n \\n new_rows = []\\n \\n if not nosignaling:\\n for new in range(size - subset_size):\\n new_rows.append(rows.pop(np.random.randint(len(rows)))) \\n else:\\n while len(new_rows) < size - subset_size and rows:\\n new = rows.pop(np.random.randint(len(rows)))\\n if self.get_nonredundant(new): new_rows.append(new)\\n \\n if new_rows:\\n subset_size += len(new_rows)\\n self.populate_LP('feasibility', source, new_rows)\\n\\n self.LP.solve() \\n\\n status = self.LP.solution.get_status_string()\\n NL = True if status=='infeasible' else (\\n False if status=='optimal' else status)\\n \\n if progressbar:\\n pbar.update(subset_size - pbar.n)\\n pbar.set_description_str(desc=str(NL), refresh=True)\\n if NL or not rows: \\n break\\n\\n return NL\",\n \"def get_obj_new(model_old, demand_path, slink_dict, demand_dict, w_a, w_b, theta, s_limit):\\n model = copy.deepcopy(model_old)\\n \\n #cpu_vector = model.cost_dict['cpu']\\n dist_matrix = model.cost_dict['dist']\\n rtt_matrix = model.cost_dict['rtt']\\n #bw_matrix = model.cost_dict['bw']\\n w_a1, w_a2 = w_a\\n w_b1, w_b2 = w_b\\n theta1, theta2, theta3 = theta\\n # find total capacity and used bw on substrate nodes\\n node_port_list, used_bw_list = total_port(model)\\n #print \\\"CHECK POINT-1\\\", used_bw_list, node_port_list\\n vnet_info = model.get_vnet_info()\\n infeasible = 0\\n\\n fail_nodes = model.failed_dict\\n start_time = time.time()\\n select_dict, slink_dict = find_standby2(model, s_limit, w_a, w_b, theta, demand_path, demand_dict, slink_dict)\\n # random selection\\n #select_dict, slink_dict = find_random(model, s_limit, w_a, w_b, theta, demand_path, demand_dict, slink_dict)\\n #print \\\"selection takes: \\\", time.time() - start_time\\n #print \\\"Selected\\\", select_dict\\n sum_cost_1_2 = 0\\n r_list = {}\\n \\n for node_id in range(0,len(used_bw_list)):\\n r_list[node_id] = used_bw_list[node_id]/node_port_list[node_id]\\n #print \\\"INITIAL\\\", r_list\\n svr_subset = {}\\n for vnet in model.vnets:\\n j = vnet.vnet_id\\n f = fail_nodes[j]\\n # only count the failed virtual network\\n if f == -1:\\n pass\\n else:\\n for node_id in vnet_info[j]['standby']:\\n svr_subset[node_id] = r_list[node_id]\\n #print \\\"Subset SVR: \\\", svr_subset\\n \\n if j in select_dict:\\n #print \\\"FEASIBLE FOUND\\\"\\n #print vnet_info[j]['standby']\\n i = select_dict[j]\\n failed_node = vnet.vnodes[f]\\n vneighbors = failed_node.vneighbors\\n for k in vneighbors: \\n eta = operation_cost()\\n #print \\\"a1: \\\", w_a1, \\\"a2: \\\", w_a2, \\\"b1: \\\", w_b1, \\\"b2: \\\", w_b2\\n dist_c = dist_cost(i, f, k, dist_matrix, w_a1, w_a2)\\n rtt_c = rtt_cost(i, k, rtt_matrix)\\n sigma = connect_cost(dist_c, rtt_c, w_b1, w_b2)\\n sum_cost_1_2 += theta1 * eta + theta2 * sigma\\n #find residual bw on substrate node\\n #xi = resource_cost(bw_matrix, i)\\n req_bw = sum(failed_node.neighbor_traffic.values())\\n #util = req_bw / xi\\n #print req_bw, i, used_bw_list[i], node_port_list[i]\\n util = req_bw/node_port_list[i]\\n \\n if i not in r_list:\\n r_list[i] = util #+ used_bw_list[i]/node_port_list[i]\\n else:\\n r_list[i] += util\\n svr_subset[i] = r_list[i]\\n #print sigma, \\\" v_\\\" + str(vnet.vnet_id) + \\\"_\\\" + str(f) + \\\"_\\\" + str(i) + \\\"_\\\" + str(k) + \\\"_\\\" + str(k)\\n else:\\n print \\\"INFEASIBLE at vnet: \\\", j\\n infeasible = 1\\n #print \\\"DONE\\\"\\n \\n if infeasible == 0:\\n #print svr_subset\\n max_util = max(svr_subset.values())\\n obj = sum_cost_1_2 + theta3 * max_util\\n else:\\n obj = \\\"infeasible\\\"\\n max_util = \\\"none\\\"\\n #print obj\\n used_time = time.time() - start_time\\n return obj, select_dict, max_util, used_time\",\n \"def evaluation(x_selected, y, state_of_art=False):\\n # check_number_of_clusters(X_selected)\\n # n_clusters = best_number_of_clusters\\n\\n y_true = np.asarray(y)\\n\\n if state_of_art:\\n avg_sil, model = get_results(x_selected, [max(y_true)])\\n else:\\n avg_sil, model = get_results(x_selected)\\n\\n # using GPU\\n #avg_sil, model = get_results_from_GPU(x_selected)\\n\\n \\\"\\\"\\\" VALID DISTANCES METRICS\\n 'euclidean', 'l2', 'l1', 'manhattan', 'cityblock',\\n 'braycurtis', 'canberra', 'chebyshev', 'correlation',\\n 'cosine', 'dice', 'hamming', 'jaccard', 'kulsinski',\\n 'mahalanobis', 'matching', 'minkowski', 'rogerstanimoto',\\n 'russellrao', 'seuclidean', 'sokalmichener',\\n 'sokalsneath', 'sqeuclidean', 'yule', \\\"wminkowski\\\"\\n \\n max([\\n metrics.silhouette_score(x_selected, model.labels_, metric='euclidean'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='cosine'),\\n\\n metrics.silhouette_score(x_selected, model.labels_, metric='manhattan'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='braycurtis'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='canberra'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='chebyshev'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='hamming'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='jaccard'),\\n\\n metrics.silhouette_score(x_selected, model.labels_, metric='russellrao'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='sokalsneath'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='yule'),\\n\\n metrics.silhouette_score(x_selected, model.labels_, metric='kulsinski'),\\n metrics.silhouette_score(x_selected, model.labels_, metric='cityblock')\\n ])\\\"\\\"\\\"\\n\\n y_predict = model.labels_\\n\\n for i in range(0, len(y_predict)):\\n y_predict[i] = y_predict[i] + 1\\n\\n # inercia = k_means.inertia_\\n inertia = model.inertia_\\n\\n # calculate NMI\\n nmi = v_measure_score(y_true, y_predict)\\n # nmi = 0\\n\\n # calculate corrected rand\\n corrected_rand = adjusted_rand_score(y_true, y_predict)\\n # corrected_rand = 0\\n\\n # calculate f-measure\\n f_measure = f1_score(y_true, y_predict, average='micro')\\n\\n # calculate ACC\\n\\n label1 = np.unique(y_true)\\n label2 = np.unique(y_predict)\\n if len(label1) == len(label2):\\n y_permuted_predict = best_map(y_true, y_predict)\\n acc = accuracy_score(y_true, y_permuted_predict)\\n else:\\n acc = 0\\n\\n logger.log(\\\"KMeans model has\\\"\\n \\\" avg_sil = \\\" + str(avg_sil) +\\n \\\" and NMI = \\\" + str(nmi) +\\n \\\" and CR = \\\" + str(corrected_rand) +\\n \\\" and f-measure = \\\" + str(f_measure), True)\\n\\n # calculate cluster.stats\\n # dgene = stats.dist(x_selected, method='euclidean')\\n\\n \\\"\\\"\\\" fpc_result = fpc.cluster_stats(dgene,\\n model.labels_,\\n G2=False,\\n G3=False,\\n silhouette=True,\\n sepwithnoise=True,\\n noisecluster=True,\\n wgap=True)\\n\\n stats_fpc = pandas2ri.ri2py(fpc_result)\\\"\\\"\\\"\\n\\n # Compute Hopkins statistic for iris dataset\\n # nrow = X_selected.shape[0]\\n # res = factoextra.get_clust_tendency(X_selected, n=nrow - 1, graph=False)\\n # print(\\\"hopkins test: \\\"+ str(res[0]))\\n # hopkins_test = res\\n\\n # dunn = stats_fpc[24][0]\\n # dunn2 = stats_fpc[25][0]\\n # entropy = stats_fpc[26][0]\\n # ch = stats_fpc[28][0]\\n\\n dunn = 0\\n dunn2 = 0\\n entropy = 0\\n ch = 0\\n\\n # inertia, avg_sil, dunn, dunn2, entropy, ch, nmi, acc, corrected_rand, f_measure\\n return ClusteringResults(max(y_predict), inertia, avg_sil, dunn, dunn2, entropy, ch, nmi, acc, corrected_rand, f_measure)\",\n \"def test_subset_classification(p_df_subset, p_weather):\\n X = p_df_subset.drop(\\\"Direction\\\", axis=1)\\n y = p_df_subset[\\\"Direction\\\"]\\n print(\\\"Scale Data...\\\")\\n scaler = StandardScaler()\\n X_scaled_train = scaler.fit_transform(X)\\n print(\\\"Do PCA...\\\")\\n pca = PCA(n_components=15)\\n pca.fit(X_scaled_train)\\n X_train_transformed = pca.transform(X_scaled_train)\\n # Read Models\\n dummy = io.read_object(\\\"Dummy_classifier_model\\\"+p_weather+\\\".pkl\\\")\\n clf = io.read_object(\\\"KNearestNeighbours_classifier_model\\\"+p_weather+\\\".pkl\\\")\\n # Predict\\n print(\\\"Predict...\\\")\\n dummy_y_prediction = dummy.predict(X_train_transformed)\\n kn_y_prediction = clf.predict(X_train_transformed)\\n # Evaluate Predict\\n prediction.evaluate.direction_error_metrics(y, dummy_y_prediction, \\\"Dummy_Classifier\\\"+p_weather, \\\"Testing\\\")\\n prediction.evaluate.direction_error_metrics(y, kn_y_prediction, \\\"KNeighbors_Classifier\\\"+p_weather, \\\"Testing\\\")\",\n \"def subset_number_to_subset(\\n set_size: int,\\n subset_size: int,\\n subset_number: int,\\n order_matters: bool = False,\\n can_reselect: bool = False\\n) -> List[int]:\\n # Sets can't have negative size\\n if set_size < 0:\\n raise ArithmeticError(f\\\"Can't have a set of {set_size} items\\\")\\n if subset_size < 0:\\n raise ArithmeticError(f\\\"Can't have a subset of {subset_size} items\\\")\\n\\n # Start with the empty set\\n subset = []\\n\\n # The empty set is the only possible subset of size 0, so return it\\n if subset_size == 0:\\n # Subset number should be 0 for a subset size of 0\\n if subset_number != 0:\\n raise ArithmeticError(\\n f\\\"0 is the only valid subset number for subsets of size 0, got {subset_number}\\\"\\n )\\n\\n return subset\\n\\n # If there are no items to select from, the empty set is the only possible selection,\\n # so any subsets of greater size are impossible\\n if set_size == 0:\\n raise ArithmeticError(\\n f\\\"Can't select a non-empty subset (subset size = {subset_size}) from the empty set\\\"\\n )\\n\\n # Special case for order-dependent\\n if order_matters:\\n # Ordered with reselection is shift-encoded, so simply shift-decode\\n if can_reselect:\\n while len(subset) < subset_size:\\n subset.append(subset_number % set_size)\\n subset_number //= set_size\\n\\n # Without reselection, the items available for selection reduces by 1 at each iteration\\n else:\\n factor = set_size - subset_size + 1\\n while len(subset) < subset_size:\\n next = subset_number % factor\\n subset_number //= factor\\n for index in range(len(subset)):\\n if subset[index] >= next:\\n subset[index] += 1\\n subset.insert(0, next)\\n factor += 1\\n\\n return subset\\n\\n # If reselect is allowed, we are expecting the equivalent binomial representation of the selection\\n if can_reselect:\\n set_size += subset_size - 1\\n subset_size = set_size - subset_size\\n\\n # Decode the arithmetic encoding of the binomial representation\\n num_subsets = number_of_subsets(set_size - 1, subset_size)\\n k = subset_size\\n for n in reversed(range(set_size)):\\n if subset_number >= num_subsets:\\n subset_number -= num_subsets\\n subset.append(n)\\n if len(subset) == subset_size:\\n break\\n num_subsets = num_subsets * k // n\\n k -= 1\\n elif n != 0:\\n num_subsets = num_subsets * (n - k) // n\\n\\n # Convert the binomial representation back to the original multinomial one if reselection was enabled\\n if can_reselect:\\n subset.sort()\\n subset_size = set_size - subset_size\\n set_size -= subset_size - 1\\n counts = {}\\n total = 0\\n for i in range(set_size - 1):\\n last = -1 if i == 0 else subset[i - 1]\\n count = subset[i] - last - 1\\n total += count\\n if count != 0:\\n counts[i] = count\\n if total < subset_size:\\n counts[set_size - 1] = subset_size - total\\n subset = []\\n for value, count in counts.items():\\n for i in range(count):\\n subset.append(value)\\n\\n return subset\",\n \"def select_fits_subset(self, pre_processing=None, binning=None,\\n exposure=(None, 'max'), reduction=None,\\n observatory=None, jd=(None, 'exact')):\\n self.data_subset = self.all_data.copy()\\n\\n # Select on pre-processing if provided.\\n if pre_processing:\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['PreProcessing'] == pre_processing]\\n\\n # Select on binning if provided.\\n if binning:\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['Binning'] == binning]\\n\\n # Select on exposure if provided.\\n if exposure[0]:\\n if exposure[1] == 'exact':\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['Exposure'] == exposure[0]]\\n elif exposure[1] == 'min':\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['Exposure'] > exposure[0]]\\n elif exposure[1] == 'max':\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['Exposure'] < exposure[0]]\\n elif exposure[1] == 'between':\\n self.data_subset = self.data_subset.loc[\\n (self.data_subset['Exposure'] > exposure[0][0]) &\\n (self.data_subset['Exposure'] < exposure[0][1])]\\n\\n # Select on reduction if provided.\\n if reduction:\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['Reduction'] == reduction]\\n\\n # Select on observatory if provided.\\n if observatory:\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['Observatory'] == observatory]\\n\\n # Select on jd if provided.\\n if jd[0]:\\n if jd[1] == 'exact':\\n if isinstance(jd[0], list):\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['JD'].isin(jd[0])]\\n else:\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['JD'] == jd[0]]\\n elif jd[1] == 'except':\\n if isinstance(jd[0], list):\\n self.data_subset = self.data_subset.drop(\\n self.data_subset[self.data_subset[\\n 'JD'].isin(jd[0])].index)\\n else:\\n self.data_subset = self.data_subset.drop(\\n self.data_subset[self.data_subset['JD']\\n == jd[0]].index)\\n elif jd[1] == 'after':\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['JD'] > jd[0]]\\n elif jd[1] == 'before':\\n self.data_subset = self.data_subset.loc[\\n self.data_subset['JD'] < jd[0]]\\n elif jd[1] == 'between':\\n self.data_subset = self.data_subset.loc[\\n (self.data_subset['JD'] > jd[0][0]) &\\n (self.data_subset['JD'] < jd[0][1])]\\n\\n # Sort by JD and reset index.\\n self.data_subset = self.data_subset.sort_values(\\n by=['JD'], ascending=True).reset_index(drop=True)\\n\\n # Check spectra found:\\n if len(self.data_subset) == 0:\\n raise FileExistsError(\\n 'No spectra found for that location or subset.')\\n\\n print('Selecting {} spectra from fits dataset.'.format(\\n len(self.data_subset)))\",\n \"def score(label_dict, target, selection, n=50):\\n\\n # Remove the queried element\\n selection = list(set(selection) - {target})\\n\\n # Fetch labels for queried image\\n if target in label_dict.keys():\\n target_dict = dict(label_dict[target])\\n else:\\n logging.error('Could not find %s in the dict keys' % target)\\n\\n target_dict = {}\\n\\n # Current score will accumulate the element-wise scores, before rescaling by scaling by 2/(k*n)\\n current_score = 0.0\\n\\n # Calculate best possible score of image\\n best_score = sum(target_dict.values())\\n\\n # Avoid problems with div zero. If best_score is 0.0 we will\\n # get 0.0 anyway, then best_score makes no difference\\n if best_score == 0.0:\\n best_score = 1.0\\n\\n # Loop through all the selected elements\\n for selected_element in selection:\\n # If we have added a non-existing image we will not get\\n # anything, and create a dict with no elements\\n # Otherwise select the current labels\\n if selected_element in label_dict.keys():\\n selected_dict = dict(label_dict[selected_element])\\n else:\\n logging.error('Could not find %s in the dict keys' % selected_element)\\n\\n selected_dict = {}\\n\\n # Extract the shared elements\\n common_elements = list(set(selected_dict.keys()) & set(target_dict.keys()))\\n\\n if len(common_elements) > 0:\\n # for each shared element, the potential score is the\\n # level of certainty in the element for each of the\\n # images, multiplied together\\n element_scores = [\\n selected_dict[element] * target_dict[element] for element in common_elements\\n ]\\n\\n # We sum the contributions, and that's it\\n current_score += sum(element_scores) / best_score\\n else:\\n # If there are no shared elements,\\n # we won't add anything\\n pass\\n\\n # We are done after scaling\\n return current_score * 2 / (len(selection) + n)\",\n \"def negSamplingCostAndGradient(predicted, target, outputVectors, dataset, K=10):\\n\\t#sampling of indices\\n\\tindices = [target]\\n\\tindices.extend(getNegativeSamples(target, dataset, K))\\n\\n\\tgrad = np.zeros(outputVectors.shape)\\n\\tgradPred = np.zeros(predicted.shape)\\n\\tcost = 0\\n\\t#a true pair\\n\\tz = sigmoid(np.dot(outputVectors[target], predicted))\\n\\n\\tcost -= np.log(z)\\n\\tgrad[target] += predicted*(z-1.0)\\n\\tgradPred += outputVectors[target]*(z-1.0)\\n\\n\\tfor k in range(K):\\n\\t\\tsamp = indices[k+1]\\n\\t\\tz = sigmoid(np.dot(outputVectors[samp], predicted))\\t#real number\\n\\t\\tcost -= np.log(1.0 - z)\\n\\t\\tgrad[samp] += predicted*z \\n\\t\\tgradPred += outputVectors[samp]*z \\n\\n\\treturn cost, gradPred, grad\",\n \"def regular_subsample(neuron):\\n # select all the main points\\n selected_index = get_main_points(neuorn)\\n\\n # Computing the parent id of the selected nodes\\n neuron = neuron_with_selected_nodes(selected_index)\\n return neuron\",\n \"def random_sampling(self, n_subset):\\n t = datetime.now().strftime(\\\"%Y-%m-%d %H:%M:%S\\\")\\n print(\\\"[INFO] {} - Random sampling with replacement ...\\\".format(t))\\n subset_list = []\\n training_set = self\\n subset_size = math.ceil(training_set.n_samples / n_subset)\\n # create subsets\\n for i in range(n_subset):\\n # run a permutation to mix all samples (sampling with replacement)\\n self.permutation()\\n # always draw the first samples\\n start_idx = 0\\n stop_idx = subset_size\\n subset = deepcopy(training_set)\\n subset.data = subset.data[start_idx:stop_idx][:]\\n subset.labels = subset.labels[start_idx:stop_idx][:]\\n subset.labels_onehot = subset.labels_onehot[start_idx:stop_idx][:]\\n subset.n_samples = stop_idx - start_idx\\n subset.true_distribution = subset._get_true_distribution()\\n subset.set_batch_size(training_set.batch_size)\\n subset_list.append(subset)\\n print(\\\"\\\\tSubset shape {}\\\".format(subset.data.shape))\\n return subset_list\",\n \"def tournament_selection(\\n fitness: List[float], n: int, size: Optional[int] = 2\\n) -> np.array:\\n\\n selected = []\\n for _ in range(n):\\n step = [np.random.choice(fitness) for _ in range(size)]\\n selected.append(np.where(min(step) == fitness)[0][0])\\n\\n return selected\",\n \"def _mate_pool_select(self,pop,mp_size,fitness_rank):\\n mp,_=self._tournament_select(pop,mp_size,fitness_rank,cap=2)\\n\\n return mp\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def select(self):\\n best_num_components = self.n_constant\\n return self.base_model(best_num_components)\",\n \"def _prefit(self,costfunc,sample):\\n # Here we obtain 10 initial candidates to best fitting\\n #opt=100.\\n if self.long_fitting[sample]:\\n l1=np.linspace(-20,0,16)\\n l2=np.linspace(-10,-0.3,16)\\n l3=np.linspace(-0.5,0.5,16)\\n l4=np.linspace(-0.015,0.015,16)\\n else:\\n l1=np.linspace(-20,0,5)\\n l2=np.linspace(-10,-0.3,5)\\n l3=np.linspace(-0.5,0.5,5)\\n l4=np.linspace(-0.015,0.015,5)\\n l1,l2,l3,l4=np.meshgrid(l1,l2,l3,l4)\\n l1,l2,l3,l4=l1.ravel(),l2.ravel(),l3.ravel(),l4.ravel()\\n #self._message(\\\"(%s) Prefitting data (grid search) - %d tests.\\\"%(sample,l1.size))\\n costs=np.ones_like(l1)\\n #optpar=np.array((l1[8],l2[8],l3[8],l4[8]))\\n for j in range(l1.size):\\n ll=np.array((l1[j],l2[j],l3[j],l4[j]))\\n costs[j]=costfunc(ll)\\n idx=np.argsort(costs)\\n opt=costs[idx]\\n optpars=np.column_stack((l1[idx],l2[idx],l3[idx],l4[idx]))\\n #self._message(str(optpars.shape))\\n #self._message(\\\"(%s) Prefitting done. Error achieved after prefitting: %s.\\\"%(sample,str(opt)))\\n #self._message(\\\"(%s) Prefitting done. Error achieved after prefitting: %g.\\\"%(sample,opt[0]))\\n if opt[0]>=1:\\n self._message(\\\"Warning: (%s) Prefitting did not find a good initial condition (%g).\\\"%(sample,opt[0]))\\n return optpars,opt\",\n \"def query(self, X_train, Y_train, labeled_idx, amount):\\n return NotImplemented\",\n \"def prepare_evaluation(self):\\n # this is called after the optimizer has discretized the graph\\n cells = [self.edges[2, 3].op, self.edges[4, 5].op, self.edges[6, 7].op]\\n\\n self._expand()\\n\\n channels = [64, 128, 256]\\n factor = 4\\n\\n for cell, c in zip(cells, channels):\\n for _, _, data in cell.edges.data():\\n data.op.update_nodes(\\n lambda node, in_edges, out_edges: _set_comb_op_channels(\\n node, in_edges, out_edges, c=c\\n ),\\n single_instances=False,\\n )\\n\\n self.edges[1, 2].set(\\\"op\\\", ops.Stem(channels[0]))\\n self.edges[2, 3].set(\\\"op\\\", cells[0].copy())\\n self.edges[3, 4].set(\\n \\\"op\\\",\\n ops.SepConv(channels[0], channels[0], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[4, 5].set(\\\"op\\\", cells[0].copy())\\n self.edges[5, 6].set(\\n \\\"op\\\",\\n ops.SepConv(channels[0], channels[1], kernel_size=3, stride=2, padding=1),\\n )\\n self.edges[6, 7].set(\\\"op\\\", cells[1].copy())\\n self.edges[7, 8].set(\\n \\\"op\\\",\\n ops.SepConv(channels[1], channels[1], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[8, 9].set(\\\"op\\\", cells[1].copy())\\n self.edges[9, 10].set(\\n \\\"op\\\",\\n ops.SepConv(channels[1], channels[2], kernel_size=3, stride=2, padding=1),\\n )\\n self.edges[10, 11].set(\\\"op\\\", cells[2].copy())\\n self.edges[11, 12].set(\\n \\\"op\\\",\\n ops.SepConv(channels[2], channels[2], kernel_size=3, stride=1, padding=1),\\n )\\n self.edges[12, 13].set(\\\"op\\\", cells[2].copy())\\n self.edges[13, 14].set(\\n \\\"op\\\",\\n ops.Sequential(\\n ops.SepConv(\\n channels[-1], channels[-1], kernel_size=3, stride=1, padding=1\\n ),\\n nn.AdaptiveAvgPool2d(1),\\n nn.Flatten(),\\n nn.Linear(channels[-1], 10),\\n ),\\n )\\n\\n self.update_edges(\\n update_func=lambda edge: _increase_channels(edge, factor),\\n scope=self.OPTIMIZER_SCOPE,\\n private_edge_data=True,\\n )\",\n \"def sim_average_cost(self, dictionary):\\n\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\tprint \\\"Running: sim_average_cost\\\"\\n\\t\\tf = open(toggles.OUTPUT_PATH + toggles.RUN_NAME + '_estimated_costs.csv', 'a')\\n\\n\\t\\tfor p in toggles.CHOSEN_PREDS:\\n\\t\\t\\tpred_cost = 0.0\\n\\t\\t\\tpred = Predicate.objects.all().get(pk=p+1)\\n\\t\\t\\tf.write(pred.question.question_text + '\\\\n')\\n\\n\\t\\t\\t#iterate through to find each ip cost\\n\\t\\t\\tfor ip in IP_Pair.objects.filter(predicate=pred):\\n\\t\\t\\t\\titem_cost = 0.0\\n\\t\\t\\t\\t# sample toggles.COST_SAMPLES times\\n\\t\\t\\t\\tfor x in range(toggles.COST_SAMPLES):\\n\\t\\t\\t\\t\\t# running one sampling\\n\\t\\t\\t\\t\\twhile ip.status_votes < toggles.NUM_CERTAIN_VOTES:\\n\\t\\t\\t\\t\\t\\t# get the vote\\n\\t\\t\\t\\t\\t\\tvalue = choice(dictionary[ip])\\n\\t\\t\\t\\t\\t\\tif value == True:\\n\\t\\t\\t\\t\\t\\t\\tip.value += 1\\n\\t\\t\\t\\t\\t\\t\\tip.num_yes += 1\\n\\t\\t\\t\\t\\t\\telif value == False:\\n\\t\\t\\t\\t\\t\\t\\tip.value -= 1\\n\\t\\t\\t\\t\\t\\t\\tip.num_no +=1\\n\\n\\t\\t\\t\\t\\t\\tip.status_votes += 1\\n\\n\\t\\t\\t\\t\\t\\t# check if ip is done\\n\\t\\t\\t\\t\\t\\tif ip.status_votes == toggles.NUM_CERTAIN_VOTES:\\n\\t\\t\\t\\t\\t\\t\\t\\tif ip.value > 0:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tuncertaintyLevel = btdtr(ip.num_yes+1, ip.num_no+1, toggles.DECISION_THRESHOLD)\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tuncertaintyLevel = btdtr(ip.num_no+1, ip.num_yes+1, toggles.DECISION_THRESHOLD)\\n\\t\\t\\t\\t\\t\\t\\t\\tif uncertaintyLevel < toggles.UNCERTAINTY_THRESHOLD:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\titem_cost += (ip.num_yes + ip.num_no)\\n\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tip.status_votes -= 2\\n\\n\\t\\t\\t\\t\\t# reset values\\n\\t\\t\\t\\t\\tip.value = 0\\n\\t\\t\\t\\t\\tip.num_yes = 0\\n\\t\\t\\t\\t\\tip.num_no = 0\\n\\t\\t\\t\\t\\tip.status_votes = 0\\n\\n\\t\\t\\t\\titem_cost = item_cost/float(toggles.COST_SAMPLES)\\n\\t\\t\\t\\tpred_cost += item_cost\\n\\t\\t\\t\\tf.write(ip.item.name + ': ' + str(item_cost) + \\\" \\\")\\n\\n\\t\\t\\tpred_cost = float(pred_cost)/IP_Pair.objects.filter(predicate=pred).count()\\n\\t\\t\\tf.write('\\\\npredicate average cost: ' + str(pred_cost) + '\\\\n \\\\n')\\n\\t\\tf.close()\\n\\t\\tif toggles.DEBUG_FLAG:\\n\\t\\t\\tprint \\\"Wrote File: \\\" + toggles.OUTPUT_PATH + toggles.RUN_NAME + '_estimated_costs.csv'\",\n \"def _select_sublist(lst, target):\\n ln = len(lst)\\n\\n # Generate an array that indicates the decision bit for each element in the list.\\n # If an element is deterministically true, then no decision bit is needed.\\n choice_bits = [None] * ln\\n x = 0\\n for i in range(0, ln):\\n if lst[i][1] not in (target.TRUE, target.FALSE):\\n choice_bits[i] = x\\n x += 1\\n\\n # We have 2^x distinct lists. Each can be represented as a number between 0 and 2^x-1=n.\\n n = (1 << x) - 1\\n\\n while n >= 0:\\n # Generate the list of positive values and node identifiers\\n # noinspection PyTypeChecker\\n sublist = [lst[i] for i in range(0, ln)\\n if (choice_bits[i] is None and lst[i][1] == target.TRUE) or\\n (choice_bits[i] is not None and n & 1 << choice_bits[i])]\\n # Generate the list of negative node identifiers\\n # noinspection PyTypeChecker\\n sublist_no = tuple([target.negate(lst[i][1]) for i in range(0, ln)\\n if (choice_bits[i] is None and lst[i][1] == target.FALSE) or (\\n choice_bits[i] is not None and not n & 1 << choice_bits[i])])\\n if sublist:\\n terms, nodes = zip(*sublist)\\n else:\\n # Empty list.\\n terms, nodes = (), ()\\n yield terms, nodes + sublist_no + (0,)\\n n -= 1\",\n \"def __init__(self, cost_func):\\n super().__init__(cost_func)\\n\\n self.support_for_bounds = True\\n self._popt = None\\n self._status = None\\n self._maxiter = None\",\n \"def __init__(self, cost_func):\\n super(MinuitController, self).__init__(cost_func)\\n self._popt = None\\n self._initial_step = None\\n self._minuit_problem = None\\n self.algorithm_check = {\\n 'all': ['minuit'],\\n 'ls': [None],\\n 'deriv_free': [None],\\n 'general': ['minuit']}\",\n \"def _reduce(self, x, y):\\n ind = self.ind_\\n n_samples, n_features = x.shape\\n n_features_selected = sum(ind)\\n\\n for _ in range(self.iters, self.max_iter):\\n if np.count_nonzero(ind) == 0:\\n warnings.warn(\\n \\\"Sparsity parameter is too big ({}) and eliminated all coeficients\\\".format(self.threshold)\\n )\\n coef = np.zeros_like(ind, dtype=float)\\n break\\n\\n coef = self._regress(x[:, ind], y, self.alpha)\\n coef, ind = self._sparse_coefficients(n_features, ind, coef, self.threshold)\\n\\n if sum(ind) == n_features_selected or self._no_change():\\n # could not (further) select important features\\n break\\n else:\\n warnings.warn(\\n \\\"STRidge._reduce did not converge after {} iterations.\\\".format(self.max_iter),\\n ConvergenceWarning,\\n )\\n try:\\n coef\\n except NameError:\\n coef = self.coef_\\n warnings.warn(\\\"STRidge._reduce has no iterations left to determine coef\\\", ConvergenceWarning)\\n self.coef_ = coef\\n self.ind_ = ind\",\n \"def selection(self):\\n\\n # sort the generation according to fitness.\\n self.sortByFitness()\\n # get the fitness sum.\\n fitnessSum = 0\\n for outfit in self.currentGeneration:\\n fitnessSum += self.applyFitness(outfit)\\n # generate a random number\\n stop = random.uniform(0, 1)\\n accumulated = 0\\n offset = 0\\n for outfit in self.currentGenerationSorted:\\n fitness = self.applyFitness(outfit) + offset\\n probability = fitness / fitnessSum\\n accumulated += probability\\n\\n if stop <= accumulated:\\n return outfit\",\n \"def optimize(opt):\\n # load new target\\n if opt.is_poly:\\n target_mesh = om.read_polymesh(opt.model)\\n else:\\n target_mesh = om.read_trimesh(opt.model)\\n target_shape_arr = target_mesh.points()\\n target_shape = target_shape_arr.copy()\\n target_shape = torch.from_numpy(\\n target_shape[:, :3].astype(np.float32)).cuda()\\n target_shape.unsqueeze_(0)\\n\\n target_faces_arr = target_mesh.face_vertex_indices()\\n target_faces = target_faces_arr.copy()\\n target_faces = torch.from_numpy(\\n target_faces[:, :3].astype(np.int64)).cuda()\\n target_faces.unsqueeze_(0)\\n\\n states = torch.load(opt.ckpt)\\n if \\\"states\\\" in states:\\n states = states[\\\"states\\\"]\\n cage_v = states[\\\"template_vertices\\\"].transpose(1, 2).cuda()\\n cage_f = states[\\\"template_faces\\\"].cuda()\\n shape_v = states[\\\"source_vertices\\\"].transpose(1, 2).cuda()\\n shape_f = states[\\\"source_faces\\\"].cuda()\\n\\n if os.path.isfile(opt.model.replace(os.path.splitext(opt.model)[1], \\\".picked\\\")) and os.path.isfile(opt.source_model.replace(os.path.splitext(opt.source_model)[1], \\\".picked\\\")):\\n new_label_path = opt.model.replace(os.path.splitext(opt.model)[1], \\\".picked\\\")\\n orig_label_path = opt.source_model.replace(os.path.splitext(opt.source_model)[1], \\\".picked\\\")\\n logger.info(\\\"Loading picked labels {} and {}\\\".format(orig_label_path, new_label_path))\\n new_label = pd.read_csv(new_label_path, delimiter=\\\" \\\",skiprows=1, header=None)\\n orig_label = pd.read_csv(orig_label_path, delimiter=\\\" \\\",skiprows=1, header=None)\\n orig_label_name = orig_label.iloc[:,5]\\n new_label_name = new_label.iloc[:,5].tolist()\\n new_to_orig_idx = []\\n for i, name in enumerate(new_label_name):\\n matched_idx = orig_label_name[orig_label_name==name].index\\n if matched_idx.size == 1:\\n new_to_orig_idx.append((i, matched_idx[0]))\\n new_to_orig_idx = np.array(new_to_orig_idx)\\n if new_label.shape[1] == 10:\\n new_vidx = new_label.iloc[:,9].to_numpy()[new_to_orig_idx[:,0]]\\n target_points = target_shape[:, new_vidx, :]\\n else:\\n new_label_points = torch.from_numpy(new_label.iloc[:,6:9].to_numpy().astype(np.float32))\\n target_points = new_label_points.unsqueeze(0).cuda()\\n target_points, new_vidx, _ = faiss_knn(1, target_points, target_shape, NCHW=False)\\n target_points = target_points.squeeze(2) # B,N,3\\n new_label[9] = new_vidx.squeeze(0).squeeze(-1).cpu().numpy()\\n new_label.to_csv(new_label_path, sep=\\\" \\\", header=[str(new_label.shape[0])]+[\\\"\\\"]*(new_label.shape[1]-1), index=False)\\n target_points = target_points[:, new_to_orig_idx[:,0], :]\\n\\n target_points = target_points.cuda()\\n source_shape, _ = read_trimesh(opt.source_model)\\n source_shape = torch.from_numpy(source_shape[None, :,:3]).float()\\n if orig_label.shape[1] == 10:\\n orig_vidx = orig_label.iloc[:,9].to_numpy()[new_to_orig_idx[:,1]]\\n source_points = source_shape[:, orig_vidx, :]\\n else:\\n orig_label_points = torch.from_numpy(orig_label.iloc[:,6:9].to_numpy().astype(np.float32))\\n source_points = orig_label_points.unsqueeze(0)\\n # find the closest point on the original meshes\\n source_points, new_vidx, _ = faiss_knn(1, source_points, source_shape, NCHW=False)\\n source_points = source_points.squeeze(2) # B,N,3\\n orig_label[9] = new_vidx.squeeze(0).squeeze(-1).cpu().numpy()\\n orig_label.to_csv(orig_label_path, sep=\\\" \\\", header=[str(orig_label.shape[0])]+[\\\"\\\"]*(orig_label.shape[1]-1), index=False)\\n source_points = source_points[:,new_to_orig_idx[:,1],:]\\n\\n _, source_center, _ = center_bounding_box(source_shape[0])\\n source_points -= source_center\\n source_points = source_points.cuda()\\n # # shift target so that the belly match\\n # try:\\n # orig_bellyUp_idx = orig_label_name[orig_label_name==\\\"bellUp\\\"].index[0]\\n # orig_bellyUp = orig_label_points[orig_bellyUp_idx, :]\\n # new_bellyUp_idx = [i for i, i2 in new_to_orig_idx if i2==orig_bellyUp_idx][0]\\n # new_bellyUp = new_label_points[new_bellyUp_idx,:]\\n # target_points += (orig_bellyUp - new_bellyUp)\\n # except Exception as e:\\n # logger.warn(\\\"Couldn\\\\'t match belly to belly\\\")\\n # traceback.print_exc(file=sys.stdout)\\n\\n # source_points[0] = center_bounding_box(source_points[0])[0]\\n elif not os.path.isfile(opt.model.replace(os.path.splitext(opt.model)[1], \\\".picked\\\")) and \\\\\\n os.path.isfile(opt.source_model.replace(os.path.splitext(opt.source_model)[1], \\\".picked\\\")):\\n logger.info(\\\"Could not find {}. Assuming SMPL model\\\".format(opt.model.replace(os.path.splitext(opt.model)[1], \\\".picked\\\")))\\n source_shape, source_faces = read_trimesh(opt.source_model)\\n assert(source_faces.shape[0] == target_faces.shape[1]), \\\\\\n \\\"opt.model must be a SMPL model with {} faces and {} vertices. Otherwise a correspondence file {} must be present.\\\".format(\\n source_faces.shape[0], source_shape.shape[0], opt.model.replace(os.path.splitext(opt.model)[1], \\\".picked\\\"))\\n # align faces not vertices\\n orig_label_path = opt.source_model.replace(os.path.splitext(opt.source_model)[1], \\\".picked\\\")\\n logger.info(\\\"Loading picked labels {}\\\".format(orig_label_path))\\n orig_label = pd.read_csv(orig_label_path, delimiter=\\\" \\\",skiprows=1, header=None)\\n source_shape = torch.from_numpy(source_shape[None, :, :3]).cuda().float()\\n source_faces = torch.from_numpy(source_faces[None, :, :3]).cuda().long()\\n idx = torch.from_numpy(orig_label.iloc[:,1].to_numpy()).long()\\n source_points = torch.gather(source_shape.unsqueeze(1).expand(-1, idx.numel(), -1, -1), 2, source_faces[:, idx, :, None].expand(-1, -1, -1, 3))\\n source_points = source_points.mean(dim=-2)\\n target_points = torch.gather(target_shape.unsqueeze(1).expand(-1, idx.numel(), -1, -1), 2, target_faces[:, idx, :, None].expand(-1, -1, -1, 3))\\n target_points = target_points.mean(dim=-2)\\n\\n _, source_center, _ = center_bounding_box(source_shape[0])\\n source_points -= source_center\\n elif not os.path.isfile(opt.model.replace(os.path.splitext(opt.model)[1], \\\".picked\\\")):\\n logger.info(\\\"Could not find {}. Assuming SMPL model\\\".format(opt.model.replace(os.path.splitext(opt.model)[1], \\\".picked\\\")))\\n source_shape, source_faces = read_trimesh(opt.source_model)\\n assert(source_faces.shape[0] == target_faces.shape[1]), \\\\\\n \\\"opt.model must be a SMPL model with {} faces and {} vertices. Otherwise a correspondence file {} must be present.\\\".format(\\n source_faces.shape[0], source_shape.shape[0], opt.model.replace(os.path.splitext(opt.model)[1], \\\".picked\\\"))\\n source_shape, source_faces = read_trimesh(opt.source_model)\\n\\n _, source_center, _ = center_bounding_box(source_shape[0])\\n source_points -= source_center\\n\\n source_shape = torch.from_numpy(source_shape[None, :, :3]).cuda().float()\\n source_faces = torch.from_numpy(source_faces[None, :, :3]).cuda().long()\\n # select a subset of faces, otherwise optimization is too slow\\n idx = torch.from_numpy(np.random.permutation(2048)).cuda().long()\\n source_points = torch.gather(source_shape.unsqueeze(1).expand(-1, source_faces.shape[1], -1, -1), 2, source_faces[:, idx,:, None].expand(-1, -1, -1, 3))\\n source_points = source_points.mean(dim=-2)\\n target_points = torch.gather(target_shape.unsqueeze(1).expand(-1, source_faces.shape[1], -1, -1), 2, target_faces[:,idx,: None].expand(-1, -1, -1, 3))\\n target_points = target_points.mean(dim=-2)\\n\\n\\n target_points = target_points[:, idx]\\n source_points = source_points[:, idx]\\n\\n\\n target_shape[0], target_center, target_scale = center_bounding_box(target_shape[0])\\n _, _, source_scale = center_bounding_box(shape_v[0])\\n # scale according y axis (body height)\\n target_scale_factor = (source_scale/target_scale)[0,1]\\n target_shape *= target_scale_factor\\n target_points -= target_center\\n target_points = (target_points*target_scale_factor).detach()\\n # make sure test use the normalized\\n target_shape_arr[:] = target_shape[0].cpu().numpy()\\n om.write_mesh(os.path.join(opt.log_dir, opt.subdir, os.path.splitext(\\n os.path.basename(opt.model))[0]+\\\"_normalized.obj\\\"), target_mesh)\\n opt.model = os.path.join(opt.log_dir, opt.subdir, os.path.splitext(\\n os.path.basename(opt.model))[0]+\\\"_normalized.obj\\\")\\n pymesh.save_mesh_raw(os.path.join(opt.log_dir, opt.subdir, \\\"template-initial.obj\\\"),\\n shape_v[0].cpu().numpy(), shape_f[0].cpu().numpy())\\n pymesh.save_mesh_raw(os.path.join(opt.log_dir, opt.subdir, \\\"cage-initial.obj\\\"),\\n cage_v[0].cpu().numpy(), cage_f[0].cpu().numpy())\\n save_ply(target_points[0].cpu().numpy(), os.path.join(\\n opt.log_dir, opt.subdir, \\\"target_points.ply\\\"))\\n save_ply(source_points[0].cpu().numpy(), os.path.join(\\n opt.log_dir, opt.subdir, \\\"source_points.ply\\\"))\\n logger.info(\\\"Optimizing for {} corresponding vertices\\\".format(\\n target_points.shape[1]))\\n\\n cage_init = cage_v.clone().detach()\\n lap_loss = MeshLaplacianLoss(torch.nn.MSELoss(reduction=\\\"none\\\"), use_cot=True,\\n use_norm=True, consistent_topology=True, precompute_L=True)\\n mvc_reg_loss = MVCRegularizer(threshold=50, beta=1.0, alpha=0.0)\\n cage_v.requires_grad_(True)\\n optimizer = torch.optim.Adam([cage_v], lr=opt.lr, betas=(0.5, 0.9))\\n scheduler = torch.optim.lr_scheduler.StepLR(optimizer, int(opt.nepochs*0.4), gamma=0.5, last_epoch=-1)\\n\\n if opt.dim == 3:\\n weights_ref = mean_value_coordinates_3D(\\n source_points, cage_init, cage_f, verbose=False)\\n else:\\n raise NotImplementedError\\n\\n for t in range(opt.nepochs):\\n optimizer.zero_grad()\\n weights = mean_value_coordinates_3D(\\n target_points, cage_v, cage_f, verbose=False)\\n loss_mvc = torch.mean((weights-weights_ref)**2)\\n # reg = torch.sum((cage_init-cage_v)**2, dim=-1)*1e-4\\n reg = torch.tensor(0.0).cuda()\\n if opt.clap_weight > 0:\\n reg = lap_loss(cage_init, cage_v, face=cage_f)*opt.clap_weight\\n reg = reg.mean()\\n if opt.mvc_weight > 0:\\n reg += mvc_reg_loss(weights)*opt.mvc_weight\\n\\n loss = loss_mvc + reg\\n if (t+1) % 50 == 0:\\n print(\\\"t {}/{} mvc_loss: {} reg: {}\\\".format(t, opt.nepochs, loss_mvc.item(), reg.item()))\\n\\n if loss_mvc.item() < 5e-6:\\n break\\n loss.backward()\\n optimizer.step()\\n scheduler.step()\\n\\n return cage_v, cage_f\",\n \"def __init__(self, b=0, drop_rate=0.5, pretrained=True):\\n\\n # Calls the super for the nn.Module.\\n super(SelectiveNet, self).__init__()\\n\\n # Loads the EfficientNet encoder.\\n if pretrained:\\n self.encoder = EfficientNet.from_pretrained(f\\\"efficientnet-b{str(b)}\\\")\\n else:\\n self.encoder = EfficientNet.from_name(f\\\"efficientnet-b{str(b)}\\\")\\n self.encoder_pool = nn.AdaptiveAvgPool2d(1)\\n\\n # Defines a hidden layer.\\n self.hidden = nn.Linear(2560, 512)\\n\\n # Initialises the classifier for generating predictions.\\n self.classifier = nn.Linear(512, 2)\\n\\n # Initialises the selective branch for generating selection scores.\\n self.selective_hidden = nn.Linear(512, 512)\\n self.selective_batch_norm = nn.BatchNorm1d(512)\\n self.selective_regression = nn.Linear(512, 1)\\n\\n # Initialises the auxiliary output used by the model during training.\\n self.auxiliary_output = nn.Linear(512, 2)\\n\\n # Stores the dropout rate in the object.\\n self.drop_rate = drop_rate\",\n \"def _select(self):\\n sel = []\\n\\n # choose randomly while favouring fit individuals\\n lp = len(self.population) // 2\\n for _ in range(lp):\\n idx1 = idx2 = int(math.sqrt(random.randrange(lp**2+1)))\\n while idx1 == idx2:\\n idx2 = int(math.sqrt(random.randrange(lp**2+1)))\\n\\n p1, p2 = self.population[idx1], self.population[idx2]\\n sel.append((p1, p2))\\n\\n return sel\",\n \"def subset_trees(self, trees_take):\\n assert self.is_fitted_\\n trees_take = np.array(trees_take).reshape(-1).astype(ctypes.c_size_t)\\n if not trees_take.shape[0]:\\n raise ValueError(\\\"'trees_take' is empty.\\\")\\n if trees_take.max() >= self._ntrees:\\n raise ValueError(\\\"Attempting to take tree indices that the model does not have.\\\")\\n new_cpp_obj = self._cpp_obj.subset_model(trees_take, self._is_extended_, self.build_imputer)\\n old_cpp_obj = self._cpp_obj\\n try:\\n self._cpp_obj = None\\n new_obj = deepcopy(self)\\n new_obj._cpp_obj = new_cpp_obj\\n finally:\\n self._cpp_obj = old_cpp_obj\\n return new_obj\",\n \"def search(self):\\n W = np.zeros((self.subsets.shape[0],)) \\n for i,E in enumerate(self.subsets):\\n self.graph.setV(E) # set the nodes to their values\\n W[i] = self.graph.computeW()\\n self.Ws = W\",\n \"def feature_selection(x_train, y_train, nb_feats=150):\\n cs = np.zeros(x_train.shape[1])\\n for f in range(x_train.shape[1]):\\n if np.isclose(np.sum(x_train[:, f]), 0):\\n cs[f] = 0\\n continue\\n\\n cs[f], p = spearmanr(x_train[:, f], np.mean(y_train, axis=1))\\n select = np.argsort(np.abs(cs))[np.max([-nb_feats, -len(cs)]):]\\n return select\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57697535","0.562434","0.5616341","0.5610637","0.56050736","0.5519219","0.5512085","0.55078983","0.5479911","0.5459371","0.54215497","0.5415881","0.5408919","0.53455186","0.5337947","0.532884","0.5326981","0.5322655","0.5321926","0.52773917","0.5220302","0.52116895","0.5188642","0.5179478","0.51632994","0.5162077","0.5150366","0.51432925","0.51254445","0.512447","0.51012737","0.50858945","0.50837976","0.5072817","0.5071895","0.50714314","0.5070205","0.50626993","0.5045847","0.5042049","0.5037463","0.50303257","0.5023835","0.50236636","0.5018697","0.5017578","0.50126565","0.4993977","0.49667153","0.49631685","0.49579537","0.4954051","0.49479705","0.49327144","0.49132347","0.49132347","0.49132347","0.49073225","0.49027285","0.49009332","0.48912746","0.48841333","0.48805422","0.48779836","0.48717675","0.48682398","0.48589","0.48538923","0.48538265","0.48534343","0.48519334","0.4849923","0.48492104","0.48460358","0.48424813","0.48422375","0.48409706","0.4840113","0.4840113","0.4840113","0.4840113","0.4840113","0.4840113","0.4840113","0.4840113","0.4840113","0.48400226","0.48343882","0.48341864","0.4830921","0.48217532","0.48201585","0.48132563","0.4808269","0.48063213","0.48050854","0.48042518","0.4802904","0.47968215","0.47941878","0.47919768"],"string":"[\n \"0.57697535\",\n \"0.562434\",\n \"0.5616341\",\n \"0.5610637\",\n \"0.56050736\",\n \"0.5519219\",\n \"0.5512085\",\n \"0.55078983\",\n \"0.5479911\",\n \"0.5459371\",\n \"0.54215497\",\n \"0.5415881\",\n \"0.5408919\",\n \"0.53455186\",\n \"0.5337947\",\n \"0.532884\",\n \"0.5326981\",\n \"0.5322655\",\n \"0.5321926\",\n \"0.52773917\",\n \"0.5220302\",\n \"0.52116895\",\n \"0.5188642\",\n \"0.5179478\",\n \"0.51632994\",\n \"0.5162077\",\n \"0.5150366\",\n \"0.51432925\",\n \"0.51254445\",\n \"0.512447\",\n \"0.51012737\",\n \"0.50858945\",\n \"0.50837976\",\n \"0.5072817\",\n \"0.5071895\",\n \"0.50714314\",\n \"0.5070205\",\n \"0.50626993\",\n \"0.5045847\",\n \"0.5042049\",\n \"0.5037463\",\n \"0.50303257\",\n \"0.5023835\",\n \"0.50236636\",\n \"0.5018697\",\n \"0.5017578\",\n \"0.50126565\",\n \"0.4993977\",\n \"0.49667153\",\n \"0.49631685\",\n \"0.49579537\",\n \"0.4954051\",\n \"0.49479705\",\n \"0.49327144\",\n \"0.49132347\",\n \"0.49132347\",\n \"0.49132347\",\n \"0.49073225\",\n \"0.49027285\",\n \"0.49009332\",\n \"0.48912746\",\n \"0.48841333\",\n \"0.48805422\",\n \"0.48779836\",\n \"0.48717675\",\n \"0.48682398\",\n \"0.48589\",\n \"0.48538923\",\n \"0.48538265\",\n \"0.48534343\",\n \"0.48519334\",\n \"0.4849923\",\n \"0.48492104\",\n \"0.48460358\",\n \"0.48424813\",\n \"0.48422375\",\n \"0.48409706\",\n \"0.4840113\",\n \"0.4840113\",\n \"0.4840113\",\n \"0.4840113\",\n \"0.4840113\",\n \"0.4840113\",\n \"0.4840113\",\n \"0.4840113\",\n \"0.4840113\",\n \"0.48400226\",\n \"0.48343882\",\n \"0.48341864\",\n \"0.4830921\",\n \"0.48217532\",\n \"0.48201585\",\n \"0.48132563\",\n \"0.4808269\",\n \"0.48063213\",\n \"0.48050854\",\n \"0.48042518\",\n \"0.4802904\",\n \"0.47968215\",\n \"0.47941878\",\n \"0.47919768\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84784,"cells":{"query":{"kind":"string","value":"Function that computes the cost value for a given x"},"document":{"kind":"string","value":"def costFun(self, S, x):"},"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 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 cost(self,x):\n Mx = self.generate_vector()\n self.prior.M.mult(x,Mx)\n return .5*Mx.inner(x)","def final_cost(self, x):\n return self.x_M_x(x[-1,:,:],self.R)","def fn(x):\n if x == 0: return 0\n if x < 0: return -inf \n return max(fn(x - c) * 10 + i + 1 for i, c in enumerate(cost))","def cost(self) -> float:","def c(x):\n cost = per_widget_cost * x + fixed_cost\n return cost","def costFunction(self, x, y ):\n self.yEst = self.forward_propagate(x)\n sqErrors = ( self.yEst - y ) ** 2\n J = sqErrors.sum() / 2\n return J","def __compute_cost(self, x, y):\n\n predictions = self.__compute_prediction(x)\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\n\n return cost","def compute_cost(AL, Y):\n pass","def cost_fun(x, problem):\n j = 0\n if problem['use_log_bar']:\n c = ineqconstr(x, problem)\n j += np.sum(logbarrierfunc(0.1, c, problem['use_sigma']))\n\n x, t_final = matrify(x, problem)\n if problem['T']!=0:\n j += np.sum([problem['cost_fun_single'](x[:, :, i], t_final, problem) for i in range(problem['Nv'])])\n else:\n j = t_final\n return j","def compute_cost(AL, Y):\n pass","def calculate_cost(x, y, weights):\r\n predictions = compute_prediction(x, weights)\r\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\r\n return cost","def objective_function(x):\n return x * 1 # change this to our actual function","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 cost_function(self, element):\n return self.maze.cost(element)","def get_cost(self) -> float:\n return math.e / self.fitness","def objective(self, x):\n pass","def objective(self, x):\n pass","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 get_cost(self, action: Action) -> N:\n pass","def calcCostFun(self):\n\n self.start()\n F, K = self.model()\n \n return self.costFunction","def calc_cost(y, x, theta_1, theta_0):\n h = theta_1 * x + theta_0\n d = h - y\n cost = np.dot(d.T, d) / (2*x.shape[0])\n return cost.flat[0]","def _cost(self, X, particle):\n startprob, transmat = self._parse_particle(particle)\n startprob, transmat = self._shape_probs(startprob, transmat)\n return -self._compute_logprob(X, startprob, transmat, **self._params)","def compute_cost(x, y, theta=[[0], [0]]):\n m = y.size\n h = x.dot(theta)\n j = 1 / (2 * m) * np.sum(np.square(h - y))\n return j","def _cost_method(self, *args, **kwargs):\n\n cost_val = 0.5 * np.linalg.norm(self.obs_data - self.op(args[0])) ** 2\n\n if 'verbose' in kwargs and kwargs['verbose']:\n print(' - DATA FIDELITY (X):', cost_val)\n\n return cost_val","def _call(self, x):\n tmp = x.asarray().flatten()\n return self.range.element(self.cost_matrix.dot(tmp))","def evaluate_cost(\n self, x: Dict[str, ArrayType], p: Dict[str, ArrayType]\n ) -> CasADiArrayType:\n x = self.opt.decision_variables.dict2vec(x)\n p = self.opt.parameters.dict2vec(p)\n return self.opt.f(x, p)","def calc_total_cost(self, X):\n return self.sess.run(self.cost, feed_dict={self.x: X, self.scale: self.training_scale})","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 cost_from_X(self, data):\n self.cost_from_X_data_specs()[0].validate(data)\n X, Y = data\n Y_hats= self.fprop(X)\n return self.cost(Y, Y_hats)","def cost_function (model, X, y, lambda_reg=0.):\n\n m = len (y)\n pred = model.predict (X)\n cost = 1. / (2. * m) * ((pred - y)**2).sum () + \\\n lambda_reg / (2. * m) * (model.coef_**2).sum ()\n return (cost)","def cost(self, cost_object, target):\n\n return cost_object.f(self.a[-1], target).mean(axis=0).sum()","def cost_function(self, config_samples):\n cost = self.work_tracker(config_samples)\n return cost","def calculate_total_cost(state):\r\n return state.cost()","def value(self, x):\n f = self._objective(\n time_series=self.observed_data,\n a=x[0],\n b=x[1],\n c=x[2],\n sigma=self.sigma\n )\n return f","def __call__(self, x, u, k):\n first_time_through = True\n for cost, arg, weight in zip(self._costs, self._args, self._weights):\n if arg == \"x\":\n cost_input = x\n else:\n cost_input = u[arg]\n\n current_term = weight * cost(cost_input, k)\n if current_term > 1e8:\n print(\"Warning: cost %s is %f\" % (cost._name, current_term))\n print(\"Input is: \", cost_input)\n\n# if cost._name[:4] == \"bike\":\n# print(cost._name, \": \", current_term)\n\n if first_time_through:\n total_cost = current_term\n else:\n total_cost += current_term\n\n first_time_through = False\n\n return total_cost","def compute_cost(AL,Y,cost_function_name):\n cost_functions = {\n \"cost_func_1\": cf.cost_function_1\n } \n\n activ_func = cost_functions.get(cost_function_name,lambda : \"Invalid Cost Function Name !\")\n\n cost,dAL = activ_func(AL,Y)\n\n return cost, dAL","def cost(self, data_X, data_Y):\n c = self.cost_function(data_Y, self.predict(data_X))\n\n if self.regularizer is not None:\n c += self.regularizer.cost(self.particle_input, self.layers)\n\n return c","def cost(self, X, y) :\n ### ========== TODO : START ========== ###\n # part d: compute J(theta)\n #we know for linear/polynomial regression, the cost is the square of the errors\n X = self.generate_polynomial_features(X)\n y_pred_vector = np.dot(X, self.coef_)\n cost = np.dot((y-y_pred_vector).transpose(),(y-y_pred_vector))#write in the matrix form\n ### ========== TODO : END ========== ###\n return cost","def compute_objective(X, C):\n # similar as mse\n\n acc = 0\n for x in range(len(X)):\n acc += (nearest_distance(X.iloc[x], C)) ** 2\n\n return acc","def compute_cost_function(X, Y, theta, lambda_factor, temp_parameter):\n h = compute_probabilities(X, theta, temp_parameter)\n\n cost = 0\n for i in range(X.shape[0]):\n for j in range(theta.shape[0]):\n if Y[i] == j:\n cost += np.log(h[j,i])\n\n cost = -cost / X.shape[0]\n\n theta = np.power(theta, 2)\n\n cost += lambda_factor / 2 * theta.sum()\n\n return cost","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 get_expected_cost(self):","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 cost(self, X=None, y=None):\n\t\tif X is None:\n\t\t\tX = self.x_data\n\t\telse:\n\t\t\tn_samples = np.size(X, 0)\n\t\t\tX = np.hstack((np.ones((n_samples, 1)), (X - np.mean(X,0)) / np.std(X,0)))\n\n\t\tif y is None:\n\t\t\ty = self.y_data\n\t\telse:\n\t\t\ty = y[:, np.newaxis]\n\n\t\ty_pred = X @ self.weights\n\n\t\t# SSE formula\n\t\tcost = 1 - (((y - y_pred) ** 2 ).sum() / ((y- y.mean())** 2).sum())\n\n\t\treturn cost","def compute_cost(features, values, theta):\n\n npoints = len(values)\n sum_of_square_errors = np.square(np.dot(features, theta) - values).sum()\n cost = sum_of_square_errors / (2*npoints)\n\n return cost","def get_action_cost(state: tuple, action: int) -> float:\n assert len(state) == 3 and state[0] < 5 and state[1] < 4 and state[2] < 3 and action < 3\n if state[0] == 0:\n return 0.0\n if state[0] == 1 and action == 0:\n return -20.0 + 10.0 * 0.5\n return -20.0 # Penalty = 20 due to Team Number = 9","def cost(self):\n\t\treturn self.g + self.h","def calculate_total_cost(state):\n pass","def eval_cost(self, params, **kwargs):\n raise NotImplementedError","def cost_total(X, cost_weights=(1.0, 1.0, 1.0)):\n return cost_weights[0] * cost_distance(X) + \\\n cost_weights[1] * cost_same_team_by_distance(X) + \\\n cost_weights[2] * cost_previous_neighbour_by_distance(X, normalize=True)","def compute_cost(self,X, y):\n \n num_samples = len(X)\n # Do Forward propagation to calculate our predictions\n z1 = X.dot(self.W1) + self.b1\n a1 = np.tanh(z1)\n z2 = a1.dot(self.W2) + self.b2\n exp_z = np.exp(z2)\n a2 = exp_z / np.sum(exp_z, axis=1, keepdims=True)\n softmax_scores = a2\n # Calculate the cross-entropy loss\n cross_ent_err = -np.log(softmax_scores[range(num_samples), y])\n data_loss = np.sum(cross_ent_err)\n return 1./num_samples * data_loss","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 optimize(self, x0):\n (result,f,d) = fmin_l_bfgs_b(lambda x:self.costFun(x), np.ravel(x0),lambda x: self.gradFun(x))\n print(\"optimization completed with cost: \" + str(f))\n return result.reshape(self.inp_shape)","def getCostFunction(self, evalpts, observations, sigma=None, metric=lambda x: sum(x*x)):\n #XXX: better interface for sigma?\n def _(params):\n ind = 0\n for F, n, ofilt, icheck in zip(self._forwardFactories, self._inputs, \\\n self._outputFilters, self._inputCheckers):\n # check input #XXX: is this worthwile to do?\n my_params = params[ind:ind+n]\n checkQ = icheck(my_params, evalpts)\n if checkQ is not None:\n # some parameters are out of range... returns \"cost\"\n return checkQ\n\n Gm = F(params[ind:ind+n])\n if ind == 0:\n x = ofilt(Gm(evalpts)) \n else:\n x = x + ofilt(Gm(evalpts)) \n ind = ind+n\n if sigma is None:\n x = x - observations\n else:\n x = (x - observations) / sigma\n #return sum(real((conjugate(x)*x)))\n #return sum(x*x) \n return metric(x)\n return _","def compute_cost(features, values, theta):\n m = len(values)\n sum_of_square_errors = np.square(np.dot(features, theta) - values).sum()\n cost = sum_of_square_errors / (2 * m)\n\n return cost","def cost_function(data_x, data_y, parameters):\n # Residual sum of squares\n rss = np.sum((data_x @ parameters - data_y) ** 2)\n\n # Number of rows times 2\n nb_rows_x2 = 2 * data_x.shape[0]\n\n return rss / nb_rows_x2","def cost_function(theta, X, y):\n\n l = None\n #######################################################################\n # TODO: #\n # Compute and return the cost l of a particular choice of #\n # theta. #\n # #\n #######################################################################\n thetaX = np.dot(X, theta)\n g = tanh(thetaX)-y\n l = np.sum(g*g) / X.shape[0]\n \n #######################################################################\n # END OF YOUR CODE #\n #######################################################################\n return l","def compute_cost(y, tx, w):\n # ***************************************************\n # INSERT YOUR CODE HERE\n # TODO: compute loss by MSE / MAE\n # ***************************************************\n \n # vector e\n e = compute_e(y, tx, w)\n N = compute_N(e)\n L_MSE = np.dot(np.matrix.transpose(e), e)\n L_MSE = L_MSE / (2 * N)\n \n return L_MSE","def prediction_cost(a, y):\n return np.sum((a - y) ** 2) / 2","def getCost(self, state, action):\n util.raiseNotDefined()","def compute_cost(self, r):\n self.r_max = 1\n return np.exp(1 / (np.power(r, 2) - np.power(self.r_max, 2))) if r < self.r_max else 0","def fn(i, cost):\n if cost >= target or i == len(toppingCosts): return cost\n return min(fn(i+1, cost), fn(i+1, cost+toppingCosts[i]), key=lambda x: (abs(x-target), x))","def calc_cost(y, yhat, cost_matrix):\n return np.mean(cost_matrix[list(y), list(yhat)])","def compute_cost(self,X, y):\r\n num_examples = np.shape(X)[0]\r\n z = np.dot(X,self.theta) + self.bias\r\n exp_z = np.exp(z)\r\n softmax_scores = exp_z / np.sum(exp_z, axis=1, keepdims=True)\r\n \r\n one_hot_y = np.zeros((num_examples,np.max(y)+1))\r\n logloss = np.zeros((num_examples,)) \r\n for i in range(np.shape(X)[0]):\r\n one_hot_y[i,y[i]] = 1\r\n logloss[i] = -np.sum(np.log(softmax_scores[i,:]) * one_hot_y[i,:])\r\n data_loss = np.sum(logloss)\r\n return 1./num_examples * data_loss","def fixed_cost(self):\n return np.einsum('i->', self.c[self.f])","def calculateCost(self,sol,weights):\n\t\treturn sum([x.value*y if x != None else 0 \\\n\t\t\t\t\tfor x,y in zip(sol,weights)])","def cost_derivative(self,output_results,y):\r\n\t\treturn (output_results-y)","def get_cost(self, Y, T):\n return - np.multiply(T, np.log(Y)).sum() / Y.shape[0]","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 total_cost(self):\n return np.einsum('i->', self.c[self.s])","def compute_cost_derivative(AL, Y):\n pass","def fn(self, x):\n\n return math.exp(x*2) - math.exp(x) - 2","def fn(self, x):\n\n return math.exp(x*2) - math.exp(x) - 2","def cost_(self, y_hat, y, eps=1e-15):\n\t\treturn -(1 / y.shape[0]) * np.sum((y * np.log(y_hat + eps)) + (1 - y) * np.log(1 - y_hat + eps))","def cost_h(self, node, xg):\n h = (node.state - xg).T @ self.Q @ (node.state - xg)\n return float(h)","def cost(self, x, y):\n return self.cross_entropy_error(x,y) + self.l2_regularization_penalty()","def _apply_cost_xy(x, y, norm_x, norm_y, vec, cost_fn, cost_pow, fn=None):\n c = _cost(x, y, norm_x, norm_y, cost_fn, cost_pow)\n return jnp.dot(c, vec) if fn is None else jnp.dot(fn(c), vec)","def eval(self, x):\n return ( float(self.coeff.nominator) / self.coeff.denominator ) * ( x ** self.expt )","def running_cost(self, t_span, step_size, x):\n cost = 0\n ones = torch.ones(x.shape[1], 1, device=x.device)\n for idx,t in enumerate(t_span):\n input_nn = torch.cat([ones*t, x[idx,:,:]], 1)\n X_C_X = self.x_M_x(x[idx,:,:], self.C)\n alpha_t = self.func_ode.alpha(input_nn)\n alpha_D_alpha = self.x_M_x(alpha_t, self.D)\n cost += step_size*(X_C_X + alpha_D_alpha)\n return cost","def evaluate_cost(self, msg):\n raise NotImplementedError()","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 fn(i, j):\n if i == len(costs): return 0 # no more houses to paint \n return costs[i][j] + min(fn(i+1, jj) for jj in range(3) if j != jj)","def _cost(self, action):\n raise NotImplementedError","def cost(lossvalues):\n return np.sum(lossvalues ** 2) / (2 * lossvalues.shape[1])","def cost_matrix(x, y, p=2):\n xc = tf.expand_dims(x, 1)\n yr = tf.expand_dims(y, 0)\n d = tf.math.pow(tf.abs(xc - yr), p)\n return tf.reduce_sum(d, axis=-1)","def calculate_cost(theta_values, data):\n population = data[:,0]\n prices = data[:,1]\n total_error = 0\n for i in range(0,len(population)):\n x = array([[1],[population[i]]])\n hypothesis = theta_values.dot(x).flatten() \n squared_error = (hypothesis - prices[i])**2\n total_error += squared_error\n return .5*total_error/len(population) #division by m is just a scaling factor since we're only interested in whether this function is minimized","def getCostFunctionSlow(self, evalpts, observations):\n #XXX: update interface to allow metric?\n def _(params):\n v = self.getVectorCostFunction(evalpts, observations)\n x = v(params)\n return sum(real((conjugate(x)*x)))\n return _","def cost(self, sample):\n assert len(sample) == len(self.domain)\n\n tail = self.n - len(np.trim_zeros(sample, 'b'))\n head = self.n - len(np.trim_zeros(np.logical_not(sample), 'f'))\n Rxt = self.n if tail > self.T and head > self.T else 0\n return -float(max(head, tail) + Rxt)","def evaluate( self, x ) :\n\n P = 0.\n for c_l in reversed( self.coefficients ) : P = c_l + x * P\n return( P )","def easy_eval(self, x):\n answer = 0\n for i in range(len(self.coefficients)):\n coef = self.coefficients[i]\n degree = len(self.coefficients) - (i+1)\n answer += x ** degree * coef\n return answer","def cost_function(x, params, y, m):\n\n x_theta = np.matmul(x, params)\n hypothesis = vectorized_sigmoid_function(x_theta)\n\n return np.sum(np.log(hypothesis) * y + np.log(1 - hypothesis) * (1 - y)) * (-1 / m)","def prediction_cost(a, y):\n return np.sum(-(y * np.log(a) + (1 - y) * np.log(1 - a)))","def cost_func(w, X, y):\n y_pred = np.dot(X, w)\n err = np.sum(np.square(y_pred - y)) / (2 * len(y))\n\n return err","def get_cost_val(self, var_name, pos):\n return self.get_other_value(self.cost, var_name, pos)","def _cost_function(self, y_pred, y, m):\n sumatory = 0\n for x in range(m):\n sumatory += (y_pred[0][x] -y[0][x])**2\n\n cost = 1/(2*m) * sumatory\n return cost","def get_cost(self):\n\n\t\tx = self.symbolic_input\n\t\ty = self.get_reconstructed_input()\n\n\t\tnegative_log_loss = -theano.tensor.sum(x*theano.tensor.log(y) +\n\t\t\t(1-x)*theano.tensor.log(1-y), axis=1)\n\n\t\tmean_loss = theano.tensor.mean(negative_log_loss)\n\n\t\treturn mean_loss","def cost_function_no_reg (model, X, y):\n\n m = len (y)\n pred = model.predict (X)\n cost = 1. / (2. * m) * ((pred - y)**2).sum ()\n return (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"],"string":"[\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 cost(self,x):\\n Mx = self.generate_vector()\\n self.prior.M.mult(x,Mx)\\n return .5*Mx.inner(x)\",\n \"def final_cost(self, x):\\n return self.x_M_x(x[-1,:,:],self.R)\",\n \"def fn(x):\\n if x == 0: return 0\\n if x < 0: return -inf \\n return max(fn(x - c) * 10 + i + 1 for i, c in enumerate(cost))\",\n \"def cost(self) -> float:\",\n \"def c(x):\\n cost = per_widget_cost * x + fixed_cost\\n return cost\",\n \"def costFunction(self, x, y ):\\n self.yEst = self.forward_propagate(x)\\n sqErrors = ( self.yEst - y ) ** 2\\n J = sqErrors.sum() / 2\\n return J\",\n \"def __compute_cost(self, x, y):\\n\\n predictions = self.__compute_prediction(x)\\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\\n\\n return cost\",\n \"def compute_cost(AL, Y):\\n pass\",\n \"def cost_fun(x, problem):\\n j = 0\\n if problem['use_log_bar']:\\n c = ineqconstr(x, problem)\\n j += np.sum(logbarrierfunc(0.1, c, problem['use_sigma']))\\n\\n x, t_final = matrify(x, problem)\\n if problem['T']!=0:\\n j += np.sum([problem['cost_fun_single'](x[:, :, i], t_final, problem) for i in range(problem['Nv'])])\\n else:\\n j = t_final\\n return j\",\n \"def compute_cost(AL, Y):\\n pass\",\n \"def calculate_cost(x, y, weights):\\r\\n predictions = compute_prediction(x, weights)\\r\\n cost = np.mean(-y * np.log(predictions) - (1 - y) * np.log(1 - predictions))\\r\\n return cost\",\n \"def objective_function(x):\\n return x * 1 # change this to our actual function\",\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 cost_function(self, element):\\n return self.maze.cost(element)\",\n \"def get_cost(self) -> float:\\n return math.e / self.fitness\",\n \"def objective(self, x):\\n pass\",\n \"def objective(self, x):\\n pass\",\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 get_cost(self, action: Action) -> N:\\n pass\",\n \"def calcCostFun(self):\\n\\n self.start()\\n F, K = self.model()\\n \\n return self.costFunction\",\n \"def calc_cost(y, x, theta_1, theta_0):\\n h = theta_1 * x + theta_0\\n d = h - y\\n cost = np.dot(d.T, d) / (2*x.shape[0])\\n return cost.flat[0]\",\n \"def _cost(self, X, particle):\\n startprob, transmat = self._parse_particle(particle)\\n startprob, transmat = self._shape_probs(startprob, transmat)\\n return -self._compute_logprob(X, startprob, transmat, **self._params)\",\n \"def compute_cost(x, y, theta=[[0], [0]]):\\n m = y.size\\n h = x.dot(theta)\\n j = 1 / (2 * m) * np.sum(np.square(h - y))\\n return j\",\n \"def _cost_method(self, *args, **kwargs):\\n\\n cost_val = 0.5 * np.linalg.norm(self.obs_data - self.op(args[0])) ** 2\\n\\n if 'verbose' in kwargs and kwargs['verbose']:\\n print(' - DATA FIDELITY (X):', cost_val)\\n\\n return cost_val\",\n \"def _call(self, x):\\n tmp = x.asarray().flatten()\\n return self.range.element(self.cost_matrix.dot(tmp))\",\n \"def evaluate_cost(\\n self, x: Dict[str, ArrayType], p: Dict[str, ArrayType]\\n ) -> CasADiArrayType:\\n x = self.opt.decision_variables.dict2vec(x)\\n p = self.opt.parameters.dict2vec(p)\\n return self.opt.f(x, p)\",\n \"def calc_total_cost(self, X):\\n return self.sess.run(self.cost, feed_dict={self.x: X, self.scale: self.training_scale})\",\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 cost_from_X(self, data):\\n self.cost_from_X_data_specs()[0].validate(data)\\n X, Y = data\\n Y_hats= self.fprop(X)\\n return self.cost(Y, Y_hats)\",\n \"def cost_function (model, X, y, lambda_reg=0.):\\n\\n m = len (y)\\n pred = model.predict (X)\\n cost = 1. / (2. * m) * ((pred - y)**2).sum () + \\\\\\n lambda_reg / (2. * m) * (model.coef_**2).sum ()\\n return (cost)\",\n \"def cost(self, cost_object, target):\\n\\n return cost_object.f(self.a[-1], target).mean(axis=0).sum()\",\n \"def cost_function(self, config_samples):\\n cost = self.work_tracker(config_samples)\\n return cost\",\n \"def calculate_total_cost(state):\\r\\n return state.cost()\",\n \"def value(self, x):\\n f = self._objective(\\n time_series=self.observed_data,\\n a=x[0],\\n b=x[1],\\n c=x[2],\\n sigma=self.sigma\\n )\\n return f\",\n \"def __call__(self, x, u, k):\\n first_time_through = True\\n for cost, arg, weight in zip(self._costs, self._args, self._weights):\\n if arg == \\\"x\\\":\\n cost_input = x\\n else:\\n cost_input = u[arg]\\n\\n current_term = weight * cost(cost_input, k)\\n if current_term > 1e8:\\n print(\\\"Warning: cost %s is %f\\\" % (cost._name, current_term))\\n print(\\\"Input is: \\\", cost_input)\\n\\n# if cost._name[:4] == \\\"bike\\\":\\n# print(cost._name, \\\": \\\", current_term)\\n\\n if first_time_through:\\n total_cost = current_term\\n else:\\n total_cost += current_term\\n\\n first_time_through = False\\n\\n return total_cost\",\n \"def compute_cost(AL,Y,cost_function_name):\\n cost_functions = {\\n \\\"cost_func_1\\\": cf.cost_function_1\\n } \\n\\n activ_func = cost_functions.get(cost_function_name,lambda : \\\"Invalid Cost Function Name !\\\")\\n\\n cost,dAL = activ_func(AL,Y)\\n\\n return cost, dAL\",\n \"def cost(self, data_X, data_Y):\\n c = self.cost_function(data_Y, self.predict(data_X))\\n\\n if self.regularizer is not None:\\n c += self.regularizer.cost(self.particle_input, self.layers)\\n\\n return c\",\n \"def cost(self, X, y) :\\n ### ========== TODO : START ========== ###\\n # part d: compute J(theta)\\n #we know for linear/polynomial regression, the cost is the square of the errors\\n X = self.generate_polynomial_features(X)\\n y_pred_vector = np.dot(X, self.coef_)\\n cost = np.dot((y-y_pred_vector).transpose(),(y-y_pred_vector))#write in the matrix form\\n ### ========== TODO : END ========== ###\\n return cost\",\n \"def compute_objective(X, C):\\n # similar as mse\\n\\n acc = 0\\n for x in range(len(X)):\\n acc += (nearest_distance(X.iloc[x], C)) ** 2\\n\\n return acc\",\n \"def compute_cost_function(X, Y, theta, lambda_factor, temp_parameter):\\n h = compute_probabilities(X, theta, temp_parameter)\\n\\n cost = 0\\n for i in range(X.shape[0]):\\n for j in range(theta.shape[0]):\\n if Y[i] == j:\\n cost += np.log(h[j,i])\\n\\n cost = -cost / X.shape[0]\\n\\n theta = np.power(theta, 2)\\n\\n cost += lambda_factor / 2 * theta.sum()\\n\\n return cost\",\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 get_expected_cost(self):\",\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 cost(self, X=None, y=None):\\n\\t\\tif X is None:\\n\\t\\t\\tX = self.x_data\\n\\t\\telse:\\n\\t\\t\\tn_samples = np.size(X, 0)\\n\\t\\t\\tX = np.hstack((np.ones((n_samples, 1)), (X - np.mean(X,0)) / np.std(X,0)))\\n\\n\\t\\tif y is None:\\n\\t\\t\\ty = self.y_data\\n\\t\\telse:\\n\\t\\t\\ty = y[:, np.newaxis]\\n\\n\\t\\ty_pred = X @ self.weights\\n\\n\\t\\t# SSE formula\\n\\t\\tcost = 1 - (((y - y_pred) ** 2 ).sum() / ((y- y.mean())** 2).sum())\\n\\n\\t\\treturn cost\",\n \"def compute_cost(features, values, theta):\\n\\n npoints = len(values)\\n sum_of_square_errors = np.square(np.dot(features, theta) - values).sum()\\n cost = sum_of_square_errors / (2*npoints)\\n\\n return cost\",\n \"def get_action_cost(state: tuple, action: int) -> float:\\n assert len(state) == 3 and state[0] < 5 and state[1] < 4 and state[2] < 3 and action < 3\\n if state[0] == 0:\\n return 0.0\\n if state[0] == 1 and action == 0:\\n return -20.0 + 10.0 * 0.5\\n return -20.0 # Penalty = 20 due to Team Number = 9\",\n \"def cost(self):\\n\\t\\treturn self.g + self.h\",\n \"def calculate_total_cost(state):\\n pass\",\n \"def eval_cost(self, params, **kwargs):\\n raise NotImplementedError\",\n \"def cost_total(X, cost_weights=(1.0, 1.0, 1.0)):\\n return cost_weights[0] * cost_distance(X) + \\\\\\n cost_weights[1] * cost_same_team_by_distance(X) + \\\\\\n cost_weights[2] * cost_previous_neighbour_by_distance(X, normalize=True)\",\n \"def compute_cost(self,X, y):\\n \\n num_samples = len(X)\\n # Do Forward propagation to calculate our predictions\\n z1 = X.dot(self.W1) + self.b1\\n a1 = np.tanh(z1)\\n z2 = a1.dot(self.W2) + self.b2\\n exp_z = np.exp(z2)\\n a2 = exp_z / np.sum(exp_z, axis=1, keepdims=True)\\n softmax_scores = a2\\n # Calculate the cross-entropy loss\\n cross_ent_err = -np.log(softmax_scores[range(num_samples), y])\\n data_loss = np.sum(cross_ent_err)\\n return 1./num_samples * data_loss\",\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 optimize(self, x0):\\n (result,f,d) = fmin_l_bfgs_b(lambda x:self.costFun(x), np.ravel(x0),lambda x: self.gradFun(x))\\n print(\\\"optimization completed with cost: \\\" + str(f))\\n return result.reshape(self.inp_shape)\",\n \"def getCostFunction(self, evalpts, observations, sigma=None, metric=lambda x: sum(x*x)):\\n #XXX: better interface for sigma?\\n def _(params):\\n ind = 0\\n for F, n, ofilt, icheck in zip(self._forwardFactories, self._inputs, \\\\\\n self._outputFilters, self._inputCheckers):\\n # check input #XXX: is this worthwile to do?\\n my_params = params[ind:ind+n]\\n checkQ = icheck(my_params, evalpts)\\n if checkQ is not None:\\n # some parameters are out of range... returns \\\"cost\\\"\\n return checkQ\\n\\n Gm = F(params[ind:ind+n])\\n if ind == 0:\\n x = ofilt(Gm(evalpts)) \\n else:\\n x = x + ofilt(Gm(evalpts)) \\n ind = ind+n\\n if sigma is None:\\n x = x - observations\\n else:\\n x = (x - observations) / sigma\\n #return sum(real((conjugate(x)*x)))\\n #return sum(x*x) \\n return metric(x)\\n return _\",\n \"def compute_cost(features, values, theta):\\n m = len(values)\\n sum_of_square_errors = np.square(np.dot(features, theta) - values).sum()\\n cost = sum_of_square_errors / (2 * m)\\n\\n return cost\",\n \"def cost_function(data_x, data_y, parameters):\\n # Residual sum of squares\\n rss = np.sum((data_x @ parameters - data_y) ** 2)\\n\\n # Number of rows times 2\\n nb_rows_x2 = 2 * data_x.shape[0]\\n\\n return rss / nb_rows_x2\",\n \"def cost_function(theta, X, y):\\n\\n l = None\\n #######################################################################\\n # TODO: #\\n # Compute and return the cost l of a particular choice of #\\n # theta. #\\n # #\\n #######################################################################\\n thetaX = np.dot(X, theta)\\n g = tanh(thetaX)-y\\n l = np.sum(g*g) / X.shape[0]\\n \\n #######################################################################\\n # END OF YOUR CODE #\\n #######################################################################\\n return l\",\n \"def compute_cost(y, tx, w):\\n # ***************************************************\\n # INSERT YOUR CODE HERE\\n # TODO: compute loss by MSE / MAE\\n # ***************************************************\\n \\n # vector e\\n e = compute_e(y, tx, w)\\n N = compute_N(e)\\n L_MSE = np.dot(np.matrix.transpose(e), e)\\n L_MSE = L_MSE / (2 * N)\\n \\n return L_MSE\",\n \"def prediction_cost(a, y):\\n return np.sum((a - y) ** 2) / 2\",\n \"def getCost(self, state, action):\\n util.raiseNotDefined()\",\n \"def compute_cost(self, r):\\n self.r_max = 1\\n return np.exp(1 / (np.power(r, 2) - np.power(self.r_max, 2))) if r < self.r_max else 0\",\n \"def fn(i, cost):\\n if cost >= target or i == len(toppingCosts): return cost\\n return min(fn(i+1, cost), fn(i+1, cost+toppingCosts[i]), key=lambda x: (abs(x-target), x))\",\n \"def calc_cost(y, yhat, cost_matrix):\\n return np.mean(cost_matrix[list(y), list(yhat)])\",\n \"def compute_cost(self,X, y):\\r\\n num_examples = np.shape(X)[0]\\r\\n z = np.dot(X,self.theta) + self.bias\\r\\n exp_z = np.exp(z)\\r\\n softmax_scores = exp_z / np.sum(exp_z, axis=1, keepdims=True)\\r\\n \\r\\n one_hot_y = np.zeros((num_examples,np.max(y)+1))\\r\\n logloss = np.zeros((num_examples,)) \\r\\n for i in range(np.shape(X)[0]):\\r\\n one_hot_y[i,y[i]] = 1\\r\\n logloss[i] = -np.sum(np.log(softmax_scores[i,:]) * one_hot_y[i,:])\\r\\n data_loss = np.sum(logloss)\\r\\n return 1./num_examples * data_loss\",\n \"def fixed_cost(self):\\n return np.einsum('i->', self.c[self.f])\",\n \"def calculateCost(self,sol,weights):\\n\\t\\treturn sum([x.value*y if x != None else 0 \\\\\\n\\t\\t\\t\\t\\tfor x,y in zip(sol,weights)])\",\n \"def cost_derivative(self,output_results,y):\\r\\n\\t\\treturn (output_results-y)\",\n \"def get_cost(self, Y, T):\\n return - np.multiply(T, np.log(Y)).sum() / Y.shape[0]\",\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 total_cost(self):\\n return np.einsum('i->', self.c[self.s])\",\n \"def compute_cost_derivative(AL, Y):\\n pass\",\n \"def fn(self, x):\\n\\n return math.exp(x*2) - math.exp(x) - 2\",\n \"def fn(self, x):\\n\\n return math.exp(x*2) - math.exp(x) - 2\",\n \"def cost_(self, y_hat, y, eps=1e-15):\\n\\t\\treturn -(1 / y.shape[0]) * np.sum((y * np.log(y_hat + eps)) + (1 - y) * np.log(1 - y_hat + eps))\",\n \"def cost_h(self, node, xg):\\n h = (node.state - xg).T @ self.Q @ (node.state - xg)\\n return float(h)\",\n \"def cost(self, x, y):\\n return self.cross_entropy_error(x,y) + self.l2_regularization_penalty()\",\n \"def _apply_cost_xy(x, y, norm_x, norm_y, vec, cost_fn, cost_pow, fn=None):\\n c = _cost(x, y, norm_x, norm_y, cost_fn, cost_pow)\\n return jnp.dot(c, vec) if fn is None else jnp.dot(fn(c), vec)\",\n \"def eval(self, x):\\n return ( float(self.coeff.nominator) / self.coeff.denominator ) * ( x ** self.expt )\",\n \"def running_cost(self, t_span, step_size, x):\\n cost = 0\\n ones = torch.ones(x.shape[1], 1, device=x.device)\\n for idx,t in enumerate(t_span):\\n input_nn = torch.cat([ones*t, x[idx,:,:]], 1)\\n X_C_X = self.x_M_x(x[idx,:,:], self.C)\\n alpha_t = self.func_ode.alpha(input_nn)\\n alpha_D_alpha = self.x_M_x(alpha_t, self.D)\\n cost += step_size*(X_C_X + alpha_D_alpha)\\n return cost\",\n \"def evaluate_cost(self, msg):\\n raise NotImplementedError()\",\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 fn(i, j):\\n if i == len(costs): return 0 # no more houses to paint \\n return costs[i][j] + min(fn(i+1, jj) for jj in range(3) if j != jj)\",\n \"def _cost(self, action):\\n raise NotImplementedError\",\n \"def cost(lossvalues):\\n return np.sum(lossvalues ** 2) / (2 * lossvalues.shape[1])\",\n \"def cost_matrix(x, y, p=2):\\n xc = tf.expand_dims(x, 1)\\n yr = tf.expand_dims(y, 0)\\n d = tf.math.pow(tf.abs(xc - yr), p)\\n return tf.reduce_sum(d, axis=-1)\",\n \"def calculate_cost(theta_values, data):\\n population = data[:,0]\\n prices = data[:,1]\\n total_error = 0\\n for i in range(0,len(population)):\\n x = array([[1],[population[i]]])\\n hypothesis = theta_values.dot(x).flatten() \\n squared_error = (hypothesis - prices[i])**2\\n total_error += squared_error\\n return .5*total_error/len(population) #division by m is just a scaling factor since we're only interested in whether this function is minimized\",\n \"def getCostFunctionSlow(self, evalpts, observations):\\n #XXX: update interface to allow metric?\\n def _(params):\\n v = self.getVectorCostFunction(evalpts, observations)\\n x = v(params)\\n return sum(real((conjugate(x)*x)))\\n return _\",\n \"def cost(self, sample):\\n assert len(sample) == len(self.domain)\\n\\n tail = self.n - len(np.trim_zeros(sample, 'b'))\\n head = self.n - len(np.trim_zeros(np.logical_not(sample), 'f'))\\n Rxt = self.n if tail > self.T and head > self.T else 0\\n return -float(max(head, tail) + Rxt)\",\n \"def evaluate( self, x ) :\\n\\n P = 0.\\n for c_l in reversed( self.coefficients ) : P = c_l + x * P\\n return( P )\",\n \"def easy_eval(self, x):\\n answer = 0\\n for i in range(len(self.coefficients)):\\n coef = self.coefficients[i]\\n degree = len(self.coefficients) - (i+1)\\n answer += x ** degree * coef\\n return answer\",\n \"def cost_function(x, params, y, m):\\n\\n x_theta = np.matmul(x, params)\\n hypothesis = vectorized_sigmoid_function(x_theta)\\n\\n return np.sum(np.log(hypothesis) * y + np.log(1 - hypothesis) * (1 - y)) * (-1 / m)\",\n \"def prediction_cost(a, y):\\n return np.sum(-(y * np.log(a) + (1 - y) * np.log(1 - a)))\",\n \"def cost_func(w, X, y):\\n y_pred = np.dot(X, w)\\n err = np.sum(np.square(y_pred - y)) / (2 * len(y))\\n\\n return err\",\n \"def get_cost_val(self, var_name, pos):\\n return self.get_other_value(self.cost, var_name, pos)\",\n \"def _cost_function(self, y_pred, y, m):\\n sumatory = 0\\n for x in range(m):\\n sumatory += (y_pred[0][x] -y[0][x])**2\\n\\n cost = 1/(2*m) * sumatory\\n return cost\",\n \"def get_cost(self):\\n\\n\\t\\tx = self.symbolic_input\\n\\t\\ty = self.get_reconstructed_input()\\n\\n\\t\\tnegative_log_loss = -theano.tensor.sum(x*theano.tensor.log(y) +\\n\\t\\t\\t(1-x)*theano.tensor.log(1-y), axis=1)\\n\\n\\t\\tmean_loss = theano.tensor.mean(negative_log_loss)\\n\\n\\t\\treturn mean_loss\",\n \"def cost_function_no_reg (model, X, y):\\n\\n m = len (y)\\n pred = model.predict (X)\\n cost = 1. / (2. * m) * ((pred - y)**2).sum ()\\n return (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]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.820668","0.7995505","0.7497831","0.74943554","0.72771204","0.72714454","0.724877","0.7232135","0.72299874","0.72011256","0.7193746","0.7113412","0.7009601","0.69141775","0.68879235","0.6861625","0.67966616","0.67966616","0.67889404","0.6746737","0.674264","0.6732482","0.6699713","0.66988903","0.66848457","0.66827816","0.66824543","0.66770774","0.66524637","0.6650004","0.6648322","0.6592004","0.6586702","0.6578686","0.6546608","0.65286237","0.6519836","0.6500097","0.6498085","0.6493202","0.6478913","0.6478499","0.6475146","0.64654005","0.6453717","0.6452941","0.6451938","0.6449452","0.6443246","0.6435242","0.643087","0.64158744","0.6413716","0.64099","0.64094526","0.64075005","0.64057136","0.64052665","0.6402028","0.63797694","0.6370514","0.636845","0.63617885","0.6355563","0.63480794","0.6346398","0.63409764","0.63382745","0.63234687","0.6322731","0.63193595","0.63068783","0.62926275","0.62926275","0.62887263","0.6281978","0.6271723","0.62571675","0.62542546","0.6252521","0.62375927","0.6234182","0.6233611","0.62254727","0.62206024","0.6219245","0.6218334","0.6213759","0.6181573","0.61668473","0.61599743","0.6156328","0.6153567","0.6150885","0.61361545","0.6133807","0.6133249","0.6132286","0.61243653","0.61243653"],"string":"[\n \"0.820668\",\n \"0.7995505\",\n \"0.7497831\",\n \"0.74943554\",\n \"0.72771204\",\n \"0.72714454\",\n \"0.724877\",\n \"0.7232135\",\n \"0.72299874\",\n \"0.72011256\",\n \"0.7193746\",\n \"0.7113412\",\n \"0.7009601\",\n \"0.69141775\",\n \"0.68879235\",\n \"0.6861625\",\n \"0.67966616\",\n \"0.67966616\",\n \"0.67889404\",\n \"0.6746737\",\n \"0.674264\",\n \"0.6732482\",\n \"0.6699713\",\n \"0.66988903\",\n \"0.66848457\",\n \"0.66827816\",\n \"0.66824543\",\n \"0.66770774\",\n \"0.66524637\",\n \"0.6650004\",\n \"0.6648322\",\n \"0.6592004\",\n \"0.6586702\",\n \"0.6578686\",\n \"0.6546608\",\n \"0.65286237\",\n \"0.6519836\",\n \"0.6500097\",\n \"0.6498085\",\n \"0.6493202\",\n \"0.6478913\",\n \"0.6478499\",\n \"0.6475146\",\n \"0.64654005\",\n \"0.6453717\",\n \"0.6452941\",\n \"0.6451938\",\n \"0.6449452\",\n \"0.6443246\",\n \"0.6435242\",\n \"0.643087\",\n \"0.64158744\",\n \"0.6413716\",\n \"0.64099\",\n \"0.64094526\",\n \"0.64075005\",\n \"0.64057136\",\n \"0.64052665\",\n \"0.6402028\",\n \"0.63797694\",\n \"0.6370514\",\n \"0.636845\",\n \"0.63617885\",\n \"0.6355563\",\n \"0.63480794\",\n \"0.6346398\",\n \"0.63409764\",\n \"0.63382745\",\n \"0.63234687\",\n \"0.6322731\",\n \"0.63193595\",\n \"0.63068783\",\n \"0.62926275\",\n \"0.62926275\",\n \"0.62887263\",\n \"0.6281978\",\n \"0.6271723\",\n \"0.62571675\",\n \"0.62542546\",\n \"0.6252521\",\n \"0.62375927\",\n \"0.6234182\",\n \"0.6233611\",\n \"0.62254727\",\n \"0.62206024\",\n \"0.6219245\",\n \"0.6218334\",\n \"0.6213759\",\n \"0.6181573\",\n \"0.61668473\",\n \"0.61599743\",\n \"0.6156328\",\n \"0.6153567\",\n \"0.6150885\",\n \"0.61361545\",\n \"0.6133807\",\n \"0.6133249\",\n \"0.6132286\",\n \"0.61243653\",\n \"0.61243653\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8048273"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":84785,"cells":{"query":{"kind":"string","value":"Function that computes the gradient of the cost function at x"},"document":{"kind":"string","value":"def gradFun(self, S, x):"},"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 gradient(self, x):\n pass","def gradient(cls, x):\n y = Sigmoid.apply(x)\n return np.multiply(y, 1 - y)","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 gradientdescent(cost_func, theta, args=(), delta_func = 0):\n step = 1\n old_cost = 0\n while True:\n theta_old = theta.copy()\n cost = cost_func(theta, *args)\n delta = delta_func(theta, *args)\n theta = theta - step * delta\n if cost > old_cost and old_cost != 0:\n step = step*0.7\n if np.allclose(theta_old, theta):\n break\n old_cost = cost\n return theta","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 compute_gradient(theta, X, y):\n m = X.shape[0]\n grad_theta = np.dot(X.transpose(), (np.dot(X, theta) - y)) / m\n #print theta, grad_theta, objective_function(theta, X, y)\n return grad_theta","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 logit_cost_grad(self, theta, X, y):\n\n grad = np.zeros(len(theta))\n\n ### YOUR CODE HERE\n sig = utils.sigmoid(theta)\n # sig = np.subtract(sig, y)\n sig = sig - y\n grad = np.dot(X.T, sig) + 2 * self.params['lamb'] * self.regularizer[1](self.weights)\n ### END YOUR CODE\n\n return grad","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 gradient_function(theta, X, y):\n\n grad = None\n #######################################################################\n # TODO: #\n # Compute the gradient for a particular choice of theta. #\n # 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 \n theta = theta[:, np.newaxis]\n \n thetatrans = theta.T\n Xtrans = X.T\n \n MulThetaX = np.dot(thetatrans, Xtrans)\n \n h = sigmoid(MulThetaX)\n \n grad = (y - h) * Xtrans\n\n #######################################################################\n # END OF YOUR CODE #\n #######################################################################\n return grad","def gradient(w, x, t):\n return 2 * np.dot(x.T, (nn(x, w) - t))","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 gradientFunctionReg(theta, X, y, Lambda):\n m = len(y) # number of training examples\n grad = np.zeros(theta.shape[0])\n theta = np.transpose(theta)\n sum_1 = 0\n X = X.values\n y = y.values\n #calcuate the theta_0 \n# ====================== YOUR CODE HERE ======================\n# Instructions: Compute the gradient of a particular choice of theta.\n# Compute the partial derivatives and set grad to the partial\n# derivatives of the cost w.r.t. each parameter in theta\n for i in range(theta.shape[0]):\n if i == 0:\n for j in range(m):\n sum_1 += (sigmoid(np.dot(X[j],theta)) - y[j]) * X[j,i]\n else:\n for j in range(m):\n sum_1 += (sigmoid(np.dot(X[j],theta)) - y[j]) * X[j,i] + Lambda*theta[i]\n grad[i] = sum_1/m\n sum_1 = 0\n\n# =============================================================\n\n return grad","def gradient(cls, x):\n return 1 - TanH.apply(x) ** 2","def objective_function_gradients(self, x):\n self._set_params_transformed(x)\n LL_gradients = self._transform_gradients(self._log_likelihood_gradients())\n prior_gradients = self._transform_gradients(self._log_prior_gradients())\n return - LL_gradients - prior_gradients","def gradient(self, x):\n return 0.0","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 gradient(self, x):\n g = self._grad(\n time_series=self.observed_data,\n a=x[0],\n b=x[1],\n c=x[2],\n sigma=self.sigma\n )\n return g","def grad(x):\n\n return x - np.arange(1, cfg.n + 1, dtype=np.float_)","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 gradient(self, x, i=None):\n self.set_parameters(x=x)\n gradient = self.gradient_loss()\n if self.add_bias:\n gradient[1:] += self.alpha * self.gradient_regularizer()\n else:\n gradient += self.alpha * self.gradient_regularizer()\n if i is not None:\n return gradient.ravel()[i]\n return gradient.ravel()","def numerical_gradient(f, x: np.ndarray):\n h = 1e-4\n grad = np.zeros_like(x)\n for i in range(x.size):\n tmp_val = x.flat[i]\n x.flat[i] = tmp_val + h\n fxh1 = f(x)\n\n x.flat[i] = tmp_val - h\n fxh2 = f(x)\n grad.flat[i] = (fxh1 - fxh2) / (2 * h)\n x.flat[i] = tmp_val\n return grad","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 objective_function_gradients(self, x):\r\n try:\r\n self._set_params_transformed(x)\r\n obj_grads = -self._transform_gradients(self._log_likelihood_gradients() + self._log_prior_gradients())\r\n self._fail_count = 0\r\n except (LinAlgError, ZeroDivisionError, ValueError) as e:\r\n if self._fail_count >= self._allowed_failures:\r\n raise e\r\n self._fail_count += 1\r\n obj_grads = np.clip(-self._transform_gradients(self._log_likelihood_gradients() + self._log_prior_gradients()), -1e100, 1e100)\r\n return obj_grads","def approx_grad(theta, X, y):\n grad_a = np.array([(cost(theta + e, X, y) - cost(theta - e, X, y)) / (2 * 1e-5)\n for e in np.identity(len(theta)) * 1e-5])\n return grad_a","def gradient(theta, X, y, learning_rate):\n m = len(y)\n\n theta = theta.reshape((-1,1))\n grad = np.zeros(theta.shape)\n h = sigmoid(np.dot(X, theta)) \n \n grad = np.dot((h-y).T, X)/m\n grad = grad.T\n grad[1:] += (learning_rate/m)*theta[1:]\n return grad","def grad(self, x):\n grad = np.zeros((x.shape[0], 1))\n grad[x >= utils.TOLERANCE] = 1.0\n grad[x <= -utils.TOLERANCE] = -1.0\n between = (x > -utils.TOLERANCE) & (x < utils.TOLERANCE)\n grad[between] = self.rng(between.sum())\n\n return self.l * grad","def compute_gradient(self, X, y, weights):\n sigmoid = self.sigmoid(np.dot(X, weights))\n return np.dot(X.T, y - sigmoid)","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 eval_numerical_gradient(f,x):\n\n\tgrad = np.zeros(x.shape)\n\th = 0.0001\n\n\t# iterate over all indexes in x\n\tit = np.nditer(x, flag = ['multi_index'], op_flags = ['readwrite'])\n\n\twhile not it.finished:\n\t\tix = it.multi_index\n\t\told_value = x[ix]\n\n\t\tx[ix] = old_value + h\n\t\tfxh_left = f(x)\n\n\t\tx[ix] = old_value - h\n\t\tfxh_right = f(x)\n\n\t\tx[ix] = old_value\n\n\t\t# compute the partial derivative\n\t\tgrad[ix] = (fxh_left - fxh_right) / (2 * h)\n\t\tit.iterate()\n\n\treturn grad","def gradient(self, x_in):\r\n\r\n return 1 - torch.pow(self.forward(x_in), 2)","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 calc_gradient_at(self, x: np.ndarray) -> np.ndarray:\n\n if self.gradient_f:\n # if the problem has knowledge about the gradient, use it directly without approximation\n return self.gradient_f(x)\n\n return gradient_approximation(self.f, x)","def lrCostFunction(theta,X,y, lambda_reg):\n m = np.size(y)\n grad = np.zeros(np.size((theta)))\n J_base, grad = costFunction(theta, X, y)\n \n\n reg_cost = (lambda_reg / (2.0 * m)) * np.sum(theta[1:] ** 2)\n \n reg_gradient = (lambda_reg / m) * theta\n reg_gradient[0] = 0\n cost = J_base + reg_cost\n return cost, grad + reg_gradient","def gradient_descent(self, x, y):\n # Initialize weights vector\n self.weights = np.zeros(len(x[0]))\n\n # Storing number of training example in a variable \n n = len(x)\n\n # Initiate variables to keep track of the current and smallest loss recorded\n lowest_loss = sys.float_info.max\n current_loss = sys.float_info.max\n\n # Initiate variables to keep track of step sizes\n norm = sys.float_info.max\n smallest_norm = sys.float_info.max\n\n # Initiate list variable that stores all previous weights\n prev_weights = []\n\n # Initiate list that stores all the errors. \n errors = []\n \n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\n k_loss_iteration = 1\n\n # Learning loop\n for i in range(self.max_iter):\n\n # Append current weights\n prev_weights.append(np.array(self.weights))\n \n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\n\n # Compute the error of the Cost Function and store it in a list\n current_loss = self.cost(x,y)\n\n if len(errors) > 1 and current_loss > errors[-1]:\n k_loss_iteration += 1\n else: \n k_loss_iteration = 1\n\n errors.append(current_loss)\n \n # Track smallest loss\n if current_loss < lowest_loss:\n lowest_loss = current_loss\n\n # Compute the L2 Norm of the difference between current weights and previous weights\n norm = np.linalg.norm(self.weights - prev_weights[-1])\n\n # Track smallest step size and set it as error threshold\n if norm < smallest_norm:\n smallest_norm = norm\n\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\n if self.error_threshold != None and norm < self.error_threshold:\n print(\"Converged after {} iterations!\".format(i))\n break\n\n # stop if error hasn't gone down in k iterations\n if k_loss_iteration >= 10:\n print(k_loss_iteration + \" iterations of loss not decreasing on {}th itertion.\".format(i))\n break\n\n # Log final weights\n print(\"Final norm: \" + str(norm) + \"\\nSmallest step size recorded: \" + str(smallest_norm) + \"\\nFinal error: \" + str(current_loss) + \"\\nLowest error recorded: \" + str(lowest_loss) + \"\\nNumber of epochs: \" + str(len(errors)) + \"\\nFinal weights: \" + str(self.weights))","def gradient_descent(X, y, theta, learning_rate, num_iters, lambda_reg):\n thetas = [theta]\n cost = np.zeros(num_iters)\n\n J = mean_cross_entropy_costs(X, y, lambda_reg)\n cost[0] = J(thetas[0])\n for i in range(1, num_iters):\n thetas.append(compute_new_theta(X, y, thetas[i - 1], learning_rate, lambda_reg))\n cost[i] = J(thetas[i])\n return cost, thetas","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 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 costFunction(self,theta, X, y): \n m = len(y)\n h = self.sigmoid(X@theta)\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \n # grad = 1/ m * X.T @ (h - y)\n return J","def gradient_descent(data_x, data_y, parameters, learn_rate, nb_iterations):\n\n # Cost history\n cost_tracking = np.zeros(nb_iterations)\n\n for _i in range(nb_iterations):\n parameters -= learn_rate * gradient(data_x, data_y, parameters)\n # recording the cost for each iteration\n cost_tracking[_i] = cost_function(data_x, data_y, parameters)\n\n return parameters, cost_tracking","def gradient(f, x, s=_DEFAULT_STEP):\n x = np.asarray(x)\n n = len(x)\n e = np.eye(n)\n\n forw = np.zeros(n)\n for i in range(n):\n forw[i] = f(x + s*e[i])\n\n g = (forw - f(x)) / s\n return g","def gradient(self):\n functional = self\n\n class KLCCGradient(Operator):\n\n \"\"\"The gradient operator of this functional.\"\"\"\n\n def __init__(self):\n \"\"\"Initialize a new instance.\"\"\"\n super().__init__(functional.domain, functional.domain,\n linear=False)\n\n def _call(self, x):\n \"\"\"Apply the gradient operator to the given point.\n\n The gradient is not defined in points where one or more\n components are larger than or equal to one.\n \"\"\"\n if functional.prior is None:\n return 1.0 / (1 - x)\n else:\n return functional.prior / (1 - x)\n\n return KLCCGradient()","def compute_gradient(self, grad=None):\n if grad is None:\n grad = backend.ones_like(self.output_value)\n x, = self.input_nodes[0].output_value\n return backend.exp(x) * grad","def gradient(data_x, data_y, parameters):\n return data_x.T @ (data_x @ parameters - data_y) / data_x.shape[0]","def approx_grad_reg(theta, X, y, _lambda):\n grad_a = np.array([(cost_reg(theta + e, X, y, _lambda) - cost_reg(theta - e, X, y, _lambda)) / (2 * 1e-5)\n for e in np.identity(len(theta)) * 1e-5])\n return grad_a","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 compute_gradient(self, function, arguments):","def lr_cost_function(theta, X, y, learning_rate):\n m = len(y) # number of training examples\n # You need to return the following variables correctly \n J = 0\n grad = np.zeros(theta.shape)\n h = sigmoid(np.dot(X, theta))\n\n #Compute cost:\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\n J = first + second\n \n #Compute gradient\n grad = np.dot((h-y).T, X)/m\n grad = grad.T\n grad[1:] += (learning_rate/m)*theta[1:]\n return float(J), grad","def compute_cost_derivative(AL, Y):\n pass","def gradient(self):\n functional = self\n\n class KLGradient(Operator):\n\n \"\"\"The gradient operator of this functional.\"\"\"\n\n def __init__(self):\n \"\"\"Initialize a new instance.\"\"\"\n super().__init__(functional.domain, functional.domain,\n linear=False)\n\n def _call(self, x):\n \"\"\"Apply the gradient operator to the given point.\n The gradient is not defined in points where one or more\n components are non-positive.\n \"\"\"\n if functional.prior is None:\n return (-1.0) / x + 1\n else:\n return (-functional.prior) / x + 1\n\n return KLGradient()","def loss_gradient(self, x, y):\n x_preproc = self._apply_processing(x)\n x_defences, y_defences = self._apply_defences(x_preproc, y, fit=False)\n\n # Adjust the shape of y for loss functions that do not take labels in one-hot encoding\n if self._reduce_labels:\n y_defences = np.argmax(y_defences, axis=1)\n\n grads = self._loss_grads([x_defences, y_defences])[0]\n grads = self._apply_defences_gradient(x_preproc, grads)\n grads = self._apply_processing_gradient(grads)\n assert grads.shape == x_preproc.shape\n\n return grads","def calculate_gradient(y, tx, w): \n return tx.T@(sigmoid(tx@w)-y)","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 grad(\n cost: Optional[Variable],\n wrt: Union[Variable, Sequence[Variable]],\n consider_constant: Optional[Sequence[Variable]] = None,\n disconnected_inputs: Literal[\"ignore\", \"warn\", \"raise\"] = \"raise\",\n add_names: bool = True,\n known_grads: Optional[Mapping[Variable, Variable]] = None,\n return_disconnected: Literal[\"none\", \"zero\", \"disconnected\"] = \"zero\",\n null_gradients: Literal[\"raise\", \"return\"] = \"raise\",\n) -> Union[Optional[Variable], Sequence[Optional[Variable]]]:\n t0 = time.perf_counter()\n\n if cost is None:\n if known_grads is None:\n raise ValueError(\"cost and known_grads can't both be None.\")\n\n if cost is not None and isinstance(cost.type, NullType):\n raise ValueError(\n \"Can't differentiate a NaN cost. \"\n f\"Cost is NaN because {cost.type.why_null}\"\n )\n\n if cost is not None and cost.type.ndim != 0:\n raise TypeError(\"Cost must be a scalar.\")\n\n if not isinstance(wrt, Sequence):\n _wrt: List[Variable] = [wrt]\n else:\n _wrt = [x for x in wrt]\n\n outputs = []\n if cost is not None:\n outputs.append(cost)\n if known_grads is not None:\n outputs.extend(list(known_grads.keys()))\n\n var_to_app_to_idx = _populate_var_to_app_to_idx(outputs, _wrt, consider_constant)\n\n # build a dict mapping var to the gradient of cost with respect to var\n grad_dict = {}\n\n if known_grads is None:\n known_grads = {}\n\n assert isinstance(known_grads, dict)\n\n # The gradient of the cost is 1 unless specified otherwise by known_grads.\n if cost is not None:\n if cost in known_grads:\n g_cost = known_grads[cost]\n else:\n g_cost = _float_ones_like(cost)\n # g_cost may be Disconnected or NullType. A creative use of the\n # function, sure, but nonetheless one we can and should support.\n # So before we try to cast it make sure it even has a dtype\n if (\n hasattr(g_cost.type, \"dtype\")\n and cost.type.dtype in aesara.tensor.type.continuous_dtypes\n ):\n # Here we enforce the constraint that floating point variables\n # have the same dtype as their gradient.\n g_cost = g_cost.astype(cost.type.dtype)\n # DO NOT enforce g_cost to be 0 if cost is an integer.\n # This is to be enforced by the Op.grad method for the\n # Op that outputs cost.\n if hasattr(g_cost.type, \"dtype\"):\n assert g_cost.type.dtype in aesara.tensor.type.continuous_dtypes\n\n grad_dict[cost] = g_cost\n\n for var in known_grads:\n g_var = known_grads[var]\n\n if not hasattr(g_var, \"type\"):\n raise TypeError(\n \"output grads must be aesara variables.\"\n f\"Ambiguous whether {type(g_var)} should be made into tensor\"\n \" or sparse aesara variable\"\n )\n\n if not isinstance(\n g_var.type, (NullType, DisconnectedType)\n ) and \"float\" not in str(g_var.type.dtype):\n raise TypeError(\n \"Gradients must always be NullType, \"\n \"DisconnectedType, or continuous, but grad was \"\n \"given a known_grad of type \" + str(g_var.type)\n )\n\n # DO NOT check that these gradients are equal to 0 if var is int\n # The gradient is allowed to be non-zero on var in that case\n # Ops outputting var should not backpropagate its gradient further\n # but that is enforced elsewhere (grep for only_connected_to_int)\n\n grad_dict[var] = g_var\n\n def handle_disconnected(var):\n message = (\n \"grad method was asked to compute the gradient \"\n \"with respect to a variable that is not part of \"\n \"the computational graph of the cost, or is used \"\n f\"only by a non-differentiable operator: {var}\"\n )\n if disconnected_inputs == \"ignore\":\n pass\n elif disconnected_inputs == \"warn\":\n warnings.warn(message, stacklevel=2)\n elif disconnected_inputs == \"raise\":\n message = utils.get_variable_trace_string(var)\n raise DisconnectedInputError(message)\n else:\n raise ValueError(\n \"Invalid value for keyword \"\n \"'disconnected_inputs', valid values are \"\n \"'ignore', 'warn' and 'raise'.\"\n )\n\n # variables that do not influence the cost have zero gradient.\n # if wrt is such a variable, populate the grad_dict with this info\n # so that wrt not being in var_to_app_to_idx won't cause an error below\n # according to the flag, possibly raise an error if wrt is disconnected\n for elem in _wrt:\n if elem not in var_to_app_to_idx and elem is not cost and elem not in grad_dict:\n handle_disconnected(elem)\n grad_dict[elem] = disconnected_type()\n\n cost_name = None\n if add_names and cost is not None:\n cost_name = cost.name\n\n # Make sure we didn't initialize the grad_dict with any ints\n # The gradient may NEVER be an int, even if the variable is an int.\n # Read the Op contract and talk to Ian Goodfellow before changing this!\n for var in grad_dict:\n g = grad_dict[var]\n if hasattr(g.type, \"dtype\"):\n assert g.type.dtype in aesara.tensor.type.float_dtypes\n\n _rval: Sequence[Variable] = _populate_grad_dict(\n var_to_app_to_idx, grad_dict, _wrt, cost_name\n )\n\n rval: MutableSequence[Optional[Variable]] = list(_rval)\n\n for i in range(len(_rval)):\n if isinstance(_rval[i].type, NullType):\n if null_gradients == \"raise\":\n raise NullTypeGradError(\n f\"`grad` encountered a NaN. {_rval[i].type.why_null}\"\n )\n else:\n assert null_gradients == \"return\"\n if isinstance(_rval[i].type, DisconnectedType):\n handle_disconnected(_rval[i])\n if return_disconnected == \"zero\":\n rval[i] = _float_zeros_like(_wrt[i])\n elif return_disconnected.lower() == \"none\":\n rval[i] = None\n else:\n assert return_disconnected.lower() == \"disconnected\"\n\n t1 = time.perf_counter()\n global grad_time\n grad_time += t1 - t0\n\n if isinstance(wrt, tuple):\n return tuple(rval)\n elif not isinstance(wrt, list):\n return rval[0]\n\n return rval","def gradient(self, x, Y):\n if self.is_sparse:\n x = x.todense()\n Y = Y.todense()\n assert(len(shape(x))==1)\n assert(len(shape(Y))==2)\n assert(len(x)==shape(Y)[1])\n \n x_2d=reshape(x, (1, len(x)))\n k = self.kernel(x_2d, Y)\n differences = Y - x\n G = (1.0 / self.width ** 2) * (k.T * differences)\n return G","def compute_gradient(self):\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 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 compute_cost_and_grad_with_reg(theta, X, y, lambda_):\n m = X.shape[0]\n y_hat = sigmoid(X @ theta.T)\n J = - (1 / m) * np.sum(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat)) + np.sum(lambda_ / (2 * m) * theta[1:] ** 2)\n temp = theta\n temp[0] = 0\n grad = (1 / m) * X.T @ (y_hat - y) + lambda_ / m * temp\n return J, grad","def gradient_descent(x0,df,rate=0.1,max_iters=1000,min_step=1e-6,max_step=1e5,\n projection=None,trajectory=False,step_history=False,f=None,\n cost_history=False,feedback=False,plot_history=False):\n if feedback is True:\n print(\"gd.gradient_descent():\")\n if f is not None:\n assert callable(f)\n fx0 = f(x0)\n if feedback is True:\n print(f\" initial cost = {fx0:.2e}\")\n if projection is not None:\n assert callable(projection)\n project = True\n else:\n project = False\n if trajectory is True:\n xx = [x0.copy()]\n if step_history is True:\n steps = []\n if cost_history is True:\n assert callable(f)\n fx = [fx0]\n\n x = x0.copy()\n for i in range(max_iters):\n dx = -rate*df(x)\n if project is True:\n x0 = x.copy()\n x = projection(x0+dx)\n dx = x-x0\n else:\n x += dx\n if trajectory is True:\n xx.append(x.copy())\n if cost_history is True:\n fx += [f(x)]\n step_size = np.linalg.norm(dx)\n if step_history is True:\n steps += [step_size]\n if step_size < min_step or step_size > max_step:\n break\n\n results = dict()\n results['output'] = x\n if trajectory is True:\n results['trajectory'] = xx\n if cost_history is True:\n results['cost_history'] = fx\n if step_history is True:\n results['step_history'] = steps\n if plot_history is True:\n assert step_history is True or cost_history is True\n plt.figure()\n if step_history is True:\n plt.semilogy(steps,label='step size')\n if cost_history is True:\n plt.semilogy(fx,label='cost')\n plt.xlabel('iteration number')\n plt.title('Gradient Descent')\n plt.legend()\n results['figure'] = plt\n plt.show(block=False)\n \n if feedback is True:\n if f is not None:\n print(f\" final cost = {f(x):.2e}\")\n \n return results","def costFunction(self, x, y ):\n self.yEst = self.forward_propagate(x)\n sqErrors = ( self.yEst - y ) ** 2\n J = sqErrors.sum() / 2\n return J","def gradient_descent(features, values, theta, alpha, num_iterations):\n m = len(values)\n cost_history = []\n\n for i in range(num_iterations):\n predicted_values = np.dot(features, theta)\n delta = alpha / m * np.dot((predicted_values - values), features)\n theta = theta - delta\n cost = compute_cost(features, values, theta)\n cost_history.append(cost)\n return theta, pandas.Series(cost_history)","def gradient(cls, x):\n return np.minimum(-2.5 < x, x < 2.5) * 0.2","def get_gradient(self, y, x, weight):\n y = np.reshape(y, (len(y),))\n return np.dot(x.T, sigmoid(np.dot(x, weight)) - y) \\\n + self.regularizer.get_gradient(weight)","def gradient(self):\n functional = self\n\n class KLCrossEntCCGradient(Operator):\n\n \"\"\"The gradient operator of this functional.\"\"\"\n\n def __init__(self):\n \"\"\"Initialize a new instance.\"\"\"\n super().__init__(functional.domain, functional.domain,\n linear=False)\n\n def _call(self, x):\n \"\"\"Apply the gradient operator to the given point.\"\"\"\n if functional.prior is None:\n return np.exp(x)\n else:\n return functional.prior * np.exp(x)\n\n return KLCrossEntCCGradient()","def gradient(cls, x):\n return np.minimum(-1. < x, x < 1.) * 1.","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 gradient_descent(features, values, theta, alpha, num_iterations):\n \n # number of points\n npoints = len(values)\n \n # intialize cost history\n cost_history = []\n \n # num_interations iterations\n for iiter in range(num_iterations):\n \n # compute and store cost\n cost = compute_cost(features, values, theta)\n cost_history.append(cost)\n \n # update values of theta\n values_predicted = np.dot(features, theta)\n theta = theta + (alpha/npoints)*(np.dot(values - values_predicted,features))\n \n return theta, pandas.Series(cost_history)","def gradient(cls, x):\n return np.multiply(1, x > 0)","def eval_numerical_gradient(f, x, verbose = True, h = 0.00001):\n fx = f(x) # evaluate function value at original point\n grad = np.zeros_like(x) # iterate over all indexese in x\n it = np.nditer(x, flags = ['multi_index'], op_flags = ['readwrite'])\n while not it.finished:\n # evaluate function at x+h\n ix = it.multi_index\n oldval = x[ix]\n x[ix] = oldval + h # increment by h\n fxph = f(x) # evaluate f(x+h)\n x[ix] = oldval - h\n fxmh = f(x) # evaluate f(x-h)\n x[ix] = oldval # restore\n \n #compute the partial derivative with centered fromula.\n grad[ix] = (fxph - fxmh) / (2 * h)\n if verbose:\n print(ix, grad[ix])\n it.iternext()\n return grad","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 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 _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 gradient_ascent(self, w, X, y, lr):\r\n # INSERT YOUR CODE HERE\r\n #raise Exception('Function not yet implemented!')\r\n # gradient = x_j*(y-σ(wTX))\r\n return np.dot(X.T, y-self.sigmoid(np.dot(X, w)))","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 gradient(theta, x, y):\n m = len(y)\n n = len(theta)\n z = theta.dot(x.T)\n grad = np.zeros(n)\n for i in xrange(m):\n grad += (g(z[i]) - y[i]) * x[i]\n return 1. / m * grad","def eval_numerical_gradient(f, x, verbose=True, h=0.00001):\n\n fx = f(x) # evaluate function value at original point\n grad = np.zeros_like(x)\n # iterate over all indexes in x\n it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])\n while not it.finished:\n\n # evaluate function at x+h\n ix = it.multi_index\n oldval = x[ix]\n x[ix] = oldval + h # increment by h\n fxph = f(x) # evalute f(x + h)\n x[ix] = oldval - h\n fxmh = f(x) # evaluate f(x - h)\n x[ix] = oldval # restore\n\n # compute the partial derivative with centered formula\n grad[ix] = (fxph - fxmh) / (2 * h) # the slope\n if verbose:\n print(ix, grad[ix])\n it.iternext() # step to next dimension\n\n return grad","def cost_gradient_thread(self, data_XYt):\n return self.cost_gradient(data_XYt[0], data_XYt[1], thread_scale=data_XYt[2])","def grad_sigmoid(self):\n grad = self.sigmoid(self.x) * (1 - self.sigmoid(self.x))\n return grad","def grad(self, x):\n return self.smoothed_grad(x)","def grad(self, x):\n return self.smoothed_grad(x)","def grad(self, x):\n return self.smoothed_grad(x)","def gradient(self):\n functional = self\n\n class KLCrossEntropyGradient(Operator):\n\n \"\"\"The gradient operator of this functional.\"\"\"\n\n def __init__(self):\n \"\"\"Initialize a new instance.\"\"\"\n super().__init__(functional.domain, functional.domain,\n linear=False)\n\n def _call(self, x):\n \"\"\"Apply the gradient operator to the given point.\n\n The gradient is not defined in for points with components less\n than or equal to zero.\n \"\"\"\n if functional.prior is None:\n tmp = np.log(x)\n else:\n tmp = np.log(x / functional.prior)\n\n if np.all(np.isfinite(tmp)):\n return tmp\n else:\n # The derivative is not defined.\n raise ValueError('The gradient of the Kullback-Leibler '\n 'Cross Entropy functional is not defined '\n 'for `x` with one or more components '\n 'less than or equal to zero.'.format(x))\n\n return KLCrossEntropyGradient()","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 gradient_descent(self, X ,eta, tol,iter):\n gd=[]\n gd_x=[X]\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 \n prev_x=X\n new_x=prev_x -(learn_rate*first_derivative(prev_x))\n gd_x.append(new_x)\n #print(\"prev_x = \",prev_x,\" Next x = \",new_x)\n for i in range(iter):\n prev_x=new_x\n #print(prev_x)\n new_x=prev_x -(learn_rate*first_derivative(prev_x))\n gd_x.append(new_x)\n # print(\"x = \",new_x,\"Gradient =\",learn_rate*self.func(prev_x))\n if abs(self.func(new_x)) <= self.func(tol) :\n break\n iteration=iteration+1\n #print(\"Best at GD x= \",new_x)\n gd.append(gd_x)\n gd.append(new_x)\n gd.append(iteration)\n\n return gd","def sigmoid_grad(x):\n sig = sigmoid(x)\n return np.multiply(sig, 1 - sig)","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 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_reg_gradient(self):\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) + self.lambda_reg * self.w # add regularization term","def gradients(f, x, grad_ys=None):\n\n if isinstance(x, list):\n grad = tf.gradients(f, x, grad_ys=grad_ys)\n for i in range(len(x)):\n if grad[i] is None:\n grad[i] = tf.zeros_like(x[i])\n return grad\n else:\n grad = tf.gradients(f, x, grad_ys=grad_ys)[0]\n if grad is None:\n return tf.zeros_like(x)\n else:\n return grad","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 (w, x, y):\n (n,d) = x.shape\n g = np.zeros(d)\n for i in range(0,d):\n g[i] = (w*x-y)*np.transpose(x[i])\n g += 0.5*w\n return g","def calculate_gradient(y, tx, w):\n return tx.T.dot(sigmoid(tx.dot(w))-np.reshape(y,(len(y),1)))","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\n dx = backend.dot(grad, backend.transpose(y))\n dy = backend.dot(backend.transpose(x), grad)\n\n return [dx, dy]","def gradient(self, node, output_grad):\r\n \"\"\"TODO: Your code here\"\"\"\r\n return [output_grad * exp(node.inputs[0])]","def grad_ReLU(self):\n grad = np.where(self.x > 0, 1, 0)\n return grad","def compute_gradient(self, grad=None):\n x = self.input_nodes[0].output_value\n if grad is None:\n grad = backend.ones_like(self.output_value)\n if x == float('inf') or x == float('-inf'):\n return grad * float('inf')\n else:\n return grad * 1 / x","def gradient(self):\n return ConstantFunctional(self.domain, self.scalar)","def gradient_model(x, I_0, a, lam):\n if np.any(np.array(x) < 0):\n raise RuntimeError('x must be positive')\n if np.any(np.array([I_0, a, lam]) < 0):\n raise RuntimeError('all params must be positive')\n return a + I_0 * np.exp(-x / lam)","def _gradient_descent(self, X, y, epochs, learning_rate, batch_size):\n num_feats = X.shape[1]\n num_samples = X.shape[0]\n\n y = y.reshape(num_samples, 1)\n W = np.random.rand(num_feats, 1)\n training_loss_epochs = []\n\n for ix in range(epochs):\n shuffled_ix = (np.arange(0, len(X)))\n np.random.shuffle(shuffled_ix)\n X = X[shuffled_ix, :]\n y = y[shuffled_ix, :]\n\n for batch_ix in np.arange(0, X.shape[0], batch_size):\n dW = self._compute_gradient(W, X[batch_ix:batch_ix + batch_size], y[batch_ix:batch_ix + batch_size])\n W -= learning_rate * dW\n\n if ix % 10 == 0:\n y_pred = np.dot(X, W)\n training_loss = self.mse(y, y_pred)\n print('epoch {0} : training loss {1}'.format(ix, training_loss))\n training_loss_epochs.append(training_loss[0])\n\n self.weights = W\n self.training_loss = training_loss_epochs\n return None","def 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"],"string":"[\n \"def gradient(self, x):\\n pass\",\n \"def gradient(cls, x):\\n y = Sigmoid.apply(x)\\n return np.multiply(y, 1 - y)\",\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 gradientdescent(cost_func, theta, args=(), delta_func = 0):\\n step = 1\\n old_cost = 0\\n while True:\\n theta_old = theta.copy()\\n cost = cost_func(theta, *args)\\n delta = delta_func(theta, *args)\\n theta = theta - step * delta\\n if cost > old_cost and old_cost != 0:\\n step = step*0.7\\n if np.allclose(theta_old, theta):\\n break\\n old_cost = cost\\n return theta\",\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 compute_gradient(theta, X, y):\\n m = X.shape[0]\\n grad_theta = np.dot(X.transpose(), (np.dot(X, theta) - y)) / m\\n #print theta, grad_theta, objective_function(theta, X, y)\\n return grad_theta\",\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 logit_cost_grad(self, theta, X, y):\\n\\n grad = np.zeros(len(theta))\\n\\n ### YOUR CODE HERE\\n sig = utils.sigmoid(theta)\\n # sig = np.subtract(sig, y)\\n sig = sig - y\\n grad = np.dot(X.T, sig) + 2 * self.params['lamb'] * self.regularizer[1](self.weights)\\n ### END YOUR CODE\\n\\n return grad\",\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 gradient_function(theta, X, y):\\n\\n grad = None\\n #######################################################################\\n # TODO: #\\n # Compute the gradient for a particular choice of theta. #\\n # 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 \\n theta = theta[:, np.newaxis]\\n \\n thetatrans = theta.T\\n Xtrans = X.T\\n \\n MulThetaX = np.dot(thetatrans, Xtrans)\\n \\n h = sigmoid(MulThetaX)\\n \\n grad = (y - h) * Xtrans\\n\\n #######################################################################\\n # END OF YOUR CODE #\\n #######################################################################\\n return grad\",\n \"def gradient(w, x, t):\\n return 2 * np.dot(x.T, (nn(x, w) - t))\",\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 gradientFunctionReg(theta, X, y, Lambda):\\n m = len(y) # number of training examples\\n grad = np.zeros(theta.shape[0])\\n theta = np.transpose(theta)\\n sum_1 = 0\\n X = X.values\\n y = y.values\\n #calcuate the theta_0 \\n# ====================== YOUR CODE HERE ======================\\n# Instructions: Compute the gradient of a particular choice of theta.\\n# Compute the partial derivatives and set grad to the partial\\n# derivatives of the cost w.r.t. each parameter in theta\\n for i in range(theta.shape[0]):\\n if i == 0:\\n for j in range(m):\\n sum_1 += (sigmoid(np.dot(X[j],theta)) - y[j]) * X[j,i]\\n else:\\n for j in range(m):\\n sum_1 += (sigmoid(np.dot(X[j],theta)) - y[j]) * X[j,i] + Lambda*theta[i]\\n grad[i] = sum_1/m\\n sum_1 = 0\\n\\n# =============================================================\\n\\n return grad\",\n \"def gradient(cls, x):\\n return 1 - TanH.apply(x) ** 2\",\n \"def objective_function_gradients(self, x):\\n self._set_params_transformed(x)\\n LL_gradients = self._transform_gradients(self._log_likelihood_gradients())\\n prior_gradients = self._transform_gradients(self._log_prior_gradients())\\n return - LL_gradients - prior_gradients\",\n \"def gradient(self, x):\\n return 0.0\",\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 gradient(self, x):\\n g = self._grad(\\n time_series=self.observed_data,\\n a=x[0],\\n b=x[1],\\n c=x[2],\\n sigma=self.sigma\\n )\\n return g\",\n \"def grad(x):\\n\\n return x - np.arange(1, cfg.n + 1, dtype=np.float_)\",\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 gradient(self, x, i=None):\\n self.set_parameters(x=x)\\n gradient = self.gradient_loss()\\n if self.add_bias:\\n gradient[1:] += self.alpha * self.gradient_regularizer()\\n else:\\n gradient += self.alpha * self.gradient_regularizer()\\n if i is not None:\\n return gradient.ravel()[i]\\n return gradient.ravel()\",\n \"def numerical_gradient(f, x: np.ndarray):\\n h = 1e-4\\n grad = np.zeros_like(x)\\n for i in range(x.size):\\n tmp_val = x.flat[i]\\n x.flat[i] = tmp_val + h\\n fxh1 = f(x)\\n\\n x.flat[i] = tmp_val - h\\n fxh2 = f(x)\\n grad.flat[i] = (fxh1 - fxh2) / (2 * h)\\n x.flat[i] = tmp_val\\n return grad\",\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 objective_function_gradients(self, x):\\r\\n try:\\r\\n self._set_params_transformed(x)\\r\\n obj_grads = -self._transform_gradients(self._log_likelihood_gradients() + self._log_prior_gradients())\\r\\n self._fail_count = 0\\r\\n except (LinAlgError, ZeroDivisionError, ValueError) as e:\\r\\n if self._fail_count >= self._allowed_failures:\\r\\n raise e\\r\\n self._fail_count += 1\\r\\n obj_grads = np.clip(-self._transform_gradients(self._log_likelihood_gradients() + self._log_prior_gradients()), -1e100, 1e100)\\r\\n return obj_grads\",\n \"def approx_grad(theta, X, y):\\n grad_a = np.array([(cost(theta + e, X, y) - cost(theta - e, X, y)) / (2 * 1e-5)\\n for e in np.identity(len(theta)) * 1e-5])\\n return grad_a\",\n \"def gradient(theta, X, y, learning_rate):\\n m = len(y)\\n\\n theta = theta.reshape((-1,1))\\n grad = np.zeros(theta.shape)\\n h = sigmoid(np.dot(X, theta)) \\n \\n grad = np.dot((h-y).T, X)/m\\n grad = grad.T\\n grad[1:] += (learning_rate/m)*theta[1:]\\n return grad\",\n \"def grad(self, x):\\n grad = np.zeros((x.shape[0], 1))\\n grad[x >= utils.TOLERANCE] = 1.0\\n grad[x <= -utils.TOLERANCE] = -1.0\\n between = (x > -utils.TOLERANCE) & (x < utils.TOLERANCE)\\n grad[between] = self.rng(between.sum())\\n\\n return self.l * grad\",\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 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 eval_numerical_gradient(f,x):\\n\\n\\tgrad = np.zeros(x.shape)\\n\\th = 0.0001\\n\\n\\t# iterate over all indexes in x\\n\\tit = np.nditer(x, flag = ['multi_index'], op_flags = ['readwrite'])\\n\\n\\twhile not it.finished:\\n\\t\\tix = it.multi_index\\n\\t\\told_value = x[ix]\\n\\n\\t\\tx[ix] = old_value + h\\n\\t\\tfxh_left = f(x)\\n\\n\\t\\tx[ix] = old_value - h\\n\\t\\tfxh_right = f(x)\\n\\n\\t\\tx[ix] = old_value\\n\\n\\t\\t# compute the partial derivative\\n\\t\\tgrad[ix] = (fxh_left - fxh_right) / (2 * h)\\n\\t\\tit.iterate()\\n\\n\\treturn grad\",\n \"def gradient(self, x_in):\\r\\n\\r\\n return 1 - torch.pow(self.forward(x_in), 2)\",\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 calc_gradient_at(self, x: np.ndarray) -> np.ndarray:\\n\\n if self.gradient_f:\\n # if the problem has knowledge about the gradient, use it directly without approximation\\n return self.gradient_f(x)\\n\\n return gradient_approximation(self.f, x)\",\n \"def lrCostFunction(theta,X,y, lambda_reg):\\n m = np.size(y)\\n grad = np.zeros(np.size((theta)))\\n J_base, grad = costFunction(theta, X, y)\\n \\n\\n reg_cost = (lambda_reg / (2.0 * m)) * np.sum(theta[1:] ** 2)\\n \\n reg_gradient = (lambda_reg / m) * theta\\n reg_gradient[0] = 0\\n cost = J_base + reg_cost\\n return cost, grad + reg_gradient\",\n \"def gradient_descent(self, x, y):\\n # Initialize weights vector\\n self.weights = np.zeros(len(x[0]))\\n\\n # Storing number of training example in a variable \\n n = len(x)\\n\\n # Initiate variables to keep track of the current and smallest loss recorded\\n lowest_loss = sys.float_info.max\\n current_loss = sys.float_info.max\\n\\n # Initiate variables to keep track of step sizes\\n norm = sys.float_info.max\\n smallest_norm = sys.float_info.max\\n\\n # Initiate list variable that stores all previous weights\\n prev_weights = []\\n\\n # Initiate list that stores all the errors. \\n errors = []\\n \\n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\\n k_loss_iteration = 1\\n\\n # Learning loop\\n for i in range(self.max_iter):\\n\\n # Append current weights\\n prev_weights.append(np.array(self.weights))\\n \\n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\\n\\n # Compute the error of the Cost Function and store it in a list\\n current_loss = self.cost(x,y)\\n\\n if len(errors) > 1 and current_loss > errors[-1]:\\n k_loss_iteration += 1\\n else: \\n k_loss_iteration = 1\\n\\n errors.append(current_loss)\\n \\n # Track smallest loss\\n if current_loss < lowest_loss:\\n lowest_loss = current_loss\\n\\n # Compute the L2 Norm of the difference between current weights and previous weights\\n norm = np.linalg.norm(self.weights - prev_weights[-1])\\n\\n # Track smallest step size and set it as error threshold\\n if norm < smallest_norm:\\n smallest_norm = norm\\n\\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\\n if self.error_threshold != None and norm < self.error_threshold:\\n print(\\\"Converged after {} iterations!\\\".format(i))\\n break\\n\\n # stop if error hasn't gone down in k iterations\\n if k_loss_iteration >= 10:\\n print(k_loss_iteration + \\\" iterations of loss not decreasing on {}th itertion.\\\".format(i))\\n break\\n\\n # Log final weights\\n print(\\\"Final norm: \\\" + str(norm) + \\\"\\\\nSmallest step size recorded: \\\" + str(smallest_norm) + \\\"\\\\nFinal error: \\\" + str(current_loss) + \\\"\\\\nLowest error recorded: \\\" + str(lowest_loss) + \\\"\\\\nNumber of epochs: \\\" + str(len(errors)) + \\\"\\\\nFinal weights: \\\" + str(self.weights))\",\n \"def gradient_descent(X, y, theta, learning_rate, num_iters, lambda_reg):\\n thetas = [theta]\\n cost = np.zeros(num_iters)\\n\\n J = mean_cross_entropy_costs(X, y, lambda_reg)\\n cost[0] = J(thetas[0])\\n for i in range(1, num_iters):\\n thetas.append(compute_new_theta(X, y, thetas[i - 1], learning_rate, lambda_reg))\\n cost[i] = J(thetas[i])\\n return cost, thetas\",\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 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 costFunction(self,theta, X, y): \\n m = len(y)\\n h = self.sigmoid(X@theta)\\n J = 1 / m * (- y.T @ self.log(h) - (1-y).T @ self.log(1-h)) \\n # grad = 1/ m * X.T @ (h - y)\\n return J\",\n \"def gradient_descent(data_x, data_y, parameters, learn_rate, nb_iterations):\\n\\n # Cost history\\n cost_tracking = np.zeros(nb_iterations)\\n\\n for _i in range(nb_iterations):\\n parameters -= learn_rate * gradient(data_x, data_y, parameters)\\n # recording the cost for each iteration\\n cost_tracking[_i] = cost_function(data_x, data_y, parameters)\\n\\n return parameters, cost_tracking\",\n \"def gradient(f, x, s=_DEFAULT_STEP):\\n x = np.asarray(x)\\n n = len(x)\\n e = np.eye(n)\\n\\n forw = np.zeros(n)\\n for i in range(n):\\n forw[i] = f(x + s*e[i])\\n\\n g = (forw - f(x)) / s\\n return g\",\n \"def gradient(self):\\n functional = self\\n\\n class KLCCGradient(Operator):\\n\\n \\\"\\\"\\\"The gradient operator of this functional.\\\"\\\"\\\"\\n\\n def __init__(self):\\n \\\"\\\"\\\"Initialize a new instance.\\\"\\\"\\\"\\n super().__init__(functional.domain, functional.domain,\\n linear=False)\\n\\n def _call(self, x):\\n \\\"\\\"\\\"Apply the gradient operator to the given point.\\n\\n The gradient is not defined in points where one or more\\n components are larger than or equal to one.\\n \\\"\\\"\\\"\\n if functional.prior is None:\\n return 1.0 / (1 - x)\\n else:\\n return functional.prior / (1 - x)\\n\\n return KLCCGradient()\",\n \"def compute_gradient(self, grad=None):\\n if grad is None:\\n grad = backend.ones_like(self.output_value)\\n x, = self.input_nodes[0].output_value\\n return backend.exp(x) * grad\",\n \"def gradient(data_x, data_y, parameters):\\n return data_x.T @ (data_x @ parameters - data_y) / data_x.shape[0]\",\n \"def approx_grad_reg(theta, X, y, _lambda):\\n grad_a = np.array([(cost_reg(theta + e, X, y, _lambda) - cost_reg(theta - e, X, y, _lambda)) / (2 * 1e-5)\\n for e in np.identity(len(theta)) * 1e-5])\\n return grad_a\",\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 compute_gradient(self, function, arguments):\",\n \"def lr_cost_function(theta, X, y, learning_rate):\\n m = len(y) # number of training examples\\n # You need to return the following variables correctly \\n J = 0\\n grad = np.zeros(theta.shape)\\n h = sigmoid(np.dot(X, theta))\\n\\n #Compute cost:\\n first = (1/m)*np.sum(np.dot(-y.T, np.log(h)) - np.dot((1-y).T, np.log(1-h)), axis=0)\\n second = (learning_rate/(2*m))*np.sum(theta[1:]**2)\\n J = first + second\\n \\n #Compute gradient\\n grad = np.dot((h-y).T, X)/m\\n grad = grad.T\\n grad[1:] += (learning_rate/m)*theta[1:]\\n return float(J), grad\",\n \"def compute_cost_derivative(AL, Y):\\n pass\",\n \"def gradient(self):\\n functional = self\\n\\n class KLGradient(Operator):\\n\\n \\\"\\\"\\\"The gradient operator of this functional.\\\"\\\"\\\"\\n\\n def __init__(self):\\n \\\"\\\"\\\"Initialize a new instance.\\\"\\\"\\\"\\n super().__init__(functional.domain, functional.domain,\\n linear=False)\\n\\n def _call(self, x):\\n \\\"\\\"\\\"Apply the gradient operator to the given point.\\n The gradient is not defined in points where one or more\\n components are non-positive.\\n \\\"\\\"\\\"\\n if functional.prior is None:\\n return (-1.0) / x + 1\\n else:\\n return (-functional.prior) / x + 1\\n\\n return KLGradient()\",\n \"def loss_gradient(self, x, y):\\n x_preproc = self._apply_processing(x)\\n x_defences, y_defences = self._apply_defences(x_preproc, y, fit=False)\\n\\n # Adjust the shape of y for loss functions that do not take labels in one-hot encoding\\n if self._reduce_labels:\\n y_defences = np.argmax(y_defences, axis=1)\\n\\n grads = self._loss_grads([x_defences, y_defences])[0]\\n grads = self._apply_defences_gradient(x_preproc, grads)\\n grads = self._apply_processing_gradient(grads)\\n assert grads.shape == x_preproc.shape\\n\\n return grads\",\n \"def calculate_gradient(y, tx, w): \\n return tx.T@(sigmoid(tx@w)-y)\",\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 grad(\\n cost: Optional[Variable],\\n wrt: Union[Variable, Sequence[Variable]],\\n consider_constant: Optional[Sequence[Variable]] = None,\\n disconnected_inputs: Literal[\\\"ignore\\\", \\\"warn\\\", \\\"raise\\\"] = \\\"raise\\\",\\n add_names: bool = True,\\n known_grads: Optional[Mapping[Variable, Variable]] = None,\\n return_disconnected: Literal[\\\"none\\\", \\\"zero\\\", \\\"disconnected\\\"] = \\\"zero\\\",\\n null_gradients: Literal[\\\"raise\\\", \\\"return\\\"] = \\\"raise\\\",\\n) -> Union[Optional[Variable], Sequence[Optional[Variable]]]:\\n t0 = time.perf_counter()\\n\\n if cost is None:\\n if known_grads is None:\\n raise ValueError(\\\"cost and known_grads can't both be None.\\\")\\n\\n if cost is not None and isinstance(cost.type, NullType):\\n raise ValueError(\\n \\\"Can't differentiate a NaN cost. \\\"\\n f\\\"Cost is NaN because {cost.type.why_null}\\\"\\n )\\n\\n if cost is not None and cost.type.ndim != 0:\\n raise TypeError(\\\"Cost must be a scalar.\\\")\\n\\n if not isinstance(wrt, Sequence):\\n _wrt: List[Variable] = [wrt]\\n else:\\n _wrt = [x for x in wrt]\\n\\n outputs = []\\n if cost is not None:\\n outputs.append(cost)\\n if known_grads is not None:\\n outputs.extend(list(known_grads.keys()))\\n\\n var_to_app_to_idx = _populate_var_to_app_to_idx(outputs, _wrt, consider_constant)\\n\\n # build a dict mapping var to the gradient of cost with respect to var\\n grad_dict = {}\\n\\n if known_grads is None:\\n known_grads = {}\\n\\n assert isinstance(known_grads, dict)\\n\\n # The gradient of the cost is 1 unless specified otherwise by known_grads.\\n if cost is not None:\\n if cost in known_grads:\\n g_cost = known_grads[cost]\\n else:\\n g_cost = _float_ones_like(cost)\\n # g_cost may be Disconnected or NullType. A creative use of the\\n # function, sure, but nonetheless one we can and should support.\\n # So before we try to cast it make sure it even has a dtype\\n if (\\n hasattr(g_cost.type, \\\"dtype\\\")\\n and cost.type.dtype in aesara.tensor.type.continuous_dtypes\\n ):\\n # Here we enforce the constraint that floating point variables\\n # have the same dtype as their gradient.\\n g_cost = g_cost.astype(cost.type.dtype)\\n # DO NOT enforce g_cost to be 0 if cost is an integer.\\n # This is to be enforced by the Op.grad method for the\\n # Op that outputs cost.\\n if hasattr(g_cost.type, \\\"dtype\\\"):\\n assert g_cost.type.dtype in aesara.tensor.type.continuous_dtypes\\n\\n grad_dict[cost] = g_cost\\n\\n for var in known_grads:\\n g_var = known_grads[var]\\n\\n if not hasattr(g_var, \\\"type\\\"):\\n raise TypeError(\\n \\\"output grads must be aesara variables.\\\"\\n f\\\"Ambiguous whether {type(g_var)} should be made into tensor\\\"\\n \\\" or sparse aesara variable\\\"\\n )\\n\\n if not isinstance(\\n g_var.type, (NullType, DisconnectedType)\\n ) and \\\"float\\\" not in str(g_var.type.dtype):\\n raise TypeError(\\n \\\"Gradients must always be NullType, \\\"\\n \\\"DisconnectedType, or continuous, but grad was \\\"\\n \\\"given a known_grad of type \\\" + str(g_var.type)\\n )\\n\\n # DO NOT check that these gradients are equal to 0 if var is int\\n # The gradient is allowed to be non-zero on var in that case\\n # Ops outputting var should not backpropagate its gradient further\\n # but that is enforced elsewhere (grep for only_connected_to_int)\\n\\n grad_dict[var] = g_var\\n\\n def handle_disconnected(var):\\n message = (\\n \\\"grad method was asked to compute the gradient \\\"\\n \\\"with respect to a variable that is not part of \\\"\\n \\\"the computational graph of the cost, or is used \\\"\\n f\\\"only by a non-differentiable operator: {var}\\\"\\n )\\n if disconnected_inputs == \\\"ignore\\\":\\n pass\\n elif disconnected_inputs == \\\"warn\\\":\\n warnings.warn(message, stacklevel=2)\\n elif disconnected_inputs == \\\"raise\\\":\\n message = utils.get_variable_trace_string(var)\\n raise DisconnectedInputError(message)\\n else:\\n raise ValueError(\\n \\\"Invalid value for keyword \\\"\\n \\\"'disconnected_inputs', valid values are \\\"\\n \\\"'ignore', 'warn' and 'raise'.\\\"\\n )\\n\\n # variables that do not influence the cost have zero gradient.\\n # if wrt is such a variable, populate the grad_dict with this info\\n # so that wrt not being in var_to_app_to_idx won't cause an error below\\n # according to the flag, possibly raise an error if wrt is disconnected\\n for elem in _wrt:\\n if elem not in var_to_app_to_idx and elem is not cost and elem not in grad_dict:\\n handle_disconnected(elem)\\n grad_dict[elem] = disconnected_type()\\n\\n cost_name = None\\n if add_names and cost is not None:\\n cost_name = cost.name\\n\\n # Make sure we didn't initialize the grad_dict with any ints\\n # The gradient may NEVER be an int, even if the variable is an int.\\n # Read the Op contract and talk to Ian Goodfellow before changing this!\\n for var in grad_dict:\\n g = grad_dict[var]\\n if hasattr(g.type, \\\"dtype\\\"):\\n assert g.type.dtype in aesara.tensor.type.float_dtypes\\n\\n _rval: Sequence[Variable] = _populate_grad_dict(\\n var_to_app_to_idx, grad_dict, _wrt, cost_name\\n )\\n\\n rval: MutableSequence[Optional[Variable]] = list(_rval)\\n\\n for i in range(len(_rval)):\\n if isinstance(_rval[i].type, NullType):\\n if null_gradients == \\\"raise\\\":\\n raise NullTypeGradError(\\n f\\\"`grad` encountered a NaN. {_rval[i].type.why_null}\\\"\\n )\\n else:\\n assert null_gradients == \\\"return\\\"\\n if isinstance(_rval[i].type, DisconnectedType):\\n handle_disconnected(_rval[i])\\n if return_disconnected == \\\"zero\\\":\\n rval[i] = _float_zeros_like(_wrt[i])\\n elif return_disconnected.lower() == \\\"none\\\":\\n rval[i] = None\\n else:\\n assert return_disconnected.lower() == \\\"disconnected\\\"\\n\\n t1 = time.perf_counter()\\n global grad_time\\n grad_time += t1 - t0\\n\\n if isinstance(wrt, tuple):\\n return tuple(rval)\\n elif not isinstance(wrt, list):\\n return rval[0]\\n\\n return rval\",\n \"def gradient(self, x, Y):\\n if self.is_sparse:\\n x = x.todense()\\n Y = Y.todense()\\n assert(len(shape(x))==1)\\n assert(len(shape(Y))==2)\\n assert(len(x)==shape(Y)[1])\\n \\n x_2d=reshape(x, (1, len(x)))\\n k = self.kernel(x_2d, Y)\\n differences = Y - x\\n G = (1.0 / self.width ** 2) * (k.T * differences)\\n return G\",\n \"def compute_gradient(self):\\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 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 compute_cost_and_grad_with_reg(theta, X, y, lambda_):\\n m = X.shape[0]\\n y_hat = sigmoid(X @ theta.T)\\n J = - (1 / m) * np.sum(y * np.log(y_hat) + (1 - y) * np.log(1 - y_hat)) + np.sum(lambda_ / (2 * m) * theta[1:] ** 2)\\n temp = theta\\n temp[0] = 0\\n grad = (1 / m) * X.T @ (y_hat - y) + lambda_ / m * temp\\n return J, grad\",\n \"def gradient_descent(x0,df,rate=0.1,max_iters=1000,min_step=1e-6,max_step=1e5,\\n projection=None,trajectory=False,step_history=False,f=None,\\n cost_history=False,feedback=False,plot_history=False):\\n if feedback is True:\\n print(\\\"gd.gradient_descent():\\\")\\n if f is not None:\\n assert callable(f)\\n fx0 = f(x0)\\n if feedback is True:\\n print(f\\\" initial cost = {fx0:.2e}\\\")\\n if projection is not None:\\n assert callable(projection)\\n project = True\\n else:\\n project = False\\n if trajectory is True:\\n xx = [x0.copy()]\\n if step_history is True:\\n steps = []\\n if cost_history is True:\\n assert callable(f)\\n fx = [fx0]\\n\\n x = x0.copy()\\n for i in range(max_iters):\\n dx = -rate*df(x)\\n if project is True:\\n x0 = x.copy()\\n x = projection(x0+dx)\\n dx = x-x0\\n else:\\n x += dx\\n if trajectory is True:\\n xx.append(x.copy())\\n if cost_history is True:\\n fx += [f(x)]\\n step_size = np.linalg.norm(dx)\\n if step_history is True:\\n steps += [step_size]\\n if step_size < min_step or step_size > max_step:\\n break\\n\\n results = dict()\\n results['output'] = x\\n if trajectory is True:\\n results['trajectory'] = xx\\n if cost_history is True:\\n results['cost_history'] = fx\\n if step_history is True:\\n results['step_history'] = steps\\n if plot_history is True:\\n assert step_history is True or cost_history is True\\n plt.figure()\\n if step_history is True:\\n plt.semilogy(steps,label='step size')\\n if cost_history is True:\\n plt.semilogy(fx,label='cost')\\n plt.xlabel('iteration number')\\n plt.title('Gradient Descent')\\n plt.legend()\\n results['figure'] = plt\\n plt.show(block=False)\\n \\n if feedback is True:\\n if f is not None:\\n print(f\\\" final cost = {f(x):.2e}\\\")\\n \\n return results\",\n \"def costFunction(self, x, y ):\\n self.yEst = self.forward_propagate(x)\\n sqErrors = ( self.yEst - y ) ** 2\\n J = sqErrors.sum() / 2\\n return J\",\n \"def gradient_descent(features, values, theta, alpha, num_iterations):\\n m = len(values)\\n cost_history = []\\n\\n for i in range(num_iterations):\\n predicted_values = np.dot(features, theta)\\n delta = alpha / m * np.dot((predicted_values - values), features)\\n theta = theta - delta\\n cost = compute_cost(features, values, theta)\\n cost_history.append(cost)\\n return theta, pandas.Series(cost_history)\",\n \"def gradient(cls, x):\\n return np.minimum(-2.5 < x, x < 2.5) * 0.2\",\n \"def get_gradient(self, y, x, weight):\\n y = np.reshape(y, (len(y),))\\n return np.dot(x.T, sigmoid(np.dot(x, weight)) - y) \\\\\\n + self.regularizer.get_gradient(weight)\",\n \"def gradient(self):\\n functional = self\\n\\n class KLCrossEntCCGradient(Operator):\\n\\n \\\"\\\"\\\"The gradient operator of this functional.\\\"\\\"\\\"\\n\\n def __init__(self):\\n \\\"\\\"\\\"Initialize a new instance.\\\"\\\"\\\"\\n super().__init__(functional.domain, functional.domain,\\n linear=False)\\n\\n def _call(self, x):\\n \\\"\\\"\\\"Apply the gradient operator to the given point.\\\"\\\"\\\"\\n if functional.prior is None:\\n return np.exp(x)\\n else:\\n return functional.prior * np.exp(x)\\n\\n return KLCrossEntCCGradient()\",\n \"def gradient(cls, x):\\n return np.minimum(-1. < x, x < 1.) * 1.\",\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 gradient_descent(features, values, theta, alpha, num_iterations):\\n \\n # number of points\\n npoints = len(values)\\n \\n # intialize cost history\\n cost_history = []\\n \\n # num_interations iterations\\n for iiter in range(num_iterations):\\n \\n # compute and store cost\\n cost = compute_cost(features, values, theta)\\n cost_history.append(cost)\\n \\n # update values of theta\\n values_predicted = np.dot(features, theta)\\n theta = theta + (alpha/npoints)*(np.dot(values - values_predicted,features))\\n \\n return theta, pandas.Series(cost_history)\",\n \"def gradient(cls, x):\\n return np.multiply(1, x > 0)\",\n \"def eval_numerical_gradient(f, x, verbose = True, h = 0.00001):\\n fx = f(x) # evaluate function value at original point\\n grad = np.zeros_like(x) # iterate over all indexese in x\\n it = np.nditer(x, flags = ['multi_index'], op_flags = ['readwrite'])\\n while not it.finished:\\n # evaluate function at x+h\\n ix = it.multi_index\\n oldval = x[ix]\\n x[ix] = oldval + h # increment by h\\n fxph = f(x) # evaluate f(x+h)\\n x[ix] = oldval - h\\n fxmh = f(x) # evaluate f(x-h)\\n x[ix] = oldval # restore\\n \\n #compute the partial derivative with centered fromula.\\n grad[ix] = (fxph - fxmh) / (2 * h)\\n if verbose:\\n print(ix, grad[ix])\\n it.iternext()\\n return grad\",\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 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 _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 gradient_ascent(self, w, X, y, lr):\\r\\n # INSERT YOUR CODE HERE\\r\\n #raise Exception('Function not yet implemented!')\\r\\n # gradient = x_j*(y-σ(wTX))\\r\\n return np.dot(X.T, y-self.sigmoid(np.dot(X, w)))\",\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 gradient(theta, x, y):\\n m = len(y)\\n n = len(theta)\\n z = theta.dot(x.T)\\n grad = np.zeros(n)\\n for i in xrange(m):\\n grad += (g(z[i]) - y[i]) * x[i]\\n return 1. / m * grad\",\n \"def eval_numerical_gradient(f, x, verbose=True, h=0.00001):\\n\\n fx = f(x) # evaluate function value at original point\\n grad = np.zeros_like(x)\\n # iterate over all indexes in x\\n it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])\\n while not it.finished:\\n\\n # evaluate function at x+h\\n ix = it.multi_index\\n oldval = x[ix]\\n x[ix] = oldval + h # increment by h\\n fxph = f(x) # evalute f(x + h)\\n x[ix] = oldval - h\\n fxmh = f(x) # evaluate f(x - h)\\n x[ix] = oldval # restore\\n\\n # compute the partial derivative with centered formula\\n grad[ix] = (fxph - fxmh) / (2 * h) # the slope\\n if verbose:\\n print(ix, grad[ix])\\n it.iternext() # step to next dimension\\n\\n return grad\",\n \"def cost_gradient_thread(self, data_XYt):\\n return self.cost_gradient(data_XYt[0], data_XYt[1], thread_scale=data_XYt[2])\",\n \"def grad_sigmoid(self):\\n grad = self.sigmoid(self.x) * (1 - self.sigmoid(self.x))\\n return grad\",\n \"def grad(self, x):\\n return self.smoothed_grad(x)\",\n \"def grad(self, x):\\n return self.smoothed_grad(x)\",\n \"def grad(self, x):\\n return self.smoothed_grad(x)\",\n \"def gradient(self):\\n functional = self\\n\\n class KLCrossEntropyGradient(Operator):\\n\\n \\\"\\\"\\\"The gradient operator of this functional.\\\"\\\"\\\"\\n\\n def __init__(self):\\n \\\"\\\"\\\"Initialize a new instance.\\\"\\\"\\\"\\n super().__init__(functional.domain, functional.domain,\\n linear=False)\\n\\n def _call(self, x):\\n \\\"\\\"\\\"Apply the gradient operator to the given point.\\n\\n The gradient is not defined in for points with components less\\n than or equal to zero.\\n \\\"\\\"\\\"\\n if functional.prior is None:\\n tmp = np.log(x)\\n else:\\n tmp = np.log(x / functional.prior)\\n\\n if np.all(np.isfinite(tmp)):\\n return tmp\\n else:\\n # The derivative is not defined.\\n raise ValueError('The gradient of the Kullback-Leibler '\\n 'Cross Entropy functional is not defined '\\n 'for `x` with one or more components '\\n 'less than or equal to zero.'.format(x))\\n\\n return KLCrossEntropyGradient()\",\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 gradient_descent(self, X ,eta, tol,iter):\\n gd=[]\\n gd_x=[X]\\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 \\n prev_x=X\\n new_x=prev_x -(learn_rate*first_derivative(prev_x))\\n gd_x.append(new_x)\\n #print(\\\"prev_x = \\\",prev_x,\\\" Next x = \\\",new_x)\\n for i in range(iter):\\n prev_x=new_x\\n #print(prev_x)\\n new_x=prev_x -(learn_rate*first_derivative(prev_x))\\n gd_x.append(new_x)\\n # print(\\\"x = \\\",new_x,\\\"Gradient =\\\",learn_rate*self.func(prev_x))\\n if abs(self.func(new_x)) <= self.func(tol) :\\n break\\n iteration=iteration+1\\n #print(\\\"Best at GD x= \\\",new_x)\\n gd.append(gd_x)\\n gd.append(new_x)\\n gd.append(iteration)\\n\\n return gd\",\n \"def sigmoid_grad(x):\\n sig = sigmoid(x)\\n return np.multiply(sig, 1 - sig)\",\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 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_reg_gradient(self):\\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) + self.lambda_reg * self.w # add regularization term\",\n \"def gradients(f, x, grad_ys=None):\\n\\n if isinstance(x, list):\\n grad = tf.gradients(f, x, grad_ys=grad_ys)\\n for i in range(len(x)):\\n if grad[i] is None:\\n grad[i] = tf.zeros_like(x[i])\\n return grad\\n else:\\n grad = tf.gradients(f, x, grad_ys=grad_ys)[0]\\n if grad is None:\\n return tf.zeros_like(x)\\n else:\\n return grad\",\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 (w, x, y):\\n (n,d) = x.shape\\n g = np.zeros(d)\\n for i in range(0,d):\\n g[i] = (w*x-y)*np.transpose(x[i])\\n g += 0.5*w\\n return g\",\n \"def calculate_gradient(y, tx, w):\\n return tx.T.dot(sigmoid(tx.dot(w))-np.reshape(y,(len(y),1)))\",\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\\n dx = backend.dot(grad, backend.transpose(y))\\n dy = backend.dot(backend.transpose(x), grad)\\n\\n return [dx, dy]\",\n \"def gradient(self, node, output_grad):\\r\\n \\\"\\\"\\\"TODO: Your code here\\\"\\\"\\\"\\r\\n return [output_grad * exp(node.inputs[0])]\",\n \"def grad_ReLU(self):\\n grad = np.where(self.x > 0, 1, 0)\\n return grad\",\n \"def compute_gradient(self, grad=None):\\n x = self.input_nodes[0].output_value\\n if grad is None:\\n grad = backend.ones_like(self.output_value)\\n if x == float('inf') or x == float('-inf'):\\n return grad * float('inf')\\n else:\\n return grad * 1 / x\",\n \"def gradient(self):\\n return ConstantFunctional(self.domain, self.scalar)\",\n \"def gradient_model(x, I_0, a, lam):\\n if np.any(np.array(x) < 0):\\n raise RuntimeError('x must be positive')\\n if np.any(np.array([I_0, a, lam]) < 0):\\n raise RuntimeError('all params must be positive')\\n return a + I_0 * np.exp(-x / lam)\",\n \"def _gradient_descent(self, X, y, epochs, learning_rate, batch_size):\\n num_feats = X.shape[1]\\n num_samples = X.shape[0]\\n\\n y = y.reshape(num_samples, 1)\\n W = np.random.rand(num_feats, 1)\\n training_loss_epochs = []\\n\\n for ix in range(epochs):\\n shuffled_ix = (np.arange(0, len(X)))\\n np.random.shuffle(shuffled_ix)\\n X = X[shuffled_ix, :]\\n y = y[shuffled_ix, :]\\n\\n for batch_ix in np.arange(0, X.shape[0], batch_size):\\n dW = self._compute_gradient(W, X[batch_ix:batch_ix + batch_size], y[batch_ix:batch_ix + batch_size])\\n W -= learning_rate * dW\\n\\n if ix % 10 == 0:\\n y_pred = np.dot(X, W)\\n training_loss = self.mse(y, y_pred)\\n print('epoch {0} : training loss {1}'.format(ix, training_loss))\\n training_loss_epochs.append(training_loss[0])\\n\\n self.weights = W\\n self.training_loss = training_loss_epochs\\n return None\",\n \"def 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]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77842075","0.7665237","0.7622198","0.7532601","0.744385","0.74368525","0.7418975","0.7415534","0.7381988","0.7379216","0.7374011","0.73667705","0.7362312","0.73497534","0.7292546","0.72891796","0.7286683","0.72824043","0.72817236","0.7221008","0.7217221","0.72115004","0.72010005","0.7175617","0.71754086","0.7173191","0.71590143","0.71467674","0.7140114","0.7131756","0.7131001","0.7130524","0.7129966","0.71225","0.7102693","0.70993704","0.7099323","0.7074166","0.7074052","0.70729125","0.70693624","0.7057815","0.7053709","0.70479536","0.7044672","0.7027092","0.70251757","0.70026755","0.6998083","0.6993366","0.6987603","0.69832534","0.6981358","0.6978515","0.6976825","0.69629955","0.6959243","0.6953732","0.6945607","0.69317627","0.69249403","0.69236994","0.6918956","0.6915946","0.69109964","0.69076717","0.6899734","0.6894298","0.68929833","0.6890172","0.68842787","0.6879261","0.6876824","0.68744284","0.68668777","0.6865218","0.6852037","0.6846718","0.68372226","0.68372226","0.68372226","0.6829083","0.68276507","0.6822475","0.6810264","0.6809227","0.68060666","0.6800019","0.67818946","0.67798615","0.6777603","0.6773404","0.67665905","0.67635447","0.6762423","0.67591417","0.6758775","0.6758098","0.6756054","0.67543626"],"string":"[\n \"0.77842075\",\n \"0.7665237\",\n \"0.7622198\",\n \"0.7532601\",\n \"0.744385\",\n \"0.74368525\",\n \"0.7418975\",\n \"0.7415534\",\n \"0.7381988\",\n \"0.7379216\",\n \"0.7374011\",\n \"0.73667705\",\n \"0.7362312\",\n \"0.73497534\",\n \"0.7292546\",\n \"0.72891796\",\n \"0.7286683\",\n \"0.72824043\",\n \"0.72817236\",\n \"0.7221008\",\n \"0.7217221\",\n \"0.72115004\",\n \"0.72010005\",\n \"0.7175617\",\n \"0.71754086\",\n \"0.7173191\",\n \"0.71590143\",\n \"0.71467674\",\n \"0.7140114\",\n \"0.7131756\",\n \"0.7131001\",\n \"0.7130524\",\n \"0.7129966\",\n \"0.71225\",\n \"0.7102693\",\n \"0.70993704\",\n \"0.7099323\",\n \"0.7074166\",\n \"0.7074052\",\n \"0.70729125\",\n \"0.70693624\",\n \"0.7057815\",\n \"0.7053709\",\n \"0.70479536\",\n \"0.7044672\",\n \"0.7027092\",\n \"0.70251757\",\n \"0.70026755\",\n \"0.6998083\",\n \"0.6993366\",\n \"0.6987603\",\n \"0.69832534\",\n \"0.6981358\",\n \"0.6978515\",\n \"0.6976825\",\n \"0.69629955\",\n \"0.6959243\",\n \"0.6953732\",\n \"0.6945607\",\n \"0.69317627\",\n \"0.69249403\",\n \"0.69236994\",\n \"0.6918956\",\n \"0.6915946\",\n \"0.69109964\",\n \"0.69076717\",\n \"0.6899734\",\n \"0.6894298\",\n \"0.68929833\",\n \"0.6890172\",\n \"0.68842787\",\n \"0.6879261\",\n \"0.6876824\",\n \"0.68744284\",\n \"0.68668777\",\n \"0.6865218\",\n \"0.6852037\",\n \"0.6846718\",\n \"0.68372226\",\n \"0.68372226\",\n \"0.68372226\",\n \"0.6829083\",\n \"0.68276507\",\n \"0.6822475\",\n \"0.6810264\",\n \"0.6809227\",\n \"0.68060666\",\n \"0.6800019\",\n \"0.67818946\",\n \"0.67798615\",\n \"0.6777603\",\n \"0.6773404\",\n \"0.67665905\",\n \"0.67635447\",\n \"0.6762423\",\n \"0.67591417\",\n \"0.6758775\",\n \"0.6758098\",\n \"0.6756054\",\n \"0.67543626\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70971864"},"document_rank":{"kind":"string","value":"37"}}},{"rowIdx":84786,"cells":{"query":{"kind":"string","value":"Solves the inverse problem"},"document":{"kind":"string","value":"def optimize(self, x0, n_iter = 50):\n x0 = np.asarray(x0, dtype=np.float32)\n opt = proximal_alg.ProximalGradSolver(self.gamma, self.alpha, lambda x: self.costFun(x,self.input), lambda x: np.sum(np.abs(x)), lambda x: self.gradFun(x, self.input), proximal_alg.prox_l1_01)\n result = opt.minimize(x0, n_iter = n_iter)\n return result"},"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 inverse(self):\n return self.solve(Matrix.I(self.nrows))","def inverse(self):\n self.check_square()\n\n\n N = self.rows\n\n inverse = make_matrix(N, N)\n\n # Solve on a per-column basis using Ax = b formalism\n for j in range(N):\n b = make_matrix(N, 1)\n b[j, 0] = 1\n\n x = self.solve_linear_system(b)\n\n for i in range(N):\n inverse[i, j] = x[i, 0]\n\n return inverse","def inverse( m, context = FloatContext, copy_m=True ):\n n,n_ = shape_mat(m)\n assert (n==n_) #matris should be square\n\n return solve( m, eye(n), context=context, copy_b=False, copy_a=copy_m )","def _inv(self) -> None:\n\n self.inv(inplace=True)","def inverse(self, x, y):","def invert(x):\n return linalg.inv(x)","def inv(P):\n L = cho_factor(P)\n return cho_solve(L, np.eye(P.shape[0]))","def inv(in_A):\n Q,R = qr(in_A)\n QT = Q.T\n N = shape(in_A)[0]\n \n for n in range(N-1,-1,-1):\n Rnn = R[n,n]\n R[n,:] /= Rnn\n QT[n,:] /= Rnn\n for m in range(n+1,N):\n Rnm = R[n,m]\n R[n,m] = 0\n QT[n,:] -= QT[m,:]*Rnm\n\n return QT","def inv(self):\n\t\tdeterminant = self.det()\n\t\tif determinant:\n\t\t\treturn self.adj() / determinant\n\t\telse:\n\t\t\traise ValueError(\"Not Invertible\")","def inverse(self):\n if not self.is_square():\n raise(ValueError, \"Non-square Matrix does not have an inverse.\")\n if self.h > 2:\n raise(NotImplementedError, \"inversion not implemented for matrices larger than 2x2.\")\n # TODO - your code here\n inverse = []\n if self.h == 1:\n temp = []\n temp.append(1/self.g[0][0])\n inverse.append(temp)\n else:\n identity_matrix = identity(self.h)\n det_term = 1/self.determinant()\n trace_term = self.trace()\n # implement intermediate scaling step locally\n # trace_x_I = trace_term * identity_matrix\n trace_x_I = []\n for i in range(len(self.g)):\n temp_row = []\n for j in range(len(self.g[i])):\n temp_row.append(trace_term * identity_matrix[i][j])\n trace_x_I.append(temp_row)\n # implement sub-traction locally\n # sub_term = trace_x_I - self.g\n sub_term = []\n for i in range(len(trace_x_I)):\n temp_row = []\n for j in range(len(trace_x_I[i])):\n temp_row.append(trace_x_I[i][j] - self.g[i][j])\n sub_term.append(temp_row)\n # implement final scaling step locally\n # inverse = det_term * sub_term\n inverse = []\n for i in range(len(sub_term)):\n temp_row = []\n for j in range(len(sub_term[i])):\n temp_row.append(det_term * sub_term[i][j])\n inverse.append(temp_row)\n return Matrix(inverse)\n # TODO - your code here","def erfcinv(a):","def inverse(self) -> 'Invertible':\n raise NotImplementedError","def inverse (x_ij):\n\n Hij = xyzrph2matrix (x_ij)\n Rji = Hij[0:3, 0:3]\n tij = Hij[0:3,3]\n Rij = Rji.transpose ()\n tji = -Rij.dot (tij)\n Hji = numpy.zeros ((4,4))\n Hji[0:3,0:3] = Rij\n Hji[0:3,3] = tji\n Hji[3,3] = 1\n return matrix2xyzrph (Hji)","def inverseN(self):\r\n result = Matrix(self.rows, self.columns)\r\n for r in range(self.rows):\r\n for c in range(self.columns):\r\n result.mat[r][c] = self.cofactor(r, c)\r\n result.out()\r\n result = result.transpose()\r\n det = self.determinant()\r\n print(\"1/(\" + str(det) + \")\")\r\n result.out()\r\n return result","def invert(self,el):\n return el^(self.q-2)","def _inverse(self, y):\n d = self._compute_shared(y=y)\n rely = y - d.y_k # tf.where(d.out_of_bounds, tf.zeros_like(y), y - d.y_k)\n term2 = rely * (d.d_kp1 + d.d_k - 2 * d.s_k)\n # These terms are the a, b, c terms of the quadratic formula.\n a = d.h_k * (d.s_k - d.d_k) + term2\n b = d.h_k * d.d_k - term2\n c = -d.s_k * rely\n # The expression used here has better numerical behavior for small 4*a*c.\n relx = tf.where(\n tf.equal(rely, 0), tf.zeros_like(a),\n (2 * c) / (-b - tf.sqrt(b**2 - 4 * a * c)))\n return relx * d.w_k + d.x_k #tf.where(d.out_of_bounds, y, relx * d.w_k + d.x_k)","def inverse(self):\n # find the determinant of the matrix\n determinant = self.determinant()\n # find the matrix of minors of the matrix\n matrix_of_minors = self.matrix_of_minors()\n # find the cofactor of the matrix of minors\n cofactor_matrix = self.cofactor_matrix(matrix_of_minors)\n # find the transpose of the cofactor matrix\n transpose_cofactor_matrix = self.transpose(cofactor_matrix)\n # find the adjugate (inverse) matrix\n inverse_matrix = self.adjugate_matrix(determinant, transpose_cofactor_matrix)\n\n return inverse_matrix","def inv_inplace(a):","def invert(self, solution, inverse_data):\n status = solution['status']\n\n primal_vars = None\n dual_vars = None\n if status in s.SOLUTION_PRESENT:\n opt_val = solution['value'] + inverse_data[s.OFFSET]\n primal_vars = {inverse_data[self.VAR_ID]: solution['primal']}\n return Solution(status, opt_val, primal_vars, dual_vars, {})\n else:\n return failure_solution(status)","def compute_inverse(in1, in2):\n aL = [in1]\n bL = [in2]\n tL = [0]\n t = 1\n sL = [1]\n s = 0\n q = math.floor((aL[0] / bL[0]))\n r = (aL[0] - (q * bL[0]))\n\n while r > 0:\n temp = (tL[0] - (q * bL[0]))\n tL[0] = t\n t = temp\n temp = (sL[0] - (q * s))\n sL[0] = s\n s = temp\n aL[0] = bL[0]\n bL[0] = r\n q = math.floor(aL[0] / bL[0])\n r = (aL[0] - (q * bL[0]))\n\n inverse = s % in2\n return inverse","def _r_inv(self):\n raise NotImplementedError","def inverse(self):\n data = np.linalg.inv(self._data)\n return self.create(self.rows, self.cols, data)","def __invert__(self):\n return self.inverse()","def support_inverse(rho):\n return LA.pinv(rho)","def test_inverse_c(self):\n for q in self.all:\n self.assertTrue((q * q.inverse()).almost_equal(q.inverse()*q))","def inverse(self):\n myMatrix = np.array(self.Matrix)\n if np.linalg.det(myMatrix) == 0:\n print(\"This matrix has a determinant of 0, meaning it has no inverse\")\n else:\n self.Inverse = np.linalg.inv(myMatrix)\n print(\"This is the inverse to your matrix: \", self.Inverse)","def _get_inv(self):\n m,d = self.B.shape\n Im = np.eye(m)\n Id = np.eye(d)\n BBt = self.B@self.B.T\n I_BBt_inv = np.linalg.pinv(Im + BBt)\n \n return (1/self.alpha)*(Id - self.B.T@( I_BBt_inv@self.B/self.alpha))","def inverse_transform(self, X):\n ...","def inverse_transform(self, X):\n ...","def inverse_transform(self, X):\n ...","def inverse_transform(self, X):\n ...","def inverse_transform(self, X):\n ...","def test_functional_inverse(self, dim):\n M = np.random.rand(dim, dim)\n assert np.all(M == symplectic.xxpp_to_xpxp(symplectic.xpxp_to_xxpp(M)))\n assert np.all(M == symplectic.xpxp_to_xxpp(symplectic.xxpp_to_xpxp(M)))\n\n v = np.random.rand(dim)\n assert np.all(v == symplectic.xxpp_to_xpxp(symplectic.xpxp_to_xxpp(v)))\n assert np.all(v == symplectic.xpxp_to_xxpp(symplectic.xxpp_to_xpxp(v)))","def inv(self,output,*args,**kwargs):\n raise ModelTypeError('Model is not invertible')","def modular_inverse(self):\n i = gmpy2.invert(self.c2, self.n)\n mx = pow(self.c1, self.a, self.n)\n my = pow(i, int(-self.b), self.n)\n self.m= mx * my % self.n","def Inverse(self, freedofs: pyngcore.BitArray = None, inverse: str = '') -> BaseMatrix:","def Inverse(self, freedofs: pyngcore.BitArray = None, inverse: str = '') -> BaseMatrix:","def _inverse(self, x):\n alpha, beta = self._get_alpha_beta()\n diff = x - self.x0\n r = tf.linalg.norm(diff, axis=-1, keepdims=True)\n h = 1. / (alpha + r)\n beta_h = beta * h\n return x + beta_h * diff","def inv(self, y):\n pass","def _r_inv(self):\n # [output_dim, output_dim]\n return tf.linalg.cholesky_solve(\n self._chol_obs_covariance,\n tf.eye(self.emission.output_dim, dtype=self._chol_obs_covariance.dtype),\n )","def inv(self, check=True, maxtries=float(\"inf\"), debug=False):\n if self.x == 0 or self.y == 0:\n return matrix(0)\n elif self.x == 1 or self.y == 1:\n return self*self.retrieve(0,0)**-1.0\n elif not (check and self.det() == 0.0):\n size = self.y\n out = getcopy(self)\n out.augment(diagmatrix(size))\n out.keepsolvingfull(False, maxtries, debug)\n return matrixlist(out.getaugment(size), self.converter).trans()\n else:\n raise IndexError(\"Matrix inverse does not exist because of 0 determinant\")","def inverse(self):\n if not self.is_square():\n raise(ValueError, \"Non-square Matrix does not have an inverse.\")\n if self.h > 2:\n raise(NotImplementedError, \"inversion not implemented for matrices larger than 2x2.\")\n\n # TODO - your code here\n if self.h == 1:\n inverse = [[1/self.g[0][0]]];\n else:\n a = self.g[0][0];\n b = self.g[0][1];\n c = self.g[1][0];\n d = self.g[1][1];\n if(a*d==b*c):\n raise ValueError('matrix does not have a inverse!');\n else:\n weigh = 1/(a*d-b*c);\n inverse = [[weigh*d,weigh*-1*b],[weigh*-1*c,weigh*a]];\n return Matrix(inverse);","def inverse(self,mat):\n result = np.linalg.inv(mat)\n self.out = result\n return self.out","def diffeo_inverse(a):\n M, N = a.shape[0], a.shape[1]\n result = np.empty_like(a)\n result.fill(-1) # fill invalid data\n many = np.zeros((M, N))\n many.fill(0)\n for i, j in coords_iterate((M, N)):\n i1 = a[i, j, 0]\n j1 = a[i, j, 1]\n result[i1, j1, 0] = i\n result[i1, j1, 1] = j\n many[i1, j1] += 1\n\n num = (many == 0).sum()\n if num:\n fill_invalid(result[:, :, 0], -1)\n fill_invalid(result[:, :, 1], -1)\n\n return result","def get_inverse(a):\n if len(a) == len(a[0]):\n i = get_identity(len(a))\n inverse = gaussian_solve(a, i)\n return inverse","def inv(self):\n\n self.x, self.y = self.y, self.x\n self._x_, self._y_ = self._y_, self._x_\n self.xfac, self.yfac = 1 / self.yfac, 1 / self.xfac\n self._xfac_, self._yfac_ = 1 / self._yfac_, 1 / self._xfac_\n self._u = 1 / self._u.conj()","def inverse(self):\n return self.invert()","def inv(q):\n return q * np.array([-1,-1,-1,1]) / amplitude(q) ** 2","def inverse(self):\n return self._inverse","def inv(a):\n a, cv, isMatrix = get_computation_matrix(a)\n t_dtype = TypeUtil.to_numpy_dtype(a.get_dtype())\n if a.numRows() != a.numCols():\n raise ValueError(\"inv: input a is not a square matrix!\")\n #compute LU using getrf\n (lu, piv, _) = getrf(a, overwrite_a=1, dtype=t_dtype)\n (ainv, _) = getri(lu, piv, lwork=0, overwrite_lu=1, dtype=t_dtype)\n if cv:\n if isMatrix:\n return ainv.to_numpy_matrix()\n else:\n return ainv.to_numpy_array()\n else:\n return ainv","def inverse(self):\r\n \r\n Mi=mat4()\r\n d=self.determinant()\r\n for i in range(4):\r\n for j in range(4):\r\n sign=1-((i+j)%2)*2\r\n m3=self._submat(i,j)\r\n Mi[j,i]=sign*m3.determinant()/d\r\n return Mi","def opposite(x):\n return -1*x","def ssc.inverse (x_ij):\n\n Hij = xyzrph2matrix (x_ij)\n Rji = Hij[0:3, 0:3]\n tij = Hij[0:3,3]\n Rij = Rji.transpose ()\n tji = -Rij.dot (tij)\n Hji = zeros ((4,4))\n Hji[0:3,0:3] = Rij\n Hji[0:3,3] = tji\n Hji[3,3] = 1\n return matrix2xyzrph (Hji)","def inverse(self):\n def inv(v):\n v[0], v[1] = v[1] , v[0]\n for v in [self.point1 , self.pointN , self.unitv, self.normalv]:\n inv(v)\n\n self.points = numpy.roll(self.points,1,axis=1)\n self.a, self.b = self.b, self.a\n self.angle = numpy.arccos( self.unitv[0] )*numpy.sign(self.unitv[1] )\n return","def inverse_transform(v):\n v, k = divmod(v - 1, N)\n v, j = divmod(v, N)\n v, i = divmod(v, N)\n return i, j, k","def inverse_basis(T, dimensions, t):\n B = basis(T, dimensions, t)\n return inv(B.T.dot(B)).dot(B.T)","def test_inverse_transform(self):","def inv(X):\n R, t = Rt(X)\n Ri = R.T\n return np.concatenate((\n np.concatenate((Ri, -Ri.dot(t)[:,np.newaxis]), axis=1),\n np.array([[0, 0, 1]])))","def inverse(self):\n if self.inv is None:\n if self.size > 0:\n self.inv = inverseIndex(self)\n else:\n self.inv = Connectivity()\n return self.inv","def inverse(self, x):\n x = np.asarray(x)\n def r(vec):\n return utils.recycled(vec, as_=x)\n if self.zero is not None and self.multiplier is not None:\n x = x / r(self.multiplier) + r(self.zero)\n elif self.zero is not None:\n x = x + r(self.zero)\n elif self.multiplier is not None:\n x = x / r(self.multiplier)\n return x","def inverse(self, x):\n return self.mul(self.weights, x.unsqueeze(-1)).squeeze(-1) + self.shift\n #return self.mul(torch.inverse(self.weights), (x - self.shift).unsqueeze(-1)).squeeze(-1)","def test_inverse_of_linear_vector_transforms(free_alg: Drudge):\n\n dr = free_alg\n p = dr.names\n v = p.v\n\n a = Vec('a')\n b = Vec('b')\n\n defs = [\n dr.define(a, v + 1),\n dr.define(b, v - 1)\n ]\n res = dr.lvt_inv(defs)\n\n assert len(res) == 2\n half = Rational(1, 2)\n one_checked = False\n v_checked = False\n for i in res:\n if i.lhs == 1:\n assert (i - half * a + half * b).simplify() == 0\n one_checked = True\n elif i.lhs == v:\n assert (i - half * a - half * b).simplify() == 0\n v_checked = True\n else:\n assert False\n continue\n\n assert one_checked and v_checked","def test__inverse_transform_continuous(self):","def inverse(self):\n # TODO\n # detA\n if not self.is_square():\n raise(\n ValueError, \"Non-square Matrix does not have an inverse.\")\n if self.h > 2:\n raise(\n NotImplementedError, \"inversion not implemented for matrices larger than 2x2.\")\n\n mD = self.determinant()\n if self.h == 1:\n if self.g[0][0] = 0:\n raise(NotImplementedError,\n \"The 1x1 Matrix contains 0 can't inverse\")\n else:\n return [[1 / self.g[0][0]]] \n for i in range(self.h): # Calculates the inverse of a 2x2 Matrix.\n my_Matrix = zeroes(2, 2)\n my_Matrix.g[1][1] = self.g[0][0] / mD\n my_Matrix.g[0][0] = self.g[1][1] / mD\n my_Matrix.g[0][1] = - self.g[0][1] / mD\n my_Matrix.g[1][0] = - self.g[1][0] / mD\n return my_Matrix\n\n # trace A\n # 与矩阵TraceA * I identity 单位矩阵","def inv(self):\n return self.conjugate()","def __invert(self, args):","def inverse(self):\n n = self.norm()\n c = self.conj()\n d = 1.0 / (n * n)\n c.scale(d)\n return c","def inverse(self, u: Tensor, covariates: Tensor) -> Tensor:\n return self.real_nvp.inverse(u, covariates)","def inv(self):\n self.inverse = not self._inverse\n return self","def inverse(self: T) -> T:","def InverseMatrix(matrix,vector):\r\n # Unveri reversible matrix\r\n if Determinant(matrix, 1) == 0:\r\n print(\"Error,Singular Matrix\\n\")\r\n return\r\n # result matrix initialized as singularity matrix\r\n result = MakeIMatrix(len(matrix), len(matrix))\r\n # loop for each row\r\n for i in range(len(matrix[0])):\r\n # turn the pivot into 1 (make elementary matrix and multiply with the result matrix )\r\n # pivoting process\r\n matrix, vector = RowXchange(matrix, vector)\r\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\r\n elementary[i][i] = 1/matrix[i][i]\r\n result = MultiplyMatrix(elementary, result)\r\n matrix = MultiplyMatrix(elementary, matrix)\r\n # make elementary loop to iterate for each row and subtracrt the number below (specific) pivot to zero (make\r\n # elementary matrix and multiply with the result matrix )\r\n for j in range(i+1, len(matrix)):\r\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\r\n elementary[j][i] = -(matrix[j][i])\r\n matrix = MultiplyMatrix(elementary, matrix)\r\n result = MultiplyMatrix(elementary, result)\r\n\r\n\r\n # after finishing with the lower part of the matrix subtract the numbers above the pivot with elementary for loop\r\n # (make elementary matrix and multiply with the result matrix )\r\n for i in range(len(matrix[0])-1, 0, -1):\r\n for j in range(i-1, -1, -1):\r\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\r\n elementary[j][i] = -(matrix[j][i])\r\n matrix = MultiplyMatrix(elementary, matrix)\r\n result = MultiplyMatrix(elementary, result)\r\n\r\n return result","def invert(self, results, inverse_data):\n import mosek\n # Status map is taken from:\n # https://docs.mosek.com/8.1/pythonapi/constants.html?highlight=solsta#mosek.solsta\n STATUS_MAP = {mosek.solsta.optimal: s.OPTIMAL,\n mosek.solsta.integer_optimal: s.OPTIMAL,\n mosek.solsta.prim_feas: s.OPTIMAL_INACCURATE, # for integer problems\n mosek.solsta.prim_infeas_cer: s.INFEASIBLE,\n mosek.solsta.dual_infeas_cer: s.UNBOUNDED}\n # \"Near\" statuses only up to Mosek 8.1\n if hasattr(mosek.solsta, 'near_optimal'):\n STATUS_MAP_INACCURATE = {mosek.solsta.near_optimal: s.OPTIMAL_INACCURATE,\n mosek.solsta.near_integer_optimal: s.OPTIMAL_INACCURATE,\n mosek.solsta.near_prim_infeas_cer: s.INFEASIBLE_INACCURATE,\n mosek.solsta.near_dual_infeas_cer: s.UNBOUNDED_INACCURATE}\n STATUS_MAP.update(STATUS_MAP_INACCURATE)\n STATUS_MAP = defaultdict(lambda: s.SOLVER_ERROR, STATUS_MAP)\n\n env = results['env']\n task = results['task']\n solver_opts = results['solver_options']\n\n if inverse_data['integer_variables']:\n sol = mosek.soltype.itg\n elif 'bfs' in solver_opts and solver_opts['bfs'] and inverse_data['is_LP']:\n sol = mosek.soltype.bas # the basic feasible solution\n else:\n sol = mosek.soltype.itr # the solution found via interior point method\n\n problem_status = task.getprosta(sol)\n solution_status = task.getsolsta(sol)\n\n status = STATUS_MAP[solution_status]\n\n # For integer problems, problem status determines infeasibility (no solution)\n if sol == mosek.soltype.itg and problem_status == mosek.prosta.prim_infeas:\n status = s.INFEASIBLE\n\n if status in s.SOLUTION_PRESENT:\n # get objective value\n opt_val = task.getprimalobj(sol) + inverse_data[s.OBJ_OFFSET]\n # recover the cvxpy standard-form primal variable\n z = [0.] * inverse_data['n0']\n task.getxxslice(sol, 0, len(z), z)\n primal_vars = {inverse_data[self.VAR_ID]: z}\n # recover the cvxpy standard-form dual variables\n if sol == mosek.soltype.itg:\n dual_vars = None\n else:\n dual_vars = MOSEK.recover_dual_variables(task, sol, inverse_data)\n else:\n if status == s.INFEASIBLE:\n opt_val = np.inf\n elif status == s.UNBOUNDED:\n opt_val = -np.inf\n else:\n opt_val = None\n primal_vars = None\n dual_vars = None\n\n # Store computation time\n attr = {s.SOLVE_TIME: task.getdouinf(mosek.dinfitem.optimizer_time)}\n\n # Delete the mosek Task and Environment\n task.__exit__(None, None, None)\n env.__exit__(None, None, None)\n\n return Solution(status, opt_val, primal_vars, dual_vars, attr)","def __invert__(self):\n try:\n B = ~(self.matrix())\n except ZeroDivisionError:\n raise ZeroDivisionError(\"matrix morphism not invertible\")\n try:\n return self.parent().reversed()(B)\n except TypeError:\n raise ZeroDivisionError(\"matrix morphism not invertible\")","def inverse_rigid_trans(Tr): \n inv_Tr = np.zeros_like(Tr) # 3x4\n inv_Tr[0:3,0:3] = np.transpose(Tr[0:3,0:3])\n inv_Tr[0:3,3] = np.dot(-np.transpose(Tr[0:3,0:3]), Tr[0:3,3])\n return inv_Tr","def inverse(self):\n cdef StdVectorFst result = self.copy()\n result.invert()\n return result","def Mq_inv(self, q):\n\t\traise NotImplementedError","def inverse(self) -> np.ndarray:\n if self.is_versor():\n return self.conjugate\n return self.conjugate / np.linalg.norm(self.q)","def inverse(self):\n if self.determinant() != 0:\n ops = reduce_to_red_echelon(self.data.copy(), True)[1]\n matrix = identity_matrix(self.n_rows).data\n \n if ops:\n if isinstance(ops[0], str):\n ops = [ops]\n \n for op in ops:\n if op[0] == 'swap':\n matrix = row_swap(matrix, op[1], op[2])\n elif op[0] == 'multiplication':\n matrix = row_multiply(matrix, op[1], op[2])\n elif op[0] == 'subtract':\n matrix = row_subtract(matrix, op[1], op[2], op[3])\n else:\n raise ValueError('Row operation not recognized')\n else:\n raise ValueError('Matrix has a determinant of 0 and is not invertible')\n return Matrix(matrix)","def inverse(self, x, *args, **kwargs):\n if self.list_of_inverses is None:\n utils.print_warning(\"inverses were not given\")\n return\n for i in range(len(self.list_of_inverses)):\n x = self.list_of_inverses[i](x, *args, **kwargs)\n return x","def inverse_matrice(T):\n a,b,c,d = T[0][0],T[0][1],T[1][0],T[1][1]\n det = a*d-b*c\n aa,bb,cc,dd = d/det,-b/det,-c/det,a/det\n Tinv = [[aa,bb],[cc,dd]]\n return Tinv","def inverse(self):\n ss = self._sum_of_squares()\n if ss > 0:\n return self.__class__(array=(self._vector_conjugate() / ss))\n else:\n raise ZeroDivisionError(\"a zero quaternion (0 + 0i + 0j + 0k) cannot be inverted\")","def inverse(self, z, y):\n y_summary = self.summary_net(y)\n return self.invertible_net(z, y_summary, inverse=True)","def inv(self):\n return MoebGen(self._d / self._det, - self._b / self._det, - self._c / self._det, self._a / self._det)","def find_inverse(a,n):\n if a==0 or gcd(a,n)!=1: return \".\"\n if a==1: return 1\n k=1\n while True:\n a_inv = (1+n*k)/a \n if a_inv.is_integer():\n return int(a_inv)\n else:\n k=k+1","def _vect_matrix_inverse(A):\n identity = np.identity(A.shape[2], dtype=A.dtype)\n return np.array([np.linalg.solve(x, identity) for x in A])","def inverse(num, r):\n if int(num) == 0:\n return 0\n else:\n # Multiply with every number in the field and\n # check if the result is one. Easy Peasy!\n # Todo: Use Extended Euclidean Algo\n # or Logs/Anti-Logs\n for i in range(1, 256):\n if _multiply(num, i, r) == 1:\n return i","def inverse_transform(self, x):\n raise NotImplementedError()","def solve(self):","def inverse(self, y):\n device = y.device\n return t.einsum('ij,k,kj->ik', y, 1. / t.sqrt(self.eig).to(device), self.rot.to(device))","def inverse_transform(self, X):\n\n pass # pragma: no cover","def inverse(self):\n return ~self","def inverse(self: Float[LinearOperator, \"*batch N N\"]) -> Float[LinearOperator, \"*batch N N\"]:\n return self.__class__(self._diag.reciprocal())","def _tridi_inverse_iteration(d, e, w, x0=None, rtol=1e-6):\n\teig_diag = d - w\n\tif x0 is None:\n\t\tx0 = np.random.randn(len(d))\n\tx_prev = np.zeros_like(x0)\n\tnorm_x = np.linalg.norm(x0)\n\t# the eigenvector is unique up to sign change, so iterate\n\t# until || |x^(n)| - |x^(n-1)| ||^2 < rtol\n\tx0 /= norm_x\n\twhile np.linalg.norm(np.abs(x0) - np.abs(x_prev)) > rtol:\n\t\tx_prev = x0.copy()\n\t\t_tridisolve(eig_diag, e, x0)\n\t\tnorm_x = np.linalg.norm(x0)\n\t\tx0 /= norm_x\n\treturn x0","def mod_inverse_iterative(a, b):\n x, y, u, v = 0, 1, 1, 0\n while a != 0:\n q = int(b / a)\n r = b % a\n m = x - u * q\n n = y - v * q\n b, a, x, y, u, v = a, r, u, v, m, n\n return b, x, y","def invertible(A, B):\n\tdetA = la.det(A)\n\tdetB = la.det(B)\n\t\n\tif (detA == 0):\n\t\tif (detB == 0):\n\t\t\tprint(\"None are invertible\")\n\t\telse:\n\t\t\treturn B\n\telse:\n\t\tif (detB == 0):\n\t\t\treturn A\n\t\telse:\n\t\t\tprint(\"Both are invertible\")","def invert(self):\n if self.m != self.n:\n raise exc.LinearAlgebraError(\"cannot invert a non-square matrix\")\n if self.determinant == 0:\n raise exc.LinearAlgebraError(\"cannot invert a singular matrix\")\n # TODO: implement block matrices in their own method\n block_rows = [r1 + r2 for r1, r2 in\n zip(self.data, self.makeIdentity(self.m).data)]\n inverse_block = Matrix.fromRows(block_rows).row_reduce()\n return inverse_block.subset([i for i in range(self.m)],\n [j + self.n for j in range(self.n)])","def pseudoInversa(J):\n\tJinv = np.linalg.pinv(J)\n\treturn Jinv","def inverse_transform(self, y: Array2D) -> Array2D:","def test_inverse_non_interacting(self, size):\n t_nn = 1.2\n idx = np.arange(size)\n g0_inv_full = np.zeros((size, size), dtype=complex)\n g0_inv_full[idx[:-1], idx[1:]] = g0_inv_full[idx[1:], idx[:-1]] = t_nn\n for g0 in self.g0_loc_inv:\n g0_inv_full[idx, idx] = g0\n rv, h, rv_inv = gt.matrix.decompose_gf(g0_inv_full)\n g0 = gt.matrix.construct_gf(rv_inv=rv_inv, diag_inv=h**-1, rv=rv)\n assert_allclose(g0.dot(g0_inv_full), np.identity(size), atol=1e-14)\n assert_allclose(g0, la.inv(g0_inv_full))\n g0_alt = gt.matrix.Decomposition(rv, h**-1, rv_inv).reconstruct(kind='full')\n assert_allclose(g0, g0_alt)","def inverse(self, ys):\n with torch.no_grad():\n xs = torch.matmul(ys, torch.diag(torch.reciprocal(torch.exp(self.scaling_diag))))\n xs = self.layer4.inverse(xs)\n xs = self.layer3.inverse(xs)\n xs = self.layer2.inverse(xs)\n xs = self.layer1.inverse(xs)\n return xs","def ginverse(p, x):\n x_ = x.data\n sinu = torch.sin(p.narrow(-1,0,1)).pow(2)\n x_.narrow(-1,1,1).mul_(sinu.pow(-1))\n return x_"],"string":"[\n \"def inverse(self):\\n return self.solve(Matrix.I(self.nrows))\",\n \"def inverse(self):\\n self.check_square()\\n\\n\\n N = self.rows\\n\\n inverse = make_matrix(N, N)\\n\\n # Solve on a per-column basis using Ax = b formalism\\n for j in range(N):\\n b = make_matrix(N, 1)\\n b[j, 0] = 1\\n\\n x = self.solve_linear_system(b)\\n\\n for i in range(N):\\n inverse[i, j] = x[i, 0]\\n\\n return inverse\",\n \"def inverse( m, context = FloatContext, copy_m=True ):\\n n,n_ = shape_mat(m)\\n assert (n==n_) #matris should be square\\n\\n return solve( m, eye(n), context=context, copy_b=False, copy_a=copy_m )\",\n \"def _inv(self) -> None:\\n\\n self.inv(inplace=True)\",\n \"def inverse(self, x, y):\",\n \"def invert(x):\\n return linalg.inv(x)\",\n \"def inv(P):\\n L = cho_factor(P)\\n return cho_solve(L, np.eye(P.shape[0]))\",\n \"def inv(in_A):\\n Q,R = qr(in_A)\\n QT = Q.T\\n N = shape(in_A)[0]\\n \\n for n in range(N-1,-1,-1):\\n Rnn = R[n,n]\\n R[n,:] /= Rnn\\n QT[n,:] /= Rnn\\n for m in range(n+1,N):\\n Rnm = R[n,m]\\n R[n,m] = 0\\n QT[n,:] -= QT[m,:]*Rnm\\n\\n return QT\",\n \"def inv(self):\\n\\t\\tdeterminant = self.det()\\n\\t\\tif determinant:\\n\\t\\t\\treturn self.adj() / determinant\\n\\t\\telse:\\n\\t\\t\\traise ValueError(\\\"Not Invertible\\\")\",\n \"def inverse(self):\\n if not self.is_square():\\n raise(ValueError, \\\"Non-square Matrix does not have an inverse.\\\")\\n if self.h > 2:\\n raise(NotImplementedError, \\\"inversion not implemented for matrices larger than 2x2.\\\")\\n # TODO - your code here\\n inverse = []\\n if self.h == 1:\\n temp = []\\n temp.append(1/self.g[0][0])\\n inverse.append(temp)\\n else:\\n identity_matrix = identity(self.h)\\n det_term = 1/self.determinant()\\n trace_term = self.trace()\\n # implement intermediate scaling step locally\\n # trace_x_I = trace_term * identity_matrix\\n trace_x_I = []\\n for i in range(len(self.g)):\\n temp_row = []\\n for j in range(len(self.g[i])):\\n temp_row.append(trace_term * identity_matrix[i][j])\\n trace_x_I.append(temp_row)\\n # implement sub-traction locally\\n # sub_term = trace_x_I - self.g\\n sub_term = []\\n for i in range(len(trace_x_I)):\\n temp_row = []\\n for j in range(len(trace_x_I[i])):\\n temp_row.append(trace_x_I[i][j] - self.g[i][j])\\n sub_term.append(temp_row)\\n # implement final scaling step locally\\n # inverse = det_term * sub_term\\n inverse = []\\n for i in range(len(sub_term)):\\n temp_row = []\\n for j in range(len(sub_term[i])):\\n temp_row.append(det_term * sub_term[i][j])\\n inverse.append(temp_row)\\n return Matrix(inverse)\\n # TODO - your code here\",\n \"def erfcinv(a):\",\n \"def inverse(self) -> 'Invertible':\\n raise NotImplementedError\",\n \"def inverse (x_ij):\\n\\n Hij = xyzrph2matrix (x_ij)\\n Rji = Hij[0:3, 0:3]\\n tij = Hij[0:3,3]\\n Rij = Rji.transpose ()\\n tji = -Rij.dot (tij)\\n Hji = numpy.zeros ((4,4))\\n Hji[0:3,0:3] = Rij\\n Hji[0:3,3] = tji\\n Hji[3,3] = 1\\n return matrix2xyzrph (Hji)\",\n \"def inverseN(self):\\r\\n result = Matrix(self.rows, self.columns)\\r\\n for r in range(self.rows):\\r\\n for c in range(self.columns):\\r\\n result.mat[r][c] = self.cofactor(r, c)\\r\\n result.out()\\r\\n result = result.transpose()\\r\\n det = self.determinant()\\r\\n print(\\\"1/(\\\" + str(det) + \\\")\\\")\\r\\n result.out()\\r\\n return result\",\n \"def invert(self,el):\\n return el^(self.q-2)\",\n \"def _inverse(self, y):\\n d = self._compute_shared(y=y)\\n rely = y - d.y_k # tf.where(d.out_of_bounds, tf.zeros_like(y), y - d.y_k)\\n term2 = rely * (d.d_kp1 + d.d_k - 2 * d.s_k)\\n # These terms are the a, b, c terms of the quadratic formula.\\n a = d.h_k * (d.s_k - d.d_k) + term2\\n b = d.h_k * d.d_k - term2\\n c = -d.s_k * rely\\n # The expression used here has better numerical behavior for small 4*a*c.\\n relx = tf.where(\\n tf.equal(rely, 0), tf.zeros_like(a),\\n (2 * c) / (-b - tf.sqrt(b**2 - 4 * a * c)))\\n return relx * d.w_k + d.x_k #tf.where(d.out_of_bounds, y, relx * d.w_k + d.x_k)\",\n \"def inverse(self):\\n # find the determinant of the matrix\\n determinant = self.determinant()\\n # find the matrix of minors of the matrix\\n matrix_of_minors = self.matrix_of_minors()\\n # find the cofactor of the matrix of minors\\n cofactor_matrix = self.cofactor_matrix(matrix_of_minors)\\n # find the transpose of the cofactor matrix\\n transpose_cofactor_matrix = self.transpose(cofactor_matrix)\\n # find the adjugate (inverse) matrix\\n inverse_matrix = self.adjugate_matrix(determinant, transpose_cofactor_matrix)\\n\\n return inverse_matrix\",\n \"def inv_inplace(a):\",\n \"def invert(self, solution, inverse_data):\\n status = solution['status']\\n\\n primal_vars = None\\n dual_vars = None\\n if status in s.SOLUTION_PRESENT:\\n opt_val = solution['value'] + inverse_data[s.OFFSET]\\n primal_vars = {inverse_data[self.VAR_ID]: solution['primal']}\\n return Solution(status, opt_val, primal_vars, dual_vars, {})\\n else:\\n return failure_solution(status)\",\n \"def compute_inverse(in1, in2):\\n aL = [in1]\\n bL = [in2]\\n tL = [0]\\n t = 1\\n sL = [1]\\n s = 0\\n q = math.floor((aL[0] / bL[0]))\\n r = (aL[0] - (q * bL[0]))\\n\\n while r > 0:\\n temp = (tL[0] - (q * bL[0]))\\n tL[0] = t\\n t = temp\\n temp = (sL[0] - (q * s))\\n sL[0] = s\\n s = temp\\n aL[0] = bL[0]\\n bL[0] = r\\n q = math.floor(aL[0] / bL[0])\\n r = (aL[0] - (q * bL[0]))\\n\\n inverse = s % in2\\n return inverse\",\n \"def _r_inv(self):\\n raise NotImplementedError\",\n \"def inverse(self):\\n data = np.linalg.inv(self._data)\\n return self.create(self.rows, self.cols, data)\",\n \"def __invert__(self):\\n return self.inverse()\",\n \"def support_inverse(rho):\\n return LA.pinv(rho)\",\n \"def test_inverse_c(self):\\n for q in self.all:\\n self.assertTrue((q * q.inverse()).almost_equal(q.inverse()*q))\",\n \"def inverse(self):\\n myMatrix = np.array(self.Matrix)\\n if np.linalg.det(myMatrix) == 0:\\n print(\\\"This matrix has a determinant of 0, meaning it has no inverse\\\")\\n else:\\n self.Inverse = np.linalg.inv(myMatrix)\\n print(\\\"This is the inverse to your matrix: \\\", self.Inverse)\",\n \"def _get_inv(self):\\n m,d = self.B.shape\\n Im = np.eye(m)\\n Id = np.eye(d)\\n BBt = self.B@self.B.T\\n I_BBt_inv = np.linalg.pinv(Im + BBt)\\n \\n return (1/self.alpha)*(Id - self.B.T@( I_BBt_inv@self.B/self.alpha))\",\n \"def inverse_transform(self, X):\\n ...\",\n \"def inverse_transform(self, X):\\n ...\",\n \"def inverse_transform(self, X):\\n ...\",\n \"def inverse_transform(self, X):\\n ...\",\n \"def inverse_transform(self, X):\\n ...\",\n \"def test_functional_inverse(self, dim):\\n M = np.random.rand(dim, dim)\\n assert np.all(M == symplectic.xxpp_to_xpxp(symplectic.xpxp_to_xxpp(M)))\\n assert np.all(M == symplectic.xpxp_to_xxpp(symplectic.xxpp_to_xpxp(M)))\\n\\n v = np.random.rand(dim)\\n assert np.all(v == symplectic.xxpp_to_xpxp(symplectic.xpxp_to_xxpp(v)))\\n assert np.all(v == symplectic.xpxp_to_xxpp(symplectic.xxpp_to_xpxp(v)))\",\n \"def inv(self,output,*args,**kwargs):\\n raise ModelTypeError('Model is not invertible')\",\n \"def modular_inverse(self):\\n i = gmpy2.invert(self.c2, self.n)\\n mx = pow(self.c1, self.a, self.n)\\n my = pow(i, int(-self.b), self.n)\\n self.m= mx * my % self.n\",\n \"def Inverse(self, freedofs: pyngcore.BitArray = None, inverse: str = '') -> BaseMatrix:\",\n \"def Inverse(self, freedofs: pyngcore.BitArray = None, inverse: str = '') -> BaseMatrix:\",\n \"def _inverse(self, x):\\n alpha, beta = self._get_alpha_beta()\\n diff = x - self.x0\\n r = tf.linalg.norm(diff, axis=-1, keepdims=True)\\n h = 1. / (alpha + r)\\n beta_h = beta * h\\n return x + beta_h * diff\",\n \"def inv(self, y):\\n pass\",\n \"def _r_inv(self):\\n # [output_dim, output_dim]\\n return tf.linalg.cholesky_solve(\\n self._chol_obs_covariance,\\n tf.eye(self.emission.output_dim, dtype=self._chol_obs_covariance.dtype),\\n )\",\n \"def inv(self, check=True, maxtries=float(\\\"inf\\\"), debug=False):\\n if self.x == 0 or self.y == 0:\\n return matrix(0)\\n elif self.x == 1 or self.y == 1:\\n return self*self.retrieve(0,0)**-1.0\\n elif not (check and self.det() == 0.0):\\n size = self.y\\n out = getcopy(self)\\n out.augment(diagmatrix(size))\\n out.keepsolvingfull(False, maxtries, debug)\\n return matrixlist(out.getaugment(size), self.converter).trans()\\n else:\\n raise IndexError(\\\"Matrix inverse does not exist because of 0 determinant\\\")\",\n \"def inverse(self):\\n if not self.is_square():\\n raise(ValueError, \\\"Non-square Matrix does not have an inverse.\\\")\\n if self.h > 2:\\n raise(NotImplementedError, \\\"inversion not implemented for matrices larger than 2x2.\\\")\\n\\n # TODO - your code here\\n if self.h == 1:\\n inverse = [[1/self.g[0][0]]];\\n else:\\n a = self.g[0][0];\\n b = self.g[0][1];\\n c = self.g[1][0];\\n d = self.g[1][1];\\n if(a*d==b*c):\\n raise ValueError('matrix does not have a inverse!');\\n else:\\n weigh = 1/(a*d-b*c);\\n inverse = [[weigh*d,weigh*-1*b],[weigh*-1*c,weigh*a]];\\n return Matrix(inverse);\",\n \"def inverse(self,mat):\\n result = np.linalg.inv(mat)\\n self.out = result\\n return self.out\",\n \"def diffeo_inverse(a):\\n M, N = a.shape[0], a.shape[1]\\n result = np.empty_like(a)\\n result.fill(-1) # fill invalid data\\n many = np.zeros((M, N))\\n many.fill(0)\\n for i, j in coords_iterate((M, N)):\\n i1 = a[i, j, 0]\\n j1 = a[i, j, 1]\\n result[i1, j1, 0] = i\\n result[i1, j1, 1] = j\\n many[i1, j1] += 1\\n\\n num = (many == 0).sum()\\n if num:\\n fill_invalid(result[:, :, 0], -1)\\n fill_invalid(result[:, :, 1], -1)\\n\\n return result\",\n \"def get_inverse(a):\\n if len(a) == len(a[0]):\\n i = get_identity(len(a))\\n inverse = gaussian_solve(a, i)\\n return inverse\",\n \"def inv(self):\\n\\n self.x, self.y = self.y, self.x\\n self._x_, self._y_ = self._y_, self._x_\\n self.xfac, self.yfac = 1 / self.yfac, 1 / self.xfac\\n self._xfac_, self._yfac_ = 1 / self._yfac_, 1 / self._xfac_\\n self._u = 1 / self._u.conj()\",\n \"def inverse(self):\\n return self.invert()\",\n \"def inv(q):\\n return q * np.array([-1,-1,-1,1]) / amplitude(q) ** 2\",\n \"def inverse(self):\\n return self._inverse\",\n \"def inv(a):\\n a, cv, isMatrix = get_computation_matrix(a)\\n t_dtype = TypeUtil.to_numpy_dtype(a.get_dtype())\\n if a.numRows() != a.numCols():\\n raise ValueError(\\\"inv: input a is not a square matrix!\\\")\\n #compute LU using getrf\\n (lu, piv, _) = getrf(a, overwrite_a=1, dtype=t_dtype)\\n (ainv, _) = getri(lu, piv, lwork=0, overwrite_lu=1, dtype=t_dtype)\\n if cv:\\n if isMatrix:\\n return ainv.to_numpy_matrix()\\n else:\\n return ainv.to_numpy_array()\\n else:\\n return ainv\",\n \"def inverse(self):\\r\\n \\r\\n Mi=mat4()\\r\\n d=self.determinant()\\r\\n for i in range(4):\\r\\n for j in range(4):\\r\\n sign=1-((i+j)%2)*2\\r\\n m3=self._submat(i,j)\\r\\n Mi[j,i]=sign*m3.determinant()/d\\r\\n return Mi\",\n \"def opposite(x):\\n return -1*x\",\n \"def ssc.inverse (x_ij):\\n\\n Hij = xyzrph2matrix (x_ij)\\n Rji = Hij[0:3, 0:3]\\n tij = Hij[0:3,3]\\n Rij = Rji.transpose ()\\n tji = -Rij.dot (tij)\\n Hji = zeros ((4,4))\\n Hji[0:3,0:3] = Rij\\n Hji[0:3,3] = tji\\n Hji[3,3] = 1\\n return matrix2xyzrph (Hji)\",\n \"def inverse(self):\\n def inv(v):\\n v[0], v[1] = v[1] , v[0]\\n for v in [self.point1 , self.pointN , self.unitv, self.normalv]:\\n inv(v)\\n\\n self.points = numpy.roll(self.points,1,axis=1)\\n self.a, self.b = self.b, self.a\\n self.angle = numpy.arccos( self.unitv[0] )*numpy.sign(self.unitv[1] )\\n return\",\n \"def inverse_transform(v):\\n v, k = divmod(v - 1, N)\\n v, j = divmod(v, N)\\n v, i = divmod(v, N)\\n return i, j, k\",\n \"def inverse_basis(T, dimensions, t):\\n B = basis(T, dimensions, t)\\n return inv(B.T.dot(B)).dot(B.T)\",\n \"def test_inverse_transform(self):\",\n \"def inv(X):\\n R, t = Rt(X)\\n Ri = R.T\\n return np.concatenate((\\n np.concatenate((Ri, -Ri.dot(t)[:,np.newaxis]), axis=1),\\n np.array([[0, 0, 1]])))\",\n \"def inverse(self):\\n if self.inv is None:\\n if self.size > 0:\\n self.inv = inverseIndex(self)\\n else:\\n self.inv = Connectivity()\\n return self.inv\",\n \"def inverse(self, x):\\n x = np.asarray(x)\\n def r(vec):\\n return utils.recycled(vec, as_=x)\\n if self.zero is not None and self.multiplier is not None:\\n x = x / r(self.multiplier) + r(self.zero)\\n elif self.zero is not None:\\n x = x + r(self.zero)\\n elif self.multiplier is not None:\\n x = x / r(self.multiplier)\\n return x\",\n \"def inverse(self, x):\\n return self.mul(self.weights, x.unsqueeze(-1)).squeeze(-1) + self.shift\\n #return self.mul(torch.inverse(self.weights), (x - self.shift).unsqueeze(-1)).squeeze(-1)\",\n \"def test_inverse_of_linear_vector_transforms(free_alg: Drudge):\\n\\n dr = free_alg\\n p = dr.names\\n v = p.v\\n\\n a = Vec('a')\\n b = Vec('b')\\n\\n defs = [\\n dr.define(a, v + 1),\\n dr.define(b, v - 1)\\n ]\\n res = dr.lvt_inv(defs)\\n\\n assert len(res) == 2\\n half = Rational(1, 2)\\n one_checked = False\\n v_checked = False\\n for i in res:\\n if i.lhs == 1:\\n assert (i - half * a + half * b).simplify() == 0\\n one_checked = True\\n elif i.lhs == v:\\n assert (i - half * a - half * b).simplify() == 0\\n v_checked = True\\n else:\\n assert False\\n continue\\n\\n assert one_checked and v_checked\",\n \"def test__inverse_transform_continuous(self):\",\n \"def inverse(self):\\n # TODO\\n # detA\\n if not self.is_square():\\n raise(\\n ValueError, \\\"Non-square Matrix does not have an inverse.\\\")\\n if self.h > 2:\\n raise(\\n NotImplementedError, \\\"inversion not implemented for matrices larger than 2x2.\\\")\\n\\n mD = self.determinant()\\n if self.h == 1:\\n if self.g[0][0] = 0:\\n raise(NotImplementedError,\\n \\\"The 1x1 Matrix contains 0 can't inverse\\\")\\n else:\\n return [[1 / self.g[0][0]]] \\n for i in range(self.h): # Calculates the inverse of a 2x2 Matrix.\\n my_Matrix = zeroes(2, 2)\\n my_Matrix.g[1][1] = self.g[0][0] / mD\\n my_Matrix.g[0][0] = self.g[1][1] / mD\\n my_Matrix.g[0][1] = - self.g[0][1] / mD\\n my_Matrix.g[1][0] = - self.g[1][0] / mD\\n return my_Matrix\\n\\n # trace A\\n # 与矩阵TraceA * I identity 单位矩阵\",\n \"def inv(self):\\n return self.conjugate()\",\n \"def __invert(self, args):\",\n \"def inverse(self):\\n n = self.norm()\\n c = self.conj()\\n d = 1.0 / (n * n)\\n c.scale(d)\\n return c\",\n \"def inverse(self, u: Tensor, covariates: Tensor) -> Tensor:\\n return self.real_nvp.inverse(u, covariates)\",\n \"def inv(self):\\n self.inverse = not self._inverse\\n return self\",\n \"def inverse(self: T) -> T:\",\n \"def InverseMatrix(matrix,vector):\\r\\n # Unveri reversible matrix\\r\\n if Determinant(matrix, 1) == 0:\\r\\n print(\\\"Error,Singular Matrix\\\\n\\\")\\r\\n return\\r\\n # result matrix initialized as singularity matrix\\r\\n result = MakeIMatrix(len(matrix), len(matrix))\\r\\n # loop for each row\\r\\n for i in range(len(matrix[0])):\\r\\n # turn the pivot into 1 (make elementary matrix and multiply with the result matrix )\\r\\n # pivoting process\\r\\n matrix, vector = RowXchange(matrix, vector)\\r\\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\\r\\n elementary[i][i] = 1/matrix[i][i]\\r\\n result = MultiplyMatrix(elementary, result)\\r\\n matrix = MultiplyMatrix(elementary, matrix)\\r\\n # make elementary loop to iterate for each row and subtracrt the number below (specific) pivot to zero (make\\r\\n # elementary matrix and multiply with the result matrix )\\r\\n for j in range(i+1, len(matrix)):\\r\\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\\r\\n elementary[j][i] = -(matrix[j][i])\\r\\n matrix = MultiplyMatrix(elementary, matrix)\\r\\n result = MultiplyMatrix(elementary, result)\\r\\n\\r\\n\\r\\n # after finishing with the lower part of the matrix subtract the numbers above the pivot with elementary for loop\\r\\n # (make elementary matrix and multiply with the result matrix )\\r\\n for i in range(len(matrix[0])-1, 0, -1):\\r\\n for j in range(i-1, -1, -1):\\r\\n elementary = MakeIMatrix(len(matrix[0]), len(matrix))\\r\\n elementary[j][i] = -(matrix[j][i])\\r\\n matrix = MultiplyMatrix(elementary, matrix)\\r\\n result = MultiplyMatrix(elementary, result)\\r\\n\\r\\n return result\",\n \"def invert(self, results, inverse_data):\\n import mosek\\n # Status map is taken from:\\n # https://docs.mosek.com/8.1/pythonapi/constants.html?highlight=solsta#mosek.solsta\\n STATUS_MAP = {mosek.solsta.optimal: s.OPTIMAL,\\n mosek.solsta.integer_optimal: s.OPTIMAL,\\n mosek.solsta.prim_feas: s.OPTIMAL_INACCURATE, # for integer problems\\n mosek.solsta.prim_infeas_cer: s.INFEASIBLE,\\n mosek.solsta.dual_infeas_cer: s.UNBOUNDED}\\n # \\\"Near\\\" statuses only up to Mosek 8.1\\n if hasattr(mosek.solsta, 'near_optimal'):\\n STATUS_MAP_INACCURATE = {mosek.solsta.near_optimal: s.OPTIMAL_INACCURATE,\\n mosek.solsta.near_integer_optimal: s.OPTIMAL_INACCURATE,\\n mosek.solsta.near_prim_infeas_cer: s.INFEASIBLE_INACCURATE,\\n mosek.solsta.near_dual_infeas_cer: s.UNBOUNDED_INACCURATE}\\n STATUS_MAP.update(STATUS_MAP_INACCURATE)\\n STATUS_MAP = defaultdict(lambda: s.SOLVER_ERROR, STATUS_MAP)\\n\\n env = results['env']\\n task = results['task']\\n solver_opts = results['solver_options']\\n\\n if inverse_data['integer_variables']:\\n sol = mosek.soltype.itg\\n elif 'bfs' in solver_opts and solver_opts['bfs'] and inverse_data['is_LP']:\\n sol = mosek.soltype.bas # the basic feasible solution\\n else:\\n sol = mosek.soltype.itr # the solution found via interior point method\\n\\n problem_status = task.getprosta(sol)\\n solution_status = task.getsolsta(sol)\\n\\n status = STATUS_MAP[solution_status]\\n\\n # For integer problems, problem status determines infeasibility (no solution)\\n if sol == mosek.soltype.itg and problem_status == mosek.prosta.prim_infeas:\\n status = s.INFEASIBLE\\n\\n if status in s.SOLUTION_PRESENT:\\n # get objective value\\n opt_val = task.getprimalobj(sol) + inverse_data[s.OBJ_OFFSET]\\n # recover the cvxpy standard-form primal variable\\n z = [0.] * inverse_data['n0']\\n task.getxxslice(sol, 0, len(z), z)\\n primal_vars = {inverse_data[self.VAR_ID]: z}\\n # recover the cvxpy standard-form dual variables\\n if sol == mosek.soltype.itg:\\n dual_vars = None\\n else:\\n dual_vars = MOSEK.recover_dual_variables(task, sol, inverse_data)\\n else:\\n if status == s.INFEASIBLE:\\n opt_val = np.inf\\n elif status == s.UNBOUNDED:\\n opt_val = -np.inf\\n else:\\n opt_val = None\\n primal_vars = None\\n dual_vars = None\\n\\n # Store computation time\\n attr = {s.SOLVE_TIME: task.getdouinf(mosek.dinfitem.optimizer_time)}\\n\\n # Delete the mosek Task and Environment\\n task.__exit__(None, None, None)\\n env.__exit__(None, None, None)\\n\\n return Solution(status, opt_val, primal_vars, dual_vars, attr)\",\n \"def __invert__(self):\\n try:\\n B = ~(self.matrix())\\n except ZeroDivisionError:\\n raise ZeroDivisionError(\\\"matrix morphism not invertible\\\")\\n try:\\n return self.parent().reversed()(B)\\n except TypeError:\\n raise ZeroDivisionError(\\\"matrix morphism not invertible\\\")\",\n \"def inverse_rigid_trans(Tr): \\n inv_Tr = np.zeros_like(Tr) # 3x4\\n inv_Tr[0:3,0:3] = np.transpose(Tr[0:3,0:3])\\n inv_Tr[0:3,3] = np.dot(-np.transpose(Tr[0:3,0:3]), Tr[0:3,3])\\n return inv_Tr\",\n \"def inverse(self):\\n cdef StdVectorFst result = self.copy()\\n result.invert()\\n return result\",\n \"def Mq_inv(self, q):\\n\\t\\traise NotImplementedError\",\n \"def inverse(self) -> np.ndarray:\\n if self.is_versor():\\n return self.conjugate\\n return self.conjugate / np.linalg.norm(self.q)\",\n \"def inverse(self):\\n if self.determinant() != 0:\\n ops = reduce_to_red_echelon(self.data.copy(), True)[1]\\n matrix = identity_matrix(self.n_rows).data\\n \\n if ops:\\n if isinstance(ops[0], str):\\n ops = [ops]\\n \\n for op in ops:\\n if op[0] == 'swap':\\n matrix = row_swap(matrix, op[1], op[2])\\n elif op[0] == 'multiplication':\\n matrix = row_multiply(matrix, op[1], op[2])\\n elif op[0] == 'subtract':\\n matrix = row_subtract(matrix, op[1], op[2], op[3])\\n else:\\n raise ValueError('Row operation not recognized')\\n else:\\n raise ValueError('Matrix has a determinant of 0 and is not invertible')\\n return Matrix(matrix)\",\n \"def inverse(self, x, *args, **kwargs):\\n if self.list_of_inverses is None:\\n utils.print_warning(\\\"inverses were not given\\\")\\n return\\n for i in range(len(self.list_of_inverses)):\\n x = self.list_of_inverses[i](x, *args, **kwargs)\\n return x\",\n \"def inverse_matrice(T):\\n a,b,c,d = T[0][0],T[0][1],T[1][0],T[1][1]\\n det = a*d-b*c\\n aa,bb,cc,dd = d/det,-b/det,-c/det,a/det\\n Tinv = [[aa,bb],[cc,dd]]\\n return Tinv\",\n \"def inverse(self):\\n ss = self._sum_of_squares()\\n if ss > 0:\\n return self.__class__(array=(self._vector_conjugate() / ss))\\n else:\\n raise ZeroDivisionError(\\\"a zero quaternion (0 + 0i + 0j + 0k) cannot be inverted\\\")\",\n \"def inverse(self, z, y):\\n y_summary = self.summary_net(y)\\n return self.invertible_net(z, y_summary, inverse=True)\",\n \"def inv(self):\\n return MoebGen(self._d / self._det, - self._b / self._det, - self._c / self._det, self._a / self._det)\",\n \"def find_inverse(a,n):\\n if a==0 or gcd(a,n)!=1: return \\\".\\\"\\n if a==1: return 1\\n k=1\\n while True:\\n a_inv = (1+n*k)/a \\n if a_inv.is_integer():\\n return int(a_inv)\\n else:\\n k=k+1\",\n \"def _vect_matrix_inverse(A):\\n identity = np.identity(A.shape[2], dtype=A.dtype)\\n return np.array([np.linalg.solve(x, identity) for x in A])\",\n \"def inverse(num, r):\\n if int(num) == 0:\\n return 0\\n else:\\n # Multiply with every number in the field and\\n # check if the result is one. Easy Peasy!\\n # Todo: Use Extended Euclidean Algo\\n # or Logs/Anti-Logs\\n for i in range(1, 256):\\n if _multiply(num, i, r) == 1:\\n return i\",\n \"def inverse_transform(self, x):\\n raise NotImplementedError()\",\n \"def solve(self):\",\n \"def inverse(self, y):\\n device = y.device\\n return t.einsum('ij,k,kj->ik', y, 1. / t.sqrt(self.eig).to(device), self.rot.to(device))\",\n \"def inverse_transform(self, X):\\n\\n pass # pragma: no cover\",\n \"def inverse(self):\\n return ~self\",\n \"def inverse(self: Float[LinearOperator, \\\"*batch N N\\\"]) -> Float[LinearOperator, \\\"*batch N N\\\"]:\\n return self.__class__(self._diag.reciprocal())\",\n \"def _tridi_inverse_iteration(d, e, w, x0=None, rtol=1e-6):\\n\\teig_diag = d - w\\n\\tif x0 is None:\\n\\t\\tx0 = np.random.randn(len(d))\\n\\tx_prev = np.zeros_like(x0)\\n\\tnorm_x = np.linalg.norm(x0)\\n\\t# the eigenvector is unique up to sign change, so iterate\\n\\t# until || |x^(n)| - |x^(n-1)| ||^2 < rtol\\n\\tx0 /= norm_x\\n\\twhile np.linalg.norm(np.abs(x0) - np.abs(x_prev)) > rtol:\\n\\t\\tx_prev = x0.copy()\\n\\t\\t_tridisolve(eig_diag, e, x0)\\n\\t\\tnorm_x = np.linalg.norm(x0)\\n\\t\\tx0 /= norm_x\\n\\treturn x0\",\n \"def mod_inverse_iterative(a, b):\\n x, y, u, v = 0, 1, 1, 0\\n while a != 0:\\n q = int(b / a)\\n r = b % a\\n m = x - u * q\\n n = y - v * q\\n b, a, x, y, u, v = a, r, u, v, m, n\\n return b, x, y\",\n \"def invertible(A, B):\\n\\tdetA = la.det(A)\\n\\tdetB = la.det(B)\\n\\t\\n\\tif (detA == 0):\\n\\t\\tif (detB == 0):\\n\\t\\t\\tprint(\\\"None are invertible\\\")\\n\\t\\telse:\\n\\t\\t\\treturn B\\n\\telse:\\n\\t\\tif (detB == 0):\\n\\t\\t\\treturn A\\n\\t\\telse:\\n\\t\\t\\tprint(\\\"Both are invertible\\\")\",\n \"def invert(self):\\n if self.m != self.n:\\n raise exc.LinearAlgebraError(\\\"cannot invert a non-square matrix\\\")\\n if self.determinant == 0:\\n raise exc.LinearAlgebraError(\\\"cannot invert a singular matrix\\\")\\n # TODO: implement block matrices in their own method\\n block_rows = [r1 + r2 for r1, r2 in\\n zip(self.data, self.makeIdentity(self.m).data)]\\n inverse_block = Matrix.fromRows(block_rows).row_reduce()\\n return inverse_block.subset([i for i in range(self.m)],\\n [j + self.n for j in range(self.n)])\",\n \"def pseudoInversa(J):\\n\\tJinv = np.linalg.pinv(J)\\n\\treturn Jinv\",\n \"def inverse_transform(self, y: Array2D) -> Array2D:\",\n \"def test_inverse_non_interacting(self, size):\\n t_nn = 1.2\\n idx = np.arange(size)\\n g0_inv_full = np.zeros((size, size), dtype=complex)\\n g0_inv_full[idx[:-1], idx[1:]] = g0_inv_full[idx[1:], idx[:-1]] = t_nn\\n for g0 in self.g0_loc_inv:\\n g0_inv_full[idx, idx] = g0\\n rv, h, rv_inv = gt.matrix.decompose_gf(g0_inv_full)\\n g0 = gt.matrix.construct_gf(rv_inv=rv_inv, diag_inv=h**-1, rv=rv)\\n assert_allclose(g0.dot(g0_inv_full), np.identity(size), atol=1e-14)\\n assert_allclose(g0, la.inv(g0_inv_full))\\n g0_alt = gt.matrix.Decomposition(rv, h**-1, rv_inv).reconstruct(kind='full')\\n assert_allclose(g0, g0_alt)\",\n \"def inverse(self, ys):\\n with torch.no_grad():\\n xs = torch.matmul(ys, torch.diag(torch.reciprocal(torch.exp(self.scaling_diag))))\\n xs = self.layer4.inverse(xs)\\n xs = self.layer3.inverse(xs)\\n xs = self.layer2.inverse(xs)\\n xs = self.layer1.inverse(xs)\\n return xs\",\n \"def ginverse(p, x):\\n x_ = x.data\\n sinu = torch.sin(p.narrow(-1,0,1)).pow(2)\\n x_.narrow(-1,1,1).mul_(sinu.pow(-1))\\n return x_\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78967696","0.768662","0.7365531","0.7246305","0.7235828","0.71719176","0.7033936","0.69739187","0.69531745","0.6916821","0.6867409","0.6858064","0.6847429","0.68383527","0.6826942","0.68186474","0.6793239","0.6787958","0.67806756","0.67797565","0.6773841","0.67426556","0.67390823","0.67216974","0.67202854","0.66869056","0.6686556","0.66855305","0.66855305","0.66855305","0.66855305","0.66855305","0.6680804","0.6677164","0.66722023","0.6651823","0.6651823","0.6649977","0.6638236","0.6636141","0.66352916","0.6608896","0.6597504","0.6596732","0.657836","0.65728307","0.65655625","0.6564429","0.65634644","0.654639","0.6544119","0.652951","0.6494564","0.6493348","0.64831847","0.6474903","0.6466217","0.6460166","0.6457555","0.6453759","0.64521766","0.64490217","0.64348596","0.6406753","0.63987166","0.63984036","0.6386605","0.6382849","0.63687605","0.636531","0.6363698","0.63501316","0.6347803","0.6329411","0.6304527","0.6300951","0.6296811","0.62956","0.6289662","0.62890935","0.6285575","0.62845165","0.6277645","0.6274996","0.6271446","0.6263067","0.6260021","0.6258347","0.6257408","0.6254754","0.62429255","0.62428105","0.62355775","0.62242174","0.6205959","0.61958075","0.6190573","0.6188359","0.6169984","0.6167521","0.61672896"],"string":"[\n \"0.78967696\",\n \"0.768662\",\n \"0.7365531\",\n \"0.7246305\",\n \"0.7235828\",\n \"0.71719176\",\n \"0.7033936\",\n \"0.69739187\",\n \"0.69531745\",\n \"0.6916821\",\n \"0.6867409\",\n \"0.6858064\",\n \"0.6847429\",\n \"0.68383527\",\n \"0.6826942\",\n \"0.68186474\",\n \"0.6793239\",\n \"0.6787958\",\n \"0.67806756\",\n \"0.67797565\",\n \"0.6773841\",\n \"0.67426556\",\n \"0.67390823\",\n \"0.67216974\",\n \"0.67202854\",\n \"0.66869056\",\n \"0.6686556\",\n \"0.66855305\",\n \"0.66855305\",\n \"0.66855305\",\n \"0.66855305\",\n \"0.66855305\",\n \"0.6680804\",\n \"0.6677164\",\n \"0.66722023\",\n \"0.6651823\",\n \"0.6651823\",\n \"0.6649977\",\n \"0.6638236\",\n \"0.6636141\",\n \"0.66352916\",\n \"0.6608896\",\n \"0.6597504\",\n \"0.6596732\",\n \"0.657836\",\n \"0.65728307\",\n \"0.65655625\",\n \"0.6564429\",\n \"0.65634644\",\n \"0.654639\",\n \"0.6544119\",\n \"0.652951\",\n \"0.6494564\",\n \"0.6493348\",\n \"0.64831847\",\n \"0.6474903\",\n \"0.6466217\",\n \"0.6460166\",\n \"0.6457555\",\n \"0.6453759\",\n \"0.64521766\",\n \"0.64490217\",\n \"0.64348596\",\n \"0.6406753\",\n \"0.63987166\",\n \"0.63984036\",\n \"0.6386605\",\n \"0.6382849\",\n \"0.63687605\",\n \"0.636531\",\n \"0.6363698\",\n \"0.63501316\",\n \"0.6347803\",\n \"0.6329411\",\n \"0.6304527\",\n \"0.6300951\",\n \"0.6296811\",\n \"0.62956\",\n \"0.6289662\",\n \"0.62890935\",\n \"0.6285575\",\n \"0.62845165\",\n \"0.6277645\",\n \"0.6274996\",\n \"0.6271446\",\n \"0.6263067\",\n \"0.6260021\",\n \"0.6258347\",\n \"0.6257408\",\n \"0.6254754\",\n \"0.62429255\",\n \"0.62428105\",\n \"0.62355775\",\n \"0.62242174\",\n \"0.6205959\",\n \"0.61958075\",\n \"0.6190573\",\n \"0.6188359\",\n \"0.6169984\",\n \"0.6167521\",\n \"0.61672896\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84787,"cells":{"query":{"kind":"string","value":"given a song and an artist, return a uri to that song in Spotify"},"document":{"kind":"string","value":"def get_spotify_uri(song, artist) -> str:\n\n song = re.sub(\"['|\\s]\", '%20', song)\n artist = re.sub(\"['|\\s]\", '%20', artist)\n query = \"https://api.spotify.com/v1/search?q=track:{}+artist:{}&type=track&offset=0&limit=20\".format(\n song, artist)\n\n response = requests.get(query, headers={\n \"Content-Type\": \"application/json\",\n \"Authorization\": \"Bearer {}\".format(spotify_token)\n })\n\n response_json = response.json()\n song_info = response_json['tracks']['items']\n if song_info:\n return song_info[0]['uri']\n else:\n return ''"},"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 get_spotify_uri(self,song_name, artist):\n query = f\"track:{song_name} artist:{artist}\"\n result = self.sp.search(q=query,limit=1,type='track')\n\n #only use the first song\n if len(result['tracks']['items']) > 0 and result['tracks']['items'][0]['artists'][0]['name'] == artist:\n uri = result['tracks']['items'][0][\"uri\"]\n else:\n uri = None\n\n return uri","def find_song_uri(self, song):\n\n try:\n tracks = self.search_song(song[\"name\"], album=song[\"album\"], artist=song[\"artist\"])\n except SongNotFoundError:\n try:\n tracks = self.search_song(song[\"name\"], artist=song[\"artist\"])\n except SongNotFoundError:\n tracks = self.search_song(song[\"name\"])\n\n result = tracks[0]\n uri = result[\"uri\"]\n return uri","def search_song(title, artist):\n\ttitle = quote(title, safe='')\n\tartist = quote(artist, safe='')\n\tbase_url = SPOTIFY_API_HOST + 'search/' + '?q=track:{0}+artist:{1}&type=track&limit=1'\n\turl = base_url.format(title, artist)\n\tresults = requests.get(url).json()\n\n\ttry:\n\t\tif results['tracks']['total'] == 0:\n\t\t\tlogging.debug('Found no results for song {0}'.format(title))\n\t\t\treturn ''\n\texcept KeyError as e:\n\t\tlogging.warning('Invalid result from spotify on key {0}:\\n{1}'.format(e, results))\n\turi_string = results['tracks']['items'][0]['uri']\n\tlogging.debug('Found uri {0} for song {1}'.format(\n\t\turi_string[uri_string.rfind(':')+1:], title))\n\treturn uri_string[uri_string.rfind(':')+1:] # Strip off the 'spotify:track:' tag.","def artist(self, uri, detail=None):\r\n extras = self.ARTIST_DETAIL.get(detail)\r\n return self.get(uri, extras)","def get_url_from_artist_name(browser, artist: str) -> str:\n base_url = \"https://rateyourmusic.com\"\n artist = artist.strip().replace(\" \", \"+\")\n url = f\"{base_url}/search?searchtype=a&searchterm={artist}\"\n logger.debug(\"Searching %s in url %s\", artist, url)\n browser.get_url(url)\n soup = browser.get_soup()\n url_artist = f\"{base_url}{soup.find('a', {'class': 'searchpage'})['href']}\"\n logger.debug(\"url for %s found : %s\", artist, url_artist)\n return url_artist","def get_lastfm_link(artist, track, l_creds):\n pass_hash = pylast.md5(l_creds[\"password\"])\n network = pylast.LastFMNetwork(\n api_key=l_creds[\"api key\"],\n api_secret=l_creds[\"shared secret\"],\n username=l_creds[\"username\"],\n password_hash=pass_hash,\n )\n\n song = network.get_track(artist, track)\n if isinstance(song, type(None)):\n log(\"Song not found on Lastfm trying remove parens\")\n song_search = clean(track)\n song = network.get_track(artist, song_search)\n if isinstance(song, type(None)):\n log(f\"Song {song_search} by {artist} not found on Last.fm\")\n return\n return song.get_url() + \"/+lyrics\"","def make_url(self, artist, song):\n url = \"http://www.azlyrics.com/lyrics/{}/{}.html\".format(artist, song)\n return url","def extract_track_url(search):\n\n if 'tracks' in search:\n tracks = search['tracks']\n if 'items' in tracks:\n items = tracks['items']\n # take the first url we can find\n for item in items:\n if 'external_urls' in item:\n external_urls = item['external_urls']\n if 'spotify' in external_urls:\n url = external_urls['spotify']\n return url","def artist(self, q, page=None):\r\n return self.get('artist', q, page)","def search_spotify(self, artist_name):\n if VERBOSE:\n print (\"\\nSearching for artist on Spotify: \" + artist_name)\n try:\n result = self.sp.search(q='artist:' + artist_name, type='artist')\n except spotipy.client.SpotifyException:\n print(\"ERROR: Couldnt not find artist: %s. Trying again.\" % artist_name)\n try:\n result = self.sp.search(q='artist:' + artist_name, type='artist')\n except spotipy.client.SpotifyException as error:\n print(\"ERROR: Failed to search twice. Error below:\")\n print(error)\n result = None\n except ValueError as error:\n print(\"ERROR: Failure while searching Spotify for artist: %s\" % artist_name)\n print(error)\n result = None\n return result","def get_artists_from(playlist_uri):\n artist_uris = []\n playlist = spotify.playlist_items(playlist_uri)['items'][0]\n for artist in playlist['track']['album']['artists']:\n artist_uris.append(artist['uri'])\n\n return artist_uris","def _mpd_lookup_artist_tracks(artist):\n\n args = [\"artist\", artist.encode(\"utf-8\")]\n hits = []\n\n for match in _mpd_client.search(*args):\n hits.append(match[\"file\"])\n\n return hits","def get_artist(artist_id):\n return query_single(artist_id, Artist, artist_schema)","def test_get_s_track_artists(self):\r\n sp_track = spotify.SpAlbumTrack(munch.munchify({'artists': [{'external_urls': {'spotify': 'https://open.spotify.com/artist/25BObiRSDCMwVrBGIVaLIf'}, 'href': 'https://api.spotify.com/v1/artists/25BObiRSDCMwVrBGIVaLIf', 'id': '25BObiRSDCMwVrBGIVaLIf', 'name': 'James K', 'type': 'artist', 'uri': 'spotify:artist:25BObiRSDCMwVrBGIVaLIf'}, {'external_urls': {'spotify': 'https://open.spotify.com/artist/1g80vffuPrdapR6S4WyxN3'}, 'href': 'https://api.spotify.com/v1/artists/1g80vffuPrdapR6S4WyxN3', 'id': '1g80vffuPrdapR6S4WyxN3', 'name': 'Eve Essex', 'type': 'artist', 'uri': 'spotify:artist:1g80vffuPrdapR6S4WyxN3'}], 'available_markets': ['AD', 'AE', 'AR', 'AT', 'AU', 'BE', 'BG', 'BH', 'BO', 'BR', 'CA', 'CH', 'CL', 'CO', 'CR', 'CY', 'CZ', 'DE', 'DK', 'DO', 'DZ', 'EC', 'EE', 'EG', 'ES', 'FI', 'FR', 'GB', 'GR', 'GT', 'HK', 'HN',\r\n 'HU', 'ID', 'IE', 'IL', 'IN', 'IS', 'IT', 'JO', 'JP', 'KW', 'LB', 'LI', 'LT', 'LU', 'LV', 'MA', 'MC', 'MT', 'MX', 'MY', 'NI', 'NL', 'NO', 'NZ', 'OM', 'PA', 'PE', 'PH', 'PL', 'PS', 'PT', 'PY', 'QA', 'RO', 'SA', 'SE', 'SG', 'SK', 'SV', 'TH', 'TN', 'TR', 'TW', 'US', 'UY', 'VN', 'ZA'], 'disc_number': 1, 'duration_ms': 260446, 'explicit': False, 'external_urls': {'spotify': 'https://open.spotify.com/track/1mh4GpKKrmlaUkVzoNqhRt'}, 'href': 'https://api.spotify.com/v1/tracks/1mh4GpKKrmlaUkVzoNqhRt', 'id': '1mh4GpKKrmlaUkVzoNqhRt', 'is_local': False, 'name': 'Stretch Deep - feat. Eve Essex', 'preview_url': 'https://p.scdn.co/mp3-preview/ebb7e70b97a5d29e05044a1f920d1fc594f92b26?cid=ea3ef49a097b42d682d3c7bc98832d65', 'track_number': 12, 'type': 'track', 'uri': 'spotify:track:1mh4GpKKrmlaUkVzoNqhRt'}))\r\n expected = ['Eve Essex', 'James K']\r\n actual = gmspotify.get_sp_track_artists(sp_track)\r\n self.assertEqual(actual, expected)","def query_artist(self, artist_name):\n # Check if the artist is in the database\n try:\n a = Artist.objects.get(searched_name = artist_name)\n return ArtistObject(searched_name=artist_name, db_model=a)\n\n # If the artist isn't in the database, search Spotify\n except Artist.DoesNotExist:\n print(\"Artist not found in database: \", artist_name)\n result = self.search_spotify(artist_name)\n\n # If there were any errors searching Spotify, don't continue\n if result is None:\n # SKIP FOR TEST NOW\n ArtistObject(searched_name=artist_name).save_to_db()\n return None\n else:\n artist = self.filter_spotify_result(result, artist_name)\n\n if artist is None:\n ArtistObject(searched_name=artist_name).save_to_db()\n return None\n\n top_tracks = self.find_top_tracks(artist.uri)\n artist.add_songs(top_tracks)\n\n # Save artist URI to the database for faster results next time\n print(\"About to save artist with name {} and object: \".format(artist_name), artist)\n artist.save_to_db()\n\n return artist","def album_art(speaker, action, args, soco_function, use_local_speaker_list):\n\n try:\n info = speaker.get_current_track_info()\n metadata = info[\"metadata\"]\n data = parse(metadata)\n album_art_uri = data[\"DIDL-Lite\"][\"item\"][\"upnp:albumArtURI\"]\n logging.info(\"Album art URI = \".format(album_art_uri))\n except:\n logging.info(\"No album art URI available\")\n print(\"Album art not available\")\n return True\n\n if not album_art_uri.lower().startswith(\"http\"):\n print(\"Album art not accessible\")\n else:\n print(album_art_uri)\n\n return True","def artist(self, artist_id, **kwargs):\n _id = self._get_artist_id(artist_id)\n # pylint: disable=no-member\n return self._get(API.ARTIST.value.format(id=_id), **kwargs)","def id(artist,track):\n track_id = sp.search(q='artist:' + artist + ' track:' + track, type='track', limit = 1)\n if len(track_id['tracks']['items'])>0:\n s_id = track_id['tracks']['items'][0]['id']\n else:\n s_id = '0'\n return s_id","def search_album_art(artist, title, select_index=0, return_all=False):\r\n # TODO: add soundcloud search as well if spotify comes up with no results.\r\n # Soundcloud has it disabled\r\n artist, title = parse.quote(artist), parse.quote(title)\r\n header = {'Authorization': 'Bearer ' + get_spotify_access_token()}\r\n # TODO: search through playlists too\r\n links = []\r\n links_set = set()\r\n for code in COUNTRY_CODES:\r\n url = f'https://api.spotify.com/v1/search?q={title}+artist:{artist}&type=track&market={code}'\r\n r = requests.get(url, headers=header).json()\r\n if 'tracks' in r:\r\n links_from_country = [item['album']['images'][0]['url'] for item in r['tracks']['items']]\r\n for link in links_from_country:\r\n if link not in links_set:\r\n links.append(link)\r\n links_set.add(link)\r\n if return_all: return links\r\n return links[0]","def search_artist_by_name(sp, artist_name_input):\n\n results = sp.search(q=artist_name_input, type='artist', limit=20, offset=0, market=\"DE\")\n\n result_artist_name = results[\"artists\"][\"items\"][0][\"name\"]\n result_artist_uri = results[\"artists\"][\"items\"][0][\"uri\"]\n\n return result_artist_name, result_artist_uri","def test_artist_uri(self):\n expect = [\"1\", \"2\", \"3\"]\n with mock.patch(\"spotlogin_api.get_artists_call\", self.mock_artist):\n result = spotify_login.get_artists(self.user[INPUT])\n self.assertEqual(result, expect)","def artist_link(self, obj):\n if not obj.artist:\n return None\n url = reverse(\n 'admin:music_publisher_artist_change', args=[obj.artist.id])\n link = '<a href=\"{}\">{}</a>'.format(url, obj.artist)\n return mark_safe(link)","def search_for_artist(name):\n\ttoken = get_token()\n\tif token:\n\t\theaders = {\"Content-Type\": \"application/json\", \"Authorization\": \"Bearer \" + token}\n\t\toptions = {\n\t\t\t'q': name, 'type': 'artist', 'limit': '1'\n\t\t}\n\n\t\tresponse = requests.get(\n\t\t\t'https://api.spotify.com/v1/search',\n\t\t\theaders=headers,\n\t\t\tparams=options\n\t\t)\n\t\tif response.status_code == 200:\n\t\t\tcontent = json.loads(response.content.decode('utf-8'))\n\t\t\tif content:\n\t\t\t\treturn content['artists']['items'][0]['id']\n\t\t\telse: return None\n\t\telse:\n\t\t\treturn None\n\telse:\n\t\treturn None","def media_artist(self):\n return self.coordinator.data.nowplaying[self.zone.SourceID].CurrSong.Artists","def get_albums_from(artist_uri):\n album_uris = []\n results = spotify.artist_albums(artist_uri, album_type='album')\n albums = results['items']\n # get URIs for each album\n for album in albums:\n album_uris.append(album['uri'])\n\n return album_uris","def get_first_artist_from_result(result):\n return result['metadata']['music'][0]['external_metadata']['spotify']['artists'][0]['name']","def get_album_artist(self) -> Optional[str]:\n return self.album_artist","def get_artist_id(artist_name: str, api_key: str):\n # Get token\n token_url = \"https://accounts.spotify.com/api/token\"\n authorization = base64.standard_b64encode(api_key.encode('utf-8')).decode('utf-8')\n headers = {'Authorization' : 'Basic ' + authorization}\n data = \"grant_type=client_credentials\".encode('utf-8')\n request = Request(token_url, data, headers, method='POST')\n response = urlopen(request)\n response_dict = json.load(response)\n token = response_dict.get('access_token')\n\n # Search artist name to get id\n search_url = f\"https://api.spotify.com/v1/search?q={quote(artist_name)}&type=artist&limit=1\"\n headers = {'Authorization' : 'Bearer ' + token}\n request = Request(search_url, headers=headers, method='GET')\n response = urlopen(request)\n\n # Get artist id from response\n response_dict = json.load(response)\n items = response_dict['artists']['items']\n\n # No artist was found, try using it the key as artist id instead\n if len(items) == 0:\n return headers, artist_name\n\n artist_id = items[0].get('id')\n return headers, artist_id","def get_speaker_uri(self, json_data):\n if self._speaker_uri:\n return self._speaker_uri\n\n next_track_art = json_data['nextTrack'].get(\"absoluteAlbumArtUri\", \"\")\n match = re.search(\"(^https?:\\/\\/.*:1400)\\/getaa\\?.*\", next_track_art)\n if match:\n self._speaker_uri = match.group(1)\n _LOGGER.debug(\"URL for %s found: %s\", self.room, self._speaker_uri)\n return self._speaker_uri","def media_artist(self):\n return self._state.get(\"artist\", None)","def find_artist_playlist(data):\n\n return data['artist'].lower() + '.m3u'","def get_artist(self) -> Optional[str]:\n return self.artist","def get_albums_by_artist(self, artist_id):\n return self.__get('album', artist_id)","def get_song_url(self, song_id):\n values = {\n 'action' : 'song',\n 'filter' : song_id,\n }\n root = self.__call_api(values)\n if not root:\n return None\n song = root.getElementsByTagName('song')[0]\n song_url = song.getElementsByTagName('url')[0].childNodes[0].data\n return song_url","def test_get_songs_by_artist(self, track_elms, service_config, request):\n artist_id = uuid.UUID(avalon.compat.to_uuid_input('2221930a-f28d-44ed-856b-c84b35f76713'))\n service_config.track_store.get_by_artist.return_value = track_elms\n service_config.id_cache.get_artist_id.return_value = artist_id\n request.args['artist'] = 'Artist'\n params = avalon.web.request.Parameters(request)\n\n service = avalon.web.services.AvalonMetadataService(service_config)\n results = service.get_songs(params)\n\n assert results == track_elms, 'Expected matching tracks returned'\n service_config.track_store.get_by_artist.assert_called_with(artist_id)","def media_album_artist(self):\n media_status = self._media_status()[0]\n return media_status.album_artist if media_status else None","def get_url_image(artist, track, size):\n s = size.lower()\n if s not in ['small', 'medium', 'large', 'extralarge']:\n return None\n track_infos = get_infos(artist, track)\n for image in track_infos['track']['album']['image']:\n if image['size'] == s:\n return image['#text']\n return None","def artist(self) -> str:\n return self._artist","def get_genius_song(song_name, artist_name, genius):\n song_search = song_name\n for i in range(0, 2):\n song = genius.search_song(song_search, artist_name)\n if isinstance(song, type(None)) or not match(\n\t (song_search, artist_name), (song.title, song.artist)\n ):\n if i:\n log(f\"Song '{song_search}' by '{artist_name}' not found on Genius\")\n return\n else:\n log(f\"Song '{song_search}' by '{artist_name}' not found on Genius trying cleaning\")\n song_search = clean(song_search)\n else:\n if i:\n log(f\"Found match for '{song_search}' by '{artist_name}'\")\n break\n\n return song","def fetch_uri(uri):\n logger.info(\"Working on uri: %s\" % uri)\n token = fetch_token()\n token_uri = 'https://accounts.spotify.com/api/token'\n client_id = os.getenv('SPOTIFY_CLIENT_ID')\n client_secret = os.getenv('SPOTIFY_CLIENT_SECRET')\n extra = {'client_id': client_id, 'client_secret': client_secret}\n\n client = OAuth2Session(client_id, token=token,\n auto_refresh_url=token_uri,\n auto_refresh_kwargs=extra,\n token_updater=save_token)\n r = client.get(uri)\n\n return r.json()","def get_song_name_from_result(result):\n return result['metadata']['music'][0]['external_metadata']['spotify']['track']['name']","def parse_spotify_url(url):\n if url.startswith(\"spotify:\"):\n log.error(\"Spotify URI was provided instead of a playlist/album/track URL.\")\n sys.exit(1)\n parsed_url = url.replace(\"https://open.spotify.com/\", \"\")\n item_type = parsed_url.split(\"/\")[0]\n item_id = parsed_url.split(\"/\")[1]\n return item_type, item_id","def media_artist(self):\n media_status = self._media_status()[0]\n return media_status.artist if media_status else None","def _get_artist(self):\n artists = FileRecord.query(FileRecord.artist).distinct().filter(\n FileRecord.album == self.name).filter(\n FileRecord.year == self.year).all()\n\n if len(artists) > 1:\n return \"Various Artists\"\n elif len(artists) == 1:\n return artists[0][0]\n else:\n return \"(Unknown)\"","def getArtistsofArtwork(catalog, codes):\n return model.getArtistname(catalog,codes)","def media_album_artist(self):\n return self._media_album_artist","def album_art(self):\n return self._album_art_url","def get_artist(self):\n return self._artist","def test_artist_uri_exception(self):\n with mock.patch(\"spotlogin_api.get_artists_call\", self.mock_key):\n result = spotify_login.get_artists(self.user[INPUT])\n self.assertEqual(result, [])","def get_random_song(self):\n songs = self.get_all_song_names()\n song_name = songs[random.randrange(len(songs))]\n hits = self.get_song_data(song_name=song_name)\n if len(hits) == 0:\n # Just return Oops! I did it again by Britney\n return 'spotify:track:6naxalmIoLFWR0siv8dnQQ'\n else:\n return hits[0].get('spotify_uri')","def _mpd_lookup_track(track):\n \n args = [\"artist\", track[\"artist\"].encode(\"utf-8\"), \"title\", track[\"title\"].encode(\"utf-8\")]\n hits = []\n \n for match in _mpd_client.find(*args) + _mpd_client.search(*args):\n hits.append(match[\"file\"])\n \n return hits","def get_track_image(artist, album):\n blank_image = url_for(\"static\", filename=\"img/blank.jpg\")\n if \"ROVI_SHARED_SECRET\" not in app.config:\n return blank_image\n if \"ROVI_API_KEY\" not in app.config:\n return blank_image\n\n headers = {\"Accept-Encoding\": \"gzip\"}\n req = requests.get(\n \"http://api.rovicorp.com/recognition/v2.1/music/match/album?apikey=\"\n + app.config[\"ROVI_API_KEY\"]\n + \"&sig=\"\n + gen_sig()\n + \"&name= \"\n + album\n + \"&performername=\"\n + artist\n + \"&include=images&size=1\",\n headers=headers,\n timeout=30,\n )\n\n if req.status_code != requests.codes.ok:\n return blank_image\n\n result = json.loads(req.content)\n try:\n return result[\"matchResponse\"][\"results\"][0][\"album\"][\"images\"][0][\"front\"][3][\"url\"]\n except (KeyError, IndexError):\n return blank_image","def media_artist(self):\n return self._media_artist","def media_artist(self):\n return self._media_artist","def get_albums_from_artists(sp, artist_uri_list):\n\n # Create header for output df\n albums_list = [[\"name\", \"album_uri\", \"album_release_date\", \"artist_uri\"]]\n\n print(\"Log: Pulling data from Spotify. This can take a while...\")\n\n # Loop through list of artist uris\n for artist_uri in artist_uri_list:\n # Get album from artist\n albums = sp.artist_albums(artist_uri)\n \n # Append each album to list\n for album in albums[\"items\"]:\n album_name = album[\"name\"]\n album_uri = album[\"uri\"]\n album_release_date = album[\"release_date\"]\n albums_list.append([album_name, album_uri, album_release_date, artist_uri])\n\n # Create df from list of albums for all artist\n albums_df = pd.DataFrame(data=albums_list[1:], columns=albums_list[0])\n\n print(\"Log: Finished pulling all albums from artist.\")\n return albums_df","def get_song(track):\n # Extract some identifying track information\n Title = track['name'].encode('utf-8')\n title = normalize(Title)\n Artist = [a['name'].encode('utf-8') for a in track['artists']]\n Album = track['name'].encode('utf-8')\n Popularity = track['popularity']\n # Put information into a namedTuple for convenience\n song = Track(Title, Artist, Album, Popularity, title)\n return song","def __init__(self, SONG):\n self.track_name = SONG['name']\n self.artist_name = SONG['artist']\n self.provider = 'lastfm'\n self.track_number = \"1\"\n self.collection_name = \"\"\n self.release_date = \"\"\n self.artwork_url_100 = SONG[\"image\"][-1][\"#text\"]\n self.track_time = \"\"\n self.primary_genre_name = \"N/A\"","def test_get_songs_by_artist_id(self, track_elms, service_config, request):\n artist_id = uuid.UUID(avalon.compat.to_uuid_input('75d590d1-9f3d-462d-8264-0d16af227860'))\n service_config.track_store.get_by_artist.return_value = track_elms\n request.args['artist_id'] = six.text_type(artist_id)\n params = avalon.web.request.Parameters(request)\n\n service = avalon.web.services.AvalonMetadataService(service_config)\n results = service.get_songs(params)\n\n assert results == track_elms, 'Expected matching tracks returned'\n service_config.track_store.get_by_artist.assert_called_with(artist_id)","def get_track(session_, uri) -> Track:\n return session_.query(Track).filter_by(uri=uri).first()","def song_album(ans):\r\n albums = simple_album_list()\r\n for album in albums:\r\n songs = simple_songs_list(album)\r\n for song in songs:\r\n if ans == song:\r\n return album","def find_song(spotify, query, matchRatio=0.75):\n results = spotify.search(\"track:\\\"\" + query + \"\\\"\", limit=50, type='track')\n candidates = list(map(lambda track: {'name': track['name'], 'uri': track['uri']}, \n results['tracks']['items']))\n for candidate in candidates:\n matcher = difflib.SequenceMatcher(None, candidate['name'].lower(), query.lower())\n if matcher.ratio() >= matchRatio:\n print(\"Adding song \" + candidate[\"name\"] + \" for \" + query)\n return candidate['uri']\n print(\"Found no matches for \" + query)\n return None","def get_redirect_url(self, **kwargs):\n metadata = get_top_song_metadata()\n filename = metadata['filename']\n return MUSIC_DIR + filename","def artist():\n\tif not request.vars.id:\n\t\tredirect(URL('index'))\n\tid = request.vars.id\n\tartistname = db.executesql(\"select m1.name from artist_name as m1, artist as m2 where m1.id = m2.name and m2.id = \"+id+\";\")\n\turls = db.executesql(\"select distinct(m2.url) from l_artist_url m1, url m2 where m2.id = m1.entity1 and m1.entity0 = \"+id+\";\")\n\tdiscography = db.executesql(\"select m4.name,m5.name,m3.id,m6.count from artist_credit_name m1, artist_credit m2,release_group m3,release_name m4, release_group_primary_type m5,rel_group_count m6 where m4.id = m3.name and m3.artist_credit = m2.id and m2.id = m1.artist_credit and m5.id = m3.type and m6.id = m3.id and m1.artist = \"+id+\";\")\n\tlinks = []\n\twiki = \"\"\n\tfor url in urls:\n\t\tif \"wikipedia\" in url[0]:\n\t\t\twiki = url[0]\n\t\telse:\n\t\t\tlinks.append(url[0])\n\treturn dict(discography=discography, wiki=wiki, links=links, artistname=artistname)","def get_spotify_id_from_result(result):\n return result['metadata']['music'][0]['external_metadata']['spotify']['track']['id']","def media_image_url(self):\n return self.coordinator.data.nowplaying[self.zone.SourceID].CurrSong.ArtworkURI","async def spotify(self, ctx, *, query):\n\n # Setup the headers with the token that should be here\n headers = {\"Authorization\": \"Bearer {}\".format(self._token)}\n opts = {\"q\": query, \"type\": \"track\"}\n url = \"https://api.spotify.com/v1/search\"\n response = await utils.request(url, headers=headers, payload=opts)\n try:\n await ctx.send(\n response.get(\"tracks\")\n .get(\"items\")[0]\n .get(\"external_urls\")\n .get(\"spotify\")\n )\n except (KeyError, AttributeError, IndexError):\n await ctx.send(\"Couldn't find a song for:\\n{}\".format(query))","def appendArtist(song):\n\tsql = []\n\t\n\tsql.append(\"INSERT INTO ARTIST ('name') VALUES ('\" \n\t+ '/'.join(song.artist) + \"');\")\n\t\n\tsql.append(\"INSERT INTO songs_artist ('songs_id', 'artist_id')\"\n\t+ \" VALUES ((select id from songs where hash = '\" + str(song.hash) + \"'), \"\n\t+ \"(select id from artist where name = '\" + '/'.join(song.artist) + \"'));\")\n\t\n\treturn sql","def get_tracks_from(album_uri):\n track_uris = []\n album = spotify.album_tracks(album_id=album_uri)\n\n for track in album['items']:\n track_uris.append(track['uri'])\n\n return track_uris","def create_url(artist, song, language):\n url = __BASE_URL__ + '/wiki/{artist}:{song}'.format(artist=urlize(artist), song=urlize(song))\n if language:\n url += '/{language}'.format(language=urlize(language).lower())\n return url","def get_all_tracks_from_artists(sp, artist_uri_list):\n\n track_list = [[\"track_name\", \"track_uri\", \"track_release_date\", \"artist_name\"]]\n track_df = pd.DataFrame(columns=track_list[0])\n\n print(\"Log: Pulling data from Spotify. This can take a while...\")\n\n for artist_uri in artist_uri_list:\n # Get artist name and albums\n artist_name = sp.artist(artist_uri)[\"name\"]\n albums = get_albums_from_artists(sp, [artist_uri])\n\n # Get tracks from artist albums\n tracks_artist_df = get_tracks_from_albums(sp, albums[\"album_uri\"].to_list())\n tracks_artist_df[\"artist_name\"] = artist_name\n\n # Append new songs to dataframe\n track_df = track_df.append(tracks_artist_df)\n \n print(\"Log: Finished pulling all tracks from artist.\")\n return track_df","def get_artwork(session_, uri: str):\n return session_.query(CoverArt).filter_by(uri=uri).first()","def _hoist_track_info(track):\n track['album_name'] = track['album']['name']\n artist = track['artists'][0]\n track['artist_name'] = artist['name']\n return track","async def get_artist(self, artist_id: int) -> APIReturn:\n return await self._request(\"GET\", \"/getArtist\", extra_query={\"id\": artist_id})","def media_artist(self):\n if self._current_item[\"artistName\"] is not None:\n if self._current_item[\"year\"] is not None:\n return self._current_item[\"artistName\"] + \", \" + self._current_item[\"year\"]\n else:\n return self._current_item[\"artistName\"]\n elif self._current_item[\"author\"] is not None:\n if self._current_item[\"year\"] is not None:\n return self._current_item[\"author\"] + \", \" + self._current_item[\"year\"]\n else:\n return self._current_item[\"author\"]\n elif self._current_item[\"year\"] is not None:\n return \"Unknown, \" + str(self._current_item[\"year\"])\n return \"\"","def parse_description(self, track: dict):\n try:\n album = track['album']\n link = album['external_urls'].get('spotify')\n preview = track.get('preview_url')\n return (f\"<p>Song from album <a href='{link}'>{album.get('name')}</a><p>\" +\n f\"<audio controls><source src='{preview}' type='audio/mp3'></audio>\")\n except KeyError:\n return \"\"","def test_ms_artist_search(helpers):\n common_tests(\n MSArtist,\n MS_ARTIST_SEARCH_XML,\n MS_ARTIST_SEARCH_DICT,\n \"00020064artistsearch:Fritjof\",\n helpers,\n )","def __add_artist(self, artist, genius_api):\n\t\tentry = {\n\t\t\t'id' : int(artist['id']),\n\t\t\t'name' : artist['name'].lower(),\n\t\t\t'is_verified' : artist['is_verified'],\n\t\t\t'url' : artist['url'],\n\t\t\t'songs' : genius_api.get_artist_songs_id(artist['id'], artist_name=artist['name'])\n\t\t\t}\n\t\t\t\t#Step 3: Insert Artist into MongoDB via isnert_one\n\t\tself.db.artists.insert_one(entry)","def artist_similar(req):\n\n artist = req.get('result').get('parameters').get('artist')\n logger.info('received {0} request for artist=\"{1}\"'.format('artist_similar', artist))\n sim_artists = cached_result('get_similar_artists', [artist], {})\n speech = 'Unable to locate similar artists for {artist}'.format(artist=artist)\n\n if sim_artists and len(sim_artists) > 0:\n speech = 'The following artists are similar to {artist}'.format(\n artist=artist)\n for art in sim_artists:\n speech += u'. {artist}'.format(artist=art)\n\n return jsonify(\n {'speech': speech,\n 'displayText': speech,\n 'source': 'last-assist'})","def album(self, uri, detail=None):\r\n extras = self.ALBUM_DETAIL.get(detail)\r\n return self.get(uri, extras)","def getSongsSpotify(song_name,access_token):\n song_name = song_name.strip()\n query = \"https://api.spotify.com/v1/search?q={}&type=track&limit=20&offset=0\".format(song_name)\n response = requests.get(\n query,\n headers={\n \"Content-Type\": \"application/json\",\n \"Authorization\": \"Bearer {}\".format(access_token)\n }\n )\n response_json = response.json()\n # \n \n songs_no = response_json[\"tracks\"][\"total\"]\n if songs_no == 0 :\n return {\"songs_no\" : songs_no}\n songs = response_json[\"tracks\"][\"items\"]\n if(len(songs)<5):\n uri = [songs[0][\"uri\"]]\n names = [songs[0][\"name\"]]\n artists = [songs[0][\"artists\"][0][\"name\"]]\n imageUrl = [songs[0][\"album\"][\"images\"][-1][\"url\"]]\n response_obj = {\n \"songs_no\" : songs_no,\n \"uri\" : uri,\n \"names\" : names,\n \"artists\" : artists,\n \"images\" : imageUrl\n }\n else:\n uri = [ songs[i][\"uri\"] for i in range(0,5)]\n names = [songs[i][\"name\"] for i in range(0,5)]\n artists = [songs[i][\"artists\"][0][\"name\"] for i in range(0,5)]\n imageUrl = [songs[i][\"album\"][\"images\"][-1][\"url\"] for i in range(0,5)]\n response_obj = {\n \"songs_no\" : songs_no,\n \"uri\" : uri,\n \"names\" : names,\n \"artists\" : artists,\n \"images\" : imageUrl\n }\n return response_obj","def get_album_url(self) -> Optional[str]:\n return self.album_url","def get_artist(self, object_id, relation=None, **kwargs):\n return self.get_object(\"artist\", object_id, relation=relation, **kwargs)","def get_url_from_album_name(browser, name: str) -> str:\n album_name = name.split(\"-\")[1].strip()\n artist_name = name.split(\"-\")[0].strip()\n artist_url = get_url_from_artist_name(browser, artist_name)\n\n logger.debug(\"Searching for %s at %s\", album_name, artist_url)\n browser.get_url(artist_url)\n soup = browser.get_soup()\n artist_album_list = [\n [x.text.strip(), \"https://rateyourmusic.com\" + x.find(\"a\")[\"href\"]]\n for x in soup.find_all(\"div\", {\"class\": \"disco_mainline\"})\n ]\n artist_album_url = [x[1] for x in artist_album_list]\n artist_album_name = [x[0] for x in artist_album_list]\n\n url_match = artist_album_url[\n artist_album_name.index(\n get_close_matches_icase(album_name, artist_album_name)[0]\n )\n ]\n logger.debug(\"Best match : %s\", url_match)\n return url_match","def _query_artist_by_song(self, entities: List[str]):\n artists = []\n for e in entities:\n artists += [\n song.get('artist_name')\n for song\n in self.kb_api.get_song_data(e)\n ]\n\n return artists","def create_artist_new_music_line(spotify_artist_music):\n body = ''\n for item in spotify_artist_music:\n if item['thumbnail']:\n artist_string = '<p><img src=\"{}\" width=\"{}\" height=\"{}\" /> {} released on {}--{}</p>\\n'\n body += artist_string.format(item['thumbnail'][0]['url'], item['thumbnail'][0]['width'],\n item['thumbnail'][0]['height'], item['name'], item['releaseDate'], item['url'])\n return body","def import_spotify(info: dict) -> (str, int):\n url = info[\"playlist_url\"]\n # Validate URL\n matches = (\n re.match(r\"^https?://open\\.spotify\\.com/playlist/([a-zA-Z\\d]*)/?\", url)\n if isinstance(url, str)\n else None\n )\n if not matches:\n return \"Invalid URL\", 400\n playlist_id = matches.group(1)\n query_url = \"https://api.spotify.com/v1/playlists/\" + playlist_id\n query_headers = {\"Authorization\": \"Bearer {}\".format(info[\"access_token\"])}\n # Get/create playlist\n playlist_json = requests.get(query_url, headers=query_headers).json()\n if \"error\" in playlist_json:\n status = playlist_json[\"error\"].get(\"status\")\n message = playlist_json[\"error\"].get(\"message\")\n return (\n message if message else \"Error retrieving playlist\",\n status if status else 500,\n )\n playlist = Playlist(\n name=playlist_json[\"name\"],\n last_sync_spotify=timezone.now(),\n spotify_id=playlist_id,\n )\n if \"user\" in info:\n playlist.owner = PlaylstrUser.objects.filter(id=info[\"user\"]).first()\n if \"owner\" in playlist_json:\n playlist.spotify_creator_id = playlist_json[\"owner\"][\"id\"]\n playlist.spotify_creator_name = playlist_json[\"owner\"][\"display_name\"]\n playlist.save()\n # Get playlist tracks\n tracks_response = requests.get(query_url + \"/tracks\", headers=query_headers)\n if tracks_response.status_code != 200:\n return tracks_response.reason, 500\n tracks_json = tracks_response.json()\n if \"error_description\" in tracks_json:\n return tracks_json[\"error_description\"], 500\n # Get list of tracks\n index = -1\n while \"next\" in tracks_json and tracks_json[\"next\"] is not None:\n for j in tracks_json[\"items\"]:\n index += 1\n track = track_from_spotify_json(j[\"track\"])\n try:\n PlaylistTrack.objects.create(\n playlist=playlist, track=track, index=index\n )\n except IntegrityError as e:\n print(\"Error adding track {}: {}\".format(str(track), str(e)))\n continue\n tracks_json = requests.get(tracks_json[\"next\"], headers=query_headers).json()\n return str(playlist.playlist_id), 200","def get_track_info(track_id):\n items = spotify.track(track_id)\n name = items[\"name\"]\n artists_names = \", \".join([\n items[\"artists\"][x][\"name\"]\n for x in range(len(items[\"artists\"]))\n ])\n album_artists = \", \".join([\n items[\"album\"][\"artists\"][x][\"name\"]\n for x in range(len(items[\"album\"][\"artists\"]))\n ])\n album_type = items[\"album\"][\"album_type\"]\n album_name = items[\"album\"][\"name\"]\n album_release = items[\"album\"][\"release_date\"]\n album_track_number = items[\"track_number\"]\n track_duration = items[\"duration_ms\"]\n images_link = items[\"album\"][\"images\"]\n max_image_res = 0\n max_icon_size = 0\n image_link = \"\"\n icon_link = \"\"\n for image in images_link:\n if image[\"height\"] * image[\"width\"] > max_image_res:\n image_link = image[\"url\"]\n max_image_res = image[\"height\"] * image[\"width\"]\n if image[\"height\"] < 400:\n if image[\"height\"] > max_icon_size:\n max_icon_size = image[\"height\"]\n icon_link = image[\"url\"]\n track = {\"name\": name,\n \"Artist(s)\": artists_names,\n \"Album Artist(s)\": album_artists,\n \"Album Type\": album_type,\n \"Album Name\": album_name,\n \"Album Release\": album_release,\n \"Track Number\": album_track_number,\n \"Track Duration (ms)\": track_duration,\n \"Image Link\": image_link,\n \"Icon Link\": icon_link\n }\n\n for artist in artists_names.split(', '):\n \"\"\"\n Checks for lyrics with song name and artist names\n combination until one is found.\n \"\"\"\n try:\n lyrics = lyricwikia.get_lyrics(artist, name)\n track['lyrics'] = lyrics\n break\n except lyricwikia.LyricsNotFound:\n pass\n\n return track","def get_icon(f):\n\n url = None\n t = FileHelper.get_media_type(f)\n if t == \"audio\":\n url = \"/img/music.png\"\n elif t == \"video\":\n url = \"/img/video.png\"\n elif t == \"image\":\n return FileHelper.get_url(f)\n for fn in os.listdir(os.path.dirname(f)):\n if \"album\" in fn.lower():\n uri = os.path.join(os.path.dirname(f), fn)\n url = FileHelper.get_url(uri)\n\n return url","def get_artist_info(self, artist):\n self.clear()\n ai = self._artist_info(artist)\n if ai != 0:\n return ai\n else:\n if 'the ' in artist:\n ai = self._artist_info(artist.replace('the ', ''))\n else:\n ai = self._artist_info('the ' + artist)\n if ai == 0:\n if 'junior' in artist:\n ai = self._artist_info(artist.replace('junior', 'jr.'))\n if ai == 0:\n if '-' in artist:\n ai = self._artist_info(artist.replace('-', ' '))\n return ai","def get_artist_ids_from_spotify(artists, spotify_authorization):\n spotify_artists = dict()\n url = os.environ['SPOTIFY_SEARCH_URL']\n headers = {\n 'Authorization': f'Bearer {spotify_authorization[\"access_token\"]}'\n }\n for artist in artists:\n params = '?q={}&type=artist&items=1'.format(artist)\n response = json.loads(requests.get(url + params, headers=headers).text)\n if not response['artists'].get('items', []):\n spotify_artists.update({artist: None})\n else:\n spotify_artists.update({response['artists']['items'][0]['id']: artist})\n\n return spotify_artists","def get_absolute_url(self):\n\n return reverse('song-detail', args=[str(self.id)])","def getURLForThing(thing):","def set_album_artist(self, album_artist: str) -> None:\n self.album_artist = album_artist","def play_music(sid):\n # Get the parameters for the get_song_id request\n artist = None\n album = None\n title = None\n if not request.json:\n # If no JSON parameters were given, just resume playing the song\n db = sqlite3.connect('/home/tropius/TROPIUS/TROPIUS.db')\n host = hosts.get_detail(db, sid)\n spotify.resume(host['ip'])\n return jsonify({})\n else:\n try:\n # Get the host data from the database\n db = sqlite3.connect('/home/tropius/TROPIUS/TROPIUS.db')\n host = hosts.get_detail(db, sid)\n artist = None\n album = None\n track = None\n if request.json.has_key('track') and request.json.get('track'):\n track = request.json.get('track')\n elif request.json.has_key('album') and request.json.get('album'):\n album = request.json.get('album')\n elif request.json.has_key('artist') and request.json.get('artist'):\n artist = request.json.get('artist')\n else:\n spotify.resume(host['ip'])\n return jsonify({})\n spotify.compound_play(host['ip'], artist=artist, album=album, song=track)\n return jsonify({})\n except:\n abort(400)","def wrap_spotify_link(item, text=''):\n\n # generate default text if no text has been given\n if not text:\n name = item['name']\n if item['type'] == 'playlist':\n user = SP.user(item['owner']['id'])['display_name']\n text = f'{name} by {user}'\n elif item['type'] == 'artist':\n text = name\n else:\n artist = item['artists'][0]['name']\n text = f'{name} by {artist}'\n\n link = item['external_urls']['spotify']\n return f'<a href=\"{link}\">{text}</a>'","def get_genius_page(self, artist: str, song: str) -> str:\n\n artist = self.just_replace_strings_with_dashes(artist)\n song = self.just_replace_strings_with_dashes(song)\n\n url = self.gen_url + artist + '-' + song + '-lyrics'\n\n resp = requests.get(url)\n\n if resp.status_code == 200:\n try:\n content = bs4.BeautifulSoup(resp.content)\n lyrics = content.text[content.text.rindex(\n '[Verse 1]'):content.text.index('Embed')]\n lyrics = self.clean_lyrics_response(lyrics)\n return lyrics\n\n except (ValueError, IndexError) as e:\n print('Lyrics not found {}, due to error {}'.format(song, e))\n\n try:\n lyrics = content.text[content.text.rindex(\n '[Verse]'):content.text.index('Embed')]\n lyrics = self.clean_lyrics_response(lyrics)\n return lyrics\n\n except ValueError as e:\n print(\n 'Lyrics not found {}, due to error {}, single verse song'.format(song, e))","def get_track_correction(artist, track):\n q_artist = quote(artist)\n q_track = quote(track)\n track_addr = \"http://ws.audioscrobbler.com/2.0/?method=track.getcorrection&artist=%s&track=%s&api_key=b25b959554ed76058ac220b7b2e0a026\" % (q_artist, q_track)\n print track_addr \n try:\n tree = ET.parse(urllib2.urlopen(track_addr))\n except urllib2.HTTPError:\n print \"httperror\"\n return (artist, track)\n c_track = None\n try:\n c_track = tree.find(\"corrections\").find(\"correction\").find(\"track\").find(\"name\").text\n except:\n pass\n\n return (artist, c_track) if c_track else (artist, track)","def make_album(artist, album, tracks=\"\"):\n retval = {'artist': artist, 'album': album}\n if tracks:\n retval['tracks'] = tracks\n return retval","def get_albums_by_artist(albumtype, search_for, sort_on):\n return list(dmla.list_albums_by_artist(albumtype, search_for, sort_on))","def getSimilarArtists(artist_id, limit = 5):\n\tresponse = requests.get(\"https://api.spotify.com/v1/artists/%s/related-artists\"%artist_id).json()\n\t\n\treturn response.get('artists')"],"string":"[\n \"def get_spotify_uri(self,song_name, artist):\\n query = f\\\"track:{song_name} artist:{artist}\\\"\\n result = self.sp.search(q=query,limit=1,type='track')\\n\\n #only use the first song\\n if len(result['tracks']['items']) > 0 and result['tracks']['items'][0]['artists'][0]['name'] == artist:\\n uri = result['tracks']['items'][0][\\\"uri\\\"]\\n else:\\n uri = None\\n\\n return uri\",\n \"def find_song_uri(self, song):\\n\\n try:\\n tracks = self.search_song(song[\\\"name\\\"], album=song[\\\"album\\\"], artist=song[\\\"artist\\\"])\\n except SongNotFoundError:\\n try:\\n tracks = self.search_song(song[\\\"name\\\"], artist=song[\\\"artist\\\"])\\n except SongNotFoundError:\\n tracks = self.search_song(song[\\\"name\\\"])\\n\\n result = tracks[0]\\n uri = result[\\\"uri\\\"]\\n return uri\",\n \"def search_song(title, artist):\\n\\ttitle = quote(title, safe='')\\n\\tartist = quote(artist, safe='')\\n\\tbase_url = SPOTIFY_API_HOST + 'search/' + '?q=track:{0}+artist:{1}&type=track&limit=1'\\n\\turl = base_url.format(title, artist)\\n\\tresults = requests.get(url).json()\\n\\n\\ttry:\\n\\t\\tif results['tracks']['total'] == 0:\\n\\t\\t\\tlogging.debug('Found no results for song {0}'.format(title))\\n\\t\\t\\treturn ''\\n\\texcept KeyError as e:\\n\\t\\tlogging.warning('Invalid result from spotify on key {0}:\\\\n{1}'.format(e, results))\\n\\turi_string = results['tracks']['items'][0]['uri']\\n\\tlogging.debug('Found uri {0} for song {1}'.format(\\n\\t\\turi_string[uri_string.rfind(':')+1:], title))\\n\\treturn uri_string[uri_string.rfind(':')+1:] # Strip off the 'spotify:track:' tag.\",\n \"def artist(self, uri, detail=None):\\r\\n extras = self.ARTIST_DETAIL.get(detail)\\r\\n return self.get(uri, extras)\",\n \"def get_url_from_artist_name(browser, artist: str) -> str:\\n base_url = \\\"https://rateyourmusic.com\\\"\\n artist = artist.strip().replace(\\\" \\\", \\\"+\\\")\\n url = f\\\"{base_url}/search?searchtype=a&searchterm={artist}\\\"\\n logger.debug(\\\"Searching %s in url %s\\\", artist, url)\\n browser.get_url(url)\\n soup = browser.get_soup()\\n url_artist = f\\\"{base_url}{soup.find('a', {'class': 'searchpage'})['href']}\\\"\\n logger.debug(\\\"url for %s found : %s\\\", artist, url_artist)\\n return url_artist\",\n \"def get_lastfm_link(artist, track, l_creds):\\n pass_hash = pylast.md5(l_creds[\\\"password\\\"])\\n network = pylast.LastFMNetwork(\\n api_key=l_creds[\\\"api key\\\"],\\n api_secret=l_creds[\\\"shared secret\\\"],\\n username=l_creds[\\\"username\\\"],\\n password_hash=pass_hash,\\n )\\n\\n song = network.get_track(artist, track)\\n if isinstance(song, type(None)):\\n log(\\\"Song not found on Lastfm trying remove parens\\\")\\n song_search = clean(track)\\n song = network.get_track(artist, song_search)\\n if isinstance(song, type(None)):\\n log(f\\\"Song {song_search} by {artist} not found on Last.fm\\\")\\n return\\n return song.get_url() + \\\"/+lyrics\\\"\",\n \"def make_url(self, artist, song):\\n url = \\\"http://www.azlyrics.com/lyrics/{}/{}.html\\\".format(artist, song)\\n return url\",\n \"def extract_track_url(search):\\n\\n if 'tracks' in search:\\n tracks = search['tracks']\\n if 'items' in tracks:\\n items = tracks['items']\\n # take the first url we can find\\n for item in items:\\n if 'external_urls' in item:\\n external_urls = item['external_urls']\\n if 'spotify' in external_urls:\\n url = external_urls['spotify']\\n return url\",\n \"def artist(self, q, page=None):\\r\\n return self.get('artist', q, page)\",\n \"def search_spotify(self, artist_name):\\n if VERBOSE:\\n print (\\\"\\\\nSearching for artist on Spotify: \\\" + artist_name)\\n try:\\n result = self.sp.search(q='artist:' + artist_name, type='artist')\\n except spotipy.client.SpotifyException:\\n print(\\\"ERROR: Couldnt not find artist: %s. Trying again.\\\" % artist_name)\\n try:\\n result = self.sp.search(q='artist:' + artist_name, type='artist')\\n except spotipy.client.SpotifyException as error:\\n print(\\\"ERROR: Failed to search twice. Error below:\\\")\\n print(error)\\n result = None\\n except ValueError as error:\\n print(\\\"ERROR: Failure while searching Spotify for artist: %s\\\" % artist_name)\\n print(error)\\n result = None\\n return result\",\n \"def get_artists_from(playlist_uri):\\n artist_uris = []\\n playlist = spotify.playlist_items(playlist_uri)['items'][0]\\n for artist in playlist['track']['album']['artists']:\\n artist_uris.append(artist['uri'])\\n\\n return artist_uris\",\n \"def _mpd_lookup_artist_tracks(artist):\\n\\n args = [\\\"artist\\\", artist.encode(\\\"utf-8\\\")]\\n hits = []\\n\\n for match in _mpd_client.search(*args):\\n hits.append(match[\\\"file\\\"])\\n\\n return hits\",\n \"def get_artist(artist_id):\\n return query_single(artist_id, Artist, artist_schema)\",\n \"def test_get_s_track_artists(self):\\r\\n sp_track = spotify.SpAlbumTrack(munch.munchify({'artists': [{'external_urls': {'spotify': 'https://open.spotify.com/artist/25BObiRSDCMwVrBGIVaLIf'}, 'href': 'https://api.spotify.com/v1/artists/25BObiRSDCMwVrBGIVaLIf', 'id': '25BObiRSDCMwVrBGIVaLIf', 'name': 'James K', 'type': 'artist', 'uri': 'spotify:artist:25BObiRSDCMwVrBGIVaLIf'}, {'external_urls': {'spotify': 'https://open.spotify.com/artist/1g80vffuPrdapR6S4WyxN3'}, 'href': 'https://api.spotify.com/v1/artists/1g80vffuPrdapR6S4WyxN3', 'id': '1g80vffuPrdapR6S4WyxN3', 'name': 'Eve Essex', 'type': 'artist', 'uri': 'spotify:artist:1g80vffuPrdapR6S4WyxN3'}], 'available_markets': ['AD', 'AE', 'AR', 'AT', 'AU', 'BE', 'BG', 'BH', 'BO', 'BR', 'CA', 'CH', 'CL', 'CO', 'CR', 'CY', 'CZ', 'DE', 'DK', 'DO', 'DZ', 'EC', 'EE', 'EG', 'ES', 'FI', 'FR', 'GB', 'GR', 'GT', 'HK', 'HN',\\r\\n 'HU', 'ID', 'IE', 'IL', 'IN', 'IS', 'IT', 'JO', 'JP', 'KW', 'LB', 'LI', 'LT', 'LU', 'LV', 'MA', 'MC', 'MT', 'MX', 'MY', 'NI', 'NL', 'NO', 'NZ', 'OM', 'PA', 'PE', 'PH', 'PL', 'PS', 'PT', 'PY', 'QA', 'RO', 'SA', 'SE', 'SG', 'SK', 'SV', 'TH', 'TN', 'TR', 'TW', 'US', 'UY', 'VN', 'ZA'], 'disc_number': 1, 'duration_ms': 260446, 'explicit': False, 'external_urls': {'spotify': 'https://open.spotify.com/track/1mh4GpKKrmlaUkVzoNqhRt'}, 'href': 'https://api.spotify.com/v1/tracks/1mh4GpKKrmlaUkVzoNqhRt', 'id': '1mh4GpKKrmlaUkVzoNqhRt', 'is_local': False, 'name': 'Stretch Deep - feat. Eve Essex', 'preview_url': 'https://p.scdn.co/mp3-preview/ebb7e70b97a5d29e05044a1f920d1fc594f92b26?cid=ea3ef49a097b42d682d3c7bc98832d65', 'track_number': 12, 'type': 'track', 'uri': 'spotify:track:1mh4GpKKrmlaUkVzoNqhRt'}))\\r\\n expected = ['Eve Essex', 'James K']\\r\\n actual = gmspotify.get_sp_track_artists(sp_track)\\r\\n self.assertEqual(actual, expected)\",\n \"def query_artist(self, artist_name):\\n # Check if the artist is in the database\\n try:\\n a = Artist.objects.get(searched_name = artist_name)\\n return ArtistObject(searched_name=artist_name, db_model=a)\\n\\n # If the artist isn't in the database, search Spotify\\n except Artist.DoesNotExist:\\n print(\\\"Artist not found in database: \\\", artist_name)\\n result = self.search_spotify(artist_name)\\n\\n # If there were any errors searching Spotify, don't continue\\n if result is None:\\n # SKIP FOR TEST NOW\\n ArtistObject(searched_name=artist_name).save_to_db()\\n return None\\n else:\\n artist = self.filter_spotify_result(result, artist_name)\\n\\n if artist is None:\\n ArtistObject(searched_name=artist_name).save_to_db()\\n return None\\n\\n top_tracks = self.find_top_tracks(artist.uri)\\n artist.add_songs(top_tracks)\\n\\n # Save artist URI to the database for faster results next time\\n print(\\\"About to save artist with name {} and object: \\\".format(artist_name), artist)\\n artist.save_to_db()\\n\\n return artist\",\n \"def album_art(speaker, action, args, soco_function, use_local_speaker_list):\\n\\n try:\\n info = speaker.get_current_track_info()\\n metadata = info[\\\"metadata\\\"]\\n data = parse(metadata)\\n album_art_uri = data[\\\"DIDL-Lite\\\"][\\\"item\\\"][\\\"upnp:albumArtURI\\\"]\\n logging.info(\\\"Album art URI = \\\".format(album_art_uri))\\n except:\\n logging.info(\\\"No album art URI available\\\")\\n print(\\\"Album art not available\\\")\\n return True\\n\\n if not album_art_uri.lower().startswith(\\\"http\\\"):\\n print(\\\"Album art not accessible\\\")\\n else:\\n print(album_art_uri)\\n\\n return True\",\n \"def artist(self, artist_id, **kwargs):\\n _id = self._get_artist_id(artist_id)\\n # pylint: disable=no-member\\n return self._get(API.ARTIST.value.format(id=_id), **kwargs)\",\n \"def id(artist,track):\\n track_id = sp.search(q='artist:' + artist + ' track:' + track, type='track', limit = 1)\\n if len(track_id['tracks']['items'])>0:\\n s_id = track_id['tracks']['items'][0]['id']\\n else:\\n s_id = '0'\\n return s_id\",\n \"def search_album_art(artist, title, select_index=0, return_all=False):\\r\\n # TODO: add soundcloud search as well if spotify comes up with no results.\\r\\n # Soundcloud has it disabled\\r\\n artist, title = parse.quote(artist), parse.quote(title)\\r\\n header = {'Authorization': 'Bearer ' + get_spotify_access_token()}\\r\\n # TODO: search through playlists too\\r\\n links = []\\r\\n links_set = set()\\r\\n for code in COUNTRY_CODES:\\r\\n url = f'https://api.spotify.com/v1/search?q={title}+artist:{artist}&type=track&market={code}'\\r\\n r = requests.get(url, headers=header).json()\\r\\n if 'tracks' in r:\\r\\n links_from_country = [item['album']['images'][0]['url'] for item in r['tracks']['items']]\\r\\n for link in links_from_country:\\r\\n if link not in links_set:\\r\\n links.append(link)\\r\\n links_set.add(link)\\r\\n if return_all: return links\\r\\n return links[0]\",\n \"def search_artist_by_name(sp, artist_name_input):\\n\\n results = sp.search(q=artist_name_input, type='artist', limit=20, offset=0, market=\\\"DE\\\")\\n\\n result_artist_name = results[\\\"artists\\\"][\\\"items\\\"][0][\\\"name\\\"]\\n result_artist_uri = results[\\\"artists\\\"][\\\"items\\\"][0][\\\"uri\\\"]\\n\\n return result_artist_name, result_artist_uri\",\n \"def test_artist_uri(self):\\n expect = [\\\"1\\\", \\\"2\\\", \\\"3\\\"]\\n with mock.patch(\\\"spotlogin_api.get_artists_call\\\", self.mock_artist):\\n result = spotify_login.get_artists(self.user[INPUT])\\n self.assertEqual(result, expect)\",\n \"def artist_link(self, obj):\\n if not obj.artist:\\n return None\\n url = reverse(\\n 'admin:music_publisher_artist_change', args=[obj.artist.id])\\n link = '<a href=\\\"{}\\\">{}</a>'.format(url, obj.artist)\\n return mark_safe(link)\",\n \"def search_for_artist(name):\\n\\ttoken = get_token()\\n\\tif token:\\n\\t\\theaders = {\\\"Content-Type\\\": \\\"application/json\\\", \\\"Authorization\\\": \\\"Bearer \\\" + token}\\n\\t\\toptions = {\\n\\t\\t\\t'q': name, 'type': 'artist', 'limit': '1'\\n\\t\\t}\\n\\n\\t\\tresponse = requests.get(\\n\\t\\t\\t'https://api.spotify.com/v1/search',\\n\\t\\t\\theaders=headers,\\n\\t\\t\\tparams=options\\n\\t\\t)\\n\\t\\tif response.status_code == 200:\\n\\t\\t\\tcontent = json.loads(response.content.decode('utf-8'))\\n\\t\\t\\tif content:\\n\\t\\t\\t\\treturn content['artists']['items'][0]['id']\\n\\t\\t\\telse: return None\\n\\t\\telse:\\n\\t\\t\\treturn None\\n\\telse:\\n\\t\\treturn None\",\n \"def media_artist(self):\\n return self.coordinator.data.nowplaying[self.zone.SourceID].CurrSong.Artists\",\n \"def get_albums_from(artist_uri):\\n album_uris = []\\n results = spotify.artist_albums(artist_uri, album_type='album')\\n albums = results['items']\\n # get URIs for each album\\n for album in albums:\\n album_uris.append(album['uri'])\\n\\n return album_uris\",\n \"def get_first_artist_from_result(result):\\n return result['metadata']['music'][0]['external_metadata']['spotify']['artists'][0]['name']\",\n \"def get_album_artist(self) -> Optional[str]:\\n return self.album_artist\",\n \"def get_artist_id(artist_name: str, api_key: str):\\n # Get token\\n token_url = \\\"https://accounts.spotify.com/api/token\\\"\\n authorization = base64.standard_b64encode(api_key.encode('utf-8')).decode('utf-8')\\n headers = {'Authorization' : 'Basic ' + authorization}\\n data = \\\"grant_type=client_credentials\\\".encode('utf-8')\\n request = Request(token_url, data, headers, method='POST')\\n response = urlopen(request)\\n response_dict = json.load(response)\\n token = response_dict.get('access_token')\\n\\n # Search artist name to get id\\n search_url = f\\\"https://api.spotify.com/v1/search?q={quote(artist_name)}&type=artist&limit=1\\\"\\n headers = {'Authorization' : 'Bearer ' + token}\\n request = Request(search_url, headers=headers, method='GET')\\n response = urlopen(request)\\n\\n # Get artist id from response\\n response_dict = json.load(response)\\n items = response_dict['artists']['items']\\n\\n # No artist was found, try using it the key as artist id instead\\n if len(items) == 0:\\n return headers, artist_name\\n\\n artist_id = items[0].get('id')\\n return headers, artist_id\",\n \"def get_speaker_uri(self, json_data):\\n if self._speaker_uri:\\n return self._speaker_uri\\n\\n next_track_art = json_data['nextTrack'].get(\\\"absoluteAlbumArtUri\\\", \\\"\\\")\\n match = re.search(\\\"(^https?:\\\\/\\\\/.*:1400)\\\\/getaa\\\\?.*\\\", next_track_art)\\n if match:\\n self._speaker_uri = match.group(1)\\n _LOGGER.debug(\\\"URL for %s found: %s\\\", self.room, self._speaker_uri)\\n return self._speaker_uri\",\n \"def media_artist(self):\\n return self._state.get(\\\"artist\\\", None)\",\n \"def find_artist_playlist(data):\\n\\n return data['artist'].lower() + '.m3u'\",\n \"def get_artist(self) -> Optional[str]:\\n return self.artist\",\n \"def get_albums_by_artist(self, artist_id):\\n return self.__get('album', artist_id)\",\n \"def get_song_url(self, song_id):\\n values = {\\n 'action' : 'song',\\n 'filter' : song_id,\\n }\\n root = self.__call_api(values)\\n if not root:\\n return None\\n song = root.getElementsByTagName('song')[0]\\n song_url = song.getElementsByTagName('url')[0].childNodes[0].data\\n return song_url\",\n \"def test_get_songs_by_artist(self, track_elms, service_config, request):\\n artist_id = uuid.UUID(avalon.compat.to_uuid_input('2221930a-f28d-44ed-856b-c84b35f76713'))\\n service_config.track_store.get_by_artist.return_value = track_elms\\n service_config.id_cache.get_artist_id.return_value = artist_id\\n request.args['artist'] = 'Artist'\\n params = avalon.web.request.Parameters(request)\\n\\n service = avalon.web.services.AvalonMetadataService(service_config)\\n results = service.get_songs(params)\\n\\n assert results == track_elms, 'Expected matching tracks returned'\\n service_config.track_store.get_by_artist.assert_called_with(artist_id)\",\n \"def media_album_artist(self):\\n media_status = self._media_status()[0]\\n return media_status.album_artist if media_status else None\",\n \"def get_url_image(artist, track, size):\\n s = size.lower()\\n if s not in ['small', 'medium', 'large', 'extralarge']:\\n return None\\n track_infos = get_infos(artist, track)\\n for image in track_infos['track']['album']['image']:\\n if image['size'] == s:\\n return image['#text']\\n return None\",\n \"def artist(self) -> str:\\n return self._artist\",\n \"def get_genius_song(song_name, artist_name, genius):\\n song_search = song_name\\n for i in range(0, 2):\\n song = genius.search_song(song_search, artist_name)\\n if isinstance(song, type(None)) or not match(\\n\\t (song_search, artist_name), (song.title, song.artist)\\n ):\\n if i:\\n log(f\\\"Song '{song_search}' by '{artist_name}' not found on Genius\\\")\\n return\\n else:\\n log(f\\\"Song '{song_search}' by '{artist_name}' not found on Genius trying cleaning\\\")\\n song_search = clean(song_search)\\n else:\\n if i:\\n log(f\\\"Found match for '{song_search}' by '{artist_name}'\\\")\\n break\\n\\n return song\",\n \"def fetch_uri(uri):\\n logger.info(\\\"Working on uri: %s\\\" % uri)\\n token = fetch_token()\\n token_uri = 'https://accounts.spotify.com/api/token'\\n client_id = os.getenv('SPOTIFY_CLIENT_ID')\\n client_secret = os.getenv('SPOTIFY_CLIENT_SECRET')\\n extra = {'client_id': client_id, 'client_secret': client_secret}\\n\\n client = OAuth2Session(client_id, token=token,\\n auto_refresh_url=token_uri,\\n auto_refresh_kwargs=extra,\\n token_updater=save_token)\\n r = client.get(uri)\\n\\n return r.json()\",\n \"def get_song_name_from_result(result):\\n return result['metadata']['music'][0]['external_metadata']['spotify']['track']['name']\",\n \"def parse_spotify_url(url):\\n if url.startswith(\\\"spotify:\\\"):\\n log.error(\\\"Spotify URI was provided instead of a playlist/album/track URL.\\\")\\n sys.exit(1)\\n parsed_url = url.replace(\\\"https://open.spotify.com/\\\", \\\"\\\")\\n item_type = parsed_url.split(\\\"/\\\")[0]\\n item_id = parsed_url.split(\\\"/\\\")[1]\\n return item_type, item_id\",\n \"def media_artist(self):\\n media_status = self._media_status()[0]\\n return media_status.artist if media_status else None\",\n \"def _get_artist(self):\\n artists = FileRecord.query(FileRecord.artist).distinct().filter(\\n FileRecord.album == self.name).filter(\\n FileRecord.year == self.year).all()\\n\\n if len(artists) > 1:\\n return \\\"Various Artists\\\"\\n elif len(artists) == 1:\\n return artists[0][0]\\n else:\\n return \\\"(Unknown)\\\"\",\n \"def getArtistsofArtwork(catalog, codes):\\n return model.getArtistname(catalog,codes)\",\n \"def media_album_artist(self):\\n return self._media_album_artist\",\n \"def album_art(self):\\n return self._album_art_url\",\n \"def get_artist(self):\\n return self._artist\",\n \"def test_artist_uri_exception(self):\\n with mock.patch(\\\"spotlogin_api.get_artists_call\\\", self.mock_key):\\n result = spotify_login.get_artists(self.user[INPUT])\\n self.assertEqual(result, [])\",\n \"def get_random_song(self):\\n songs = self.get_all_song_names()\\n song_name = songs[random.randrange(len(songs))]\\n hits = self.get_song_data(song_name=song_name)\\n if len(hits) == 0:\\n # Just return Oops! I did it again by Britney\\n return 'spotify:track:6naxalmIoLFWR0siv8dnQQ'\\n else:\\n return hits[0].get('spotify_uri')\",\n \"def _mpd_lookup_track(track):\\n \\n args = [\\\"artist\\\", track[\\\"artist\\\"].encode(\\\"utf-8\\\"), \\\"title\\\", track[\\\"title\\\"].encode(\\\"utf-8\\\")]\\n hits = []\\n \\n for match in _mpd_client.find(*args) + _mpd_client.search(*args):\\n hits.append(match[\\\"file\\\"])\\n \\n return hits\",\n \"def get_track_image(artist, album):\\n blank_image = url_for(\\\"static\\\", filename=\\\"img/blank.jpg\\\")\\n if \\\"ROVI_SHARED_SECRET\\\" not in app.config:\\n return blank_image\\n if \\\"ROVI_API_KEY\\\" not in app.config:\\n return blank_image\\n\\n headers = {\\\"Accept-Encoding\\\": \\\"gzip\\\"}\\n req = requests.get(\\n \\\"http://api.rovicorp.com/recognition/v2.1/music/match/album?apikey=\\\"\\n + app.config[\\\"ROVI_API_KEY\\\"]\\n + \\\"&sig=\\\"\\n + gen_sig()\\n + \\\"&name= \\\"\\n + album\\n + \\\"&performername=\\\"\\n + artist\\n + \\\"&include=images&size=1\\\",\\n headers=headers,\\n timeout=30,\\n )\\n\\n if req.status_code != requests.codes.ok:\\n return blank_image\\n\\n result = json.loads(req.content)\\n try:\\n return result[\\\"matchResponse\\\"][\\\"results\\\"][0][\\\"album\\\"][\\\"images\\\"][0][\\\"front\\\"][3][\\\"url\\\"]\\n except (KeyError, IndexError):\\n return blank_image\",\n \"def media_artist(self):\\n return self._media_artist\",\n \"def media_artist(self):\\n return self._media_artist\",\n \"def get_albums_from_artists(sp, artist_uri_list):\\n\\n # Create header for output df\\n albums_list = [[\\\"name\\\", \\\"album_uri\\\", \\\"album_release_date\\\", \\\"artist_uri\\\"]]\\n\\n print(\\\"Log: Pulling data from Spotify. This can take a while...\\\")\\n\\n # Loop through list of artist uris\\n for artist_uri in artist_uri_list:\\n # Get album from artist\\n albums = sp.artist_albums(artist_uri)\\n \\n # Append each album to list\\n for album in albums[\\\"items\\\"]:\\n album_name = album[\\\"name\\\"]\\n album_uri = album[\\\"uri\\\"]\\n album_release_date = album[\\\"release_date\\\"]\\n albums_list.append([album_name, album_uri, album_release_date, artist_uri])\\n\\n # Create df from list of albums for all artist\\n albums_df = pd.DataFrame(data=albums_list[1:], columns=albums_list[0])\\n\\n print(\\\"Log: Finished pulling all albums from artist.\\\")\\n return albums_df\",\n \"def get_song(track):\\n # Extract some identifying track information\\n Title = track['name'].encode('utf-8')\\n title = normalize(Title)\\n Artist = [a['name'].encode('utf-8') for a in track['artists']]\\n Album = track['name'].encode('utf-8')\\n Popularity = track['popularity']\\n # Put information into a namedTuple for convenience\\n song = Track(Title, Artist, Album, Popularity, title)\\n return song\",\n \"def __init__(self, SONG):\\n self.track_name = SONG['name']\\n self.artist_name = SONG['artist']\\n self.provider = 'lastfm'\\n self.track_number = \\\"1\\\"\\n self.collection_name = \\\"\\\"\\n self.release_date = \\\"\\\"\\n self.artwork_url_100 = SONG[\\\"image\\\"][-1][\\\"#text\\\"]\\n self.track_time = \\\"\\\"\\n self.primary_genre_name = \\\"N/A\\\"\",\n \"def test_get_songs_by_artist_id(self, track_elms, service_config, request):\\n artist_id = uuid.UUID(avalon.compat.to_uuid_input('75d590d1-9f3d-462d-8264-0d16af227860'))\\n service_config.track_store.get_by_artist.return_value = track_elms\\n request.args['artist_id'] = six.text_type(artist_id)\\n params = avalon.web.request.Parameters(request)\\n\\n service = avalon.web.services.AvalonMetadataService(service_config)\\n results = service.get_songs(params)\\n\\n assert results == track_elms, 'Expected matching tracks returned'\\n service_config.track_store.get_by_artist.assert_called_with(artist_id)\",\n \"def get_track(session_, uri) -> Track:\\n return session_.query(Track).filter_by(uri=uri).first()\",\n \"def song_album(ans):\\r\\n albums = simple_album_list()\\r\\n for album in albums:\\r\\n songs = simple_songs_list(album)\\r\\n for song in songs:\\r\\n if ans == song:\\r\\n return album\",\n \"def find_song(spotify, query, matchRatio=0.75):\\n results = spotify.search(\\\"track:\\\\\\\"\\\" + query + \\\"\\\\\\\"\\\", limit=50, type='track')\\n candidates = list(map(lambda track: {'name': track['name'], 'uri': track['uri']}, \\n results['tracks']['items']))\\n for candidate in candidates:\\n matcher = difflib.SequenceMatcher(None, candidate['name'].lower(), query.lower())\\n if matcher.ratio() >= matchRatio:\\n print(\\\"Adding song \\\" + candidate[\\\"name\\\"] + \\\" for \\\" + query)\\n return candidate['uri']\\n print(\\\"Found no matches for \\\" + query)\\n return None\",\n \"def get_redirect_url(self, **kwargs):\\n metadata = get_top_song_metadata()\\n filename = metadata['filename']\\n return MUSIC_DIR + filename\",\n \"def artist():\\n\\tif not request.vars.id:\\n\\t\\tredirect(URL('index'))\\n\\tid = request.vars.id\\n\\tartistname = db.executesql(\\\"select m1.name from artist_name as m1, artist as m2 where m1.id = m2.name and m2.id = \\\"+id+\\\";\\\")\\n\\turls = db.executesql(\\\"select distinct(m2.url) from l_artist_url m1, url m2 where m2.id = m1.entity1 and m1.entity0 = \\\"+id+\\\";\\\")\\n\\tdiscography = db.executesql(\\\"select m4.name,m5.name,m3.id,m6.count from artist_credit_name m1, artist_credit m2,release_group m3,release_name m4, release_group_primary_type m5,rel_group_count m6 where m4.id = m3.name and m3.artist_credit = m2.id and m2.id = m1.artist_credit and m5.id = m3.type and m6.id = m3.id and m1.artist = \\\"+id+\\\";\\\")\\n\\tlinks = []\\n\\twiki = \\\"\\\"\\n\\tfor url in urls:\\n\\t\\tif \\\"wikipedia\\\" in url[0]:\\n\\t\\t\\twiki = url[0]\\n\\t\\telse:\\n\\t\\t\\tlinks.append(url[0])\\n\\treturn dict(discography=discography, wiki=wiki, links=links, artistname=artistname)\",\n \"def get_spotify_id_from_result(result):\\n return result['metadata']['music'][0]['external_metadata']['spotify']['track']['id']\",\n \"def media_image_url(self):\\n return self.coordinator.data.nowplaying[self.zone.SourceID].CurrSong.ArtworkURI\",\n \"async def spotify(self, ctx, *, query):\\n\\n # Setup the headers with the token that should be here\\n headers = {\\\"Authorization\\\": \\\"Bearer {}\\\".format(self._token)}\\n opts = {\\\"q\\\": query, \\\"type\\\": \\\"track\\\"}\\n url = \\\"https://api.spotify.com/v1/search\\\"\\n response = await utils.request(url, headers=headers, payload=opts)\\n try:\\n await ctx.send(\\n response.get(\\\"tracks\\\")\\n .get(\\\"items\\\")[0]\\n .get(\\\"external_urls\\\")\\n .get(\\\"spotify\\\")\\n )\\n except (KeyError, AttributeError, IndexError):\\n await ctx.send(\\\"Couldn't find a song for:\\\\n{}\\\".format(query))\",\n \"def appendArtist(song):\\n\\tsql = []\\n\\t\\n\\tsql.append(\\\"INSERT INTO ARTIST ('name') VALUES ('\\\" \\n\\t+ '/'.join(song.artist) + \\\"');\\\")\\n\\t\\n\\tsql.append(\\\"INSERT INTO songs_artist ('songs_id', 'artist_id')\\\"\\n\\t+ \\\" VALUES ((select id from songs where hash = '\\\" + str(song.hash) + \\\"'), \\\"\\n\\t+ \\\"(select id from artist where name = '\\\" + '/'.join(song.artist) + \\\"'));\\\")\\n\\t\\n\\treturn sql\",\n \"def get_tracks_from(album_uri):\\n track_uris = []\\n album = spotify.album_tracks(album_id=album_uri)\\n\\n for track in album['items']:\\n track_uris.append(track['uri'])\\n\\n return track_uris\",\n \"def create_url(artist, song, language):\\n url = __BASE_URL__ + '/wiki/{artist}:{song}'.format(artist=urlize(artist), song=urlize(song))\\n if language:\\n url += '/{language}'.format(language=urlize(language).lower())\\n return url\",\n \"def get_all_tracks_from_artists(sp, artist_uri_list):\\n\\n track_list = [[\\\"track_name\\\", \\\"track_uri\\\", \\\"track_release_date\\\", \\\"artist_name\\\"]]\\n track_df = pd.DataFrame(columns=track_list[0])\\n\\n print(\\\"Log: Pulling data from Spotify. This can take a while...\\\")\\n\\n for artist_uri in artist_uri_list:\\n # Get artist name and albums\\n artist_name = sp.artist(artist_uri)[\\\"name\\\"]\\n albums = get_albums_from_artists(sp, [artist_uri])\\n\\n # Get tracks from artist albums\\n tracks_artist_df = get_tracks_from_albums(sp, albums[\\\"album_uri\\\"].to_list())\\n tracks_artist_df[\\\"artist_name\\\"] = artist_name\\n\\n # Append new songs to dataframe\\n track_df = track_df.append(tracks_artist_df)\\n \\n print(\\\"Log: Finished pulling all tracks from artist.\\\")\\n return track_df\",\n \"def get_artwork(session_, uri: str):\\n return session_.query(CoverArt).filter_by(uri=uri).first()\",\n \"def _hoist_track_info(track):\\n track['album_name'] = track['album']['name']\\n artist = track['artists'][0]\\n track['artist_name'] = artist['name']\\n return track\",\n \"async def get_artist(self, artist_id: int) -> APIReturn:\\n return await self._request(\\\"GET\\\", \\\"/getArtist\\\", extra_query={\\\"id\\\": artist_id})\",\n \"def media_artist(self):\\n if self._current_item[\\\"artistName\\\"] is not None:\\n if self._current_item[\\\"year\\\"] is not None:\\n return self._current_item[\\\"artistName\\\"] + \\\", \\\" + self._current_item[\\\"year\\\"]\\n else:\\n return self._current_item[\\\"artistName\\\"]\\n elif self._current_item[\\\"author\\\"] is not None:\\n if self._current_item[\\\"year\\\"] is not None:\\n return self._current_item[\\\"author\\\"] + \\\", \\\" + self._current_item[\\\"year\\\"]\\n else:\\n return self._current_item[\\\"author\\\"]\\n elif self._current_item[\\\"year\\\"] is not None:\\n return \\\"Unknown, \\\" + str(self._current_item[\\\"year\\\"])\\n return \\\"\\\"\",\n \"def parse_description(self, track: dict):\\n try:\\n album = track['album']\\n link = album['external_urls'].get('spotify')\\n preview = track.get('preview_url')\\n return (f\\\"<p>Song from album <a href='{link}'>{album.get('name')}</a><p>\\\" +\\n f\\\"<audio controls><source src='{preview}' type='audio/mp3'></audio>\\\")\\n except KeyError:\\n return \\\"\\\"\",\n \"def test_ms_artist_search(helpers):\\n common_tests(\\n MSArtist,\\n MS_ARTIST_SEARCH_XML,\\n MS_ARTIST_SEARCH_DICT,\\n \\\"00020064artistsearch:Fritjof\\\",\\n helpers,\\n )\",\n \"def __add_artist(self, artist, genius_api):\\n\\t\\tentry = {\\n\\t\\t\\t'id' : int(artist['id']),\\n\\t\\t\\t'name' : artist['name'].lower(),\\n\\t\\t\\t'is_verified' : artist['is_verified'],\\n\\t\\t\\t'url' : artist['url'],\\n\\t\\t\\t'songs' : genius_api.get_artist_songs_id(artist['id'], artist_name=artist['name'])\\n\\t\\t\\t}\\n\\t\\t\\t\\t#Step 3: Insert Artist into MongoDB via isnert_one\\n\\t\\tself.db.artists.insert_one(entry)\",\n \"def artist_similar(req):\\n\\n artist = req.get('result').get('parameters').get('artist')\\n logger.info('received {0} request for artist=\\\"{1}\\\"'.format('artist_similar', artist))\\n sim_artists = cached_result('get_similar_artists', [artist], {})\\n speech = 'Unable to locate similar artists for {artist}'.format(artist=artist)\\n\\n if sim_artists and len(sim_artists) > 0:\\n speech = 'The following artists are similar to {artist}'.format(\\n artist=artist)\\n for art in sim_artists:\\n speech += u'. {artist}'.format(artist=art)\\n\\n return jsonify(\\n {'speech': speech,\\n 'displayText': speech,\\n 'source': 'last-assist'})\",\n \"def album(self, uri, detail=None):\\r\\n extras = self.ALBUM_DETAIL.get(detail)\\r\\n return self.get(uri, extras)\",\n \"def getSongsSpotify(song_name,access_token):\\n song_name = song_name.strip()\\n query = \\\"https://api.spotify.com/v1/search?q={}&type=track&limit=20&offset=0\\\".format(song_name)\\n response = requests.get(\\n query,\\n headers={\\n \\\"Content-Type\\\": \\\"application/json\\\",\\n \\\"Authorization\\\": \\\"Bearer {}\\\".format(access_token)\\n }\\n )\\n response_json = response.json()\\n # \\n \\n songs_no = response_json[\\\"tracks\\\"][\\\"total\\\"]\\n if songs_no == 0 :\\n return {\\\"songs_no\\\" : songs_no}\\n songs = response_json[\\\"tracks\\\"][\\\"items\\\"]\\n if(len(songs)<5):\\n uri = [songs[0][\\\"uri\\\"]]\\n names = [songs[0][\\\"name\\\"]]\\n artists = [songs[0][\\\"artists\\\"][0][\\\"name\\\"]]\\n imageUrl = [songs[0][\\\"album\\\"][\\\"images\\\"][-1][\\\"url\\\"]]\\n response_obj = {\\n \\\"songs_no\\\" : songs_no,\\n \\\"uri\\\" : uri,\\n \\\"names\\\" : names,\\n \\\"artists\\\" : artists,\\n \\\"images\\\" : imageUrl\\n }\\n else:\\n uri = [ songs[i][\\\"uri\\\"] for i in range(0,5)]\\n names = [songs[i][\\\"name\\\"] for i in range(0,5)]\\n artists = [songs[i][\\\"artists\\\"][0][\\\"name\\\"] for i in range(0,5)]\\n imageUrl = [songs[i][\\\"album\\\"][\\\"images\\\"][-1][\\\"url\\\"] for i in range(0,5)]\\n response_obj = {\\n \\\"songs_no\\\" : songs_no,\\n \\\"uri\\\" : uri,\\n \\\"names\\\" : names,\\n \\\"artists\\\" : artists,\\n \\\"images\\\" : imageUrl\\n }\\n return response_obj\",\n \"def get_album_url(self) -> Optional[str]:\\n return self.album_url\",\n \"def get_artist(self, object_id, relation=None, **kwargs):\\n return self.get_object(\\\"artist\\\", object_id, relation=relation, **kwargs)\",\n \"def get_url_from_album_name(browser, name: str) -> str:\\n album_name = name.split(\\\"-\\\")[1].strip()\\n artist_name = name.split(\\\"-\\\")[0].strip()\\n artist_url = get_url_from_artist_name(browser, artist_name)\\n\\n logger.debug(\\\"Searching for %s at %s\\\", album_name, artist_url)\\n browser.get_url(artist_url)\\n soup = browser.get_soup()\\n artist_album_list = [\\n [x.text.strip(), \\\"https://rateyourmusic.com\\\" + x.find(\\\"a\\\")[\\\"href\\\"]]\\n for x in soup.find_all(\\\"div\\\", {\\\"class\\\": \\\"disco_mainline\\\"})\\n ]\\n artist_album_url = [x[1] for x in artist_album_list]\\n artist_album_name = [x[0] for x in artist_album_list]\\n\\n url_match = artist_album_url[\\n artist_album_name.index(\\n get_close_matches_icase(album_name, artist_album_name)[0]\\n )\\n ]\\n logger.debug(\\\"Best match : %s\\\", url_match)\\n return url_match\",\n \"def _query_artist_by_song(self, entities: List[str]):\\n artists = []\\n for e in entities:\\n artists += [\\n song.get('artist_name')\\n for song\\n in self.kb_api.get_song_data(e)\\n ]\\n\\n return artists\",\n \"def create_artist_new_music_line(spotify_artist_music):\\n body = ''\\n for item in spotify_artist_music:\\n if item['thumbnail']:\\n artist_string = '<p><img src=\\\"{}\\\" width=\\\"{}\\\" height=\\\"{}\\\" /> {} released on {}--{}</p>\\\\n'\\n body += artist_string.format(item['thumbnail'][0]['url'], item['thumbnail'][0]['width'],\\n item['thumbnail'][0]['height'], item['name'], item['releaseDate'], item['url'])\\n return body\",\n \"def import_spotify(info: dict) -> (str, int):\\n url = info[\\\"playlist_url\\\"]\\n # Validate URL\\n matches = (\\n re.match(r\\\"^https?://open\\\\.spotify\\\\.com/playlist/([a-zA-Z\\\\d]*)/?\\\", url)\\n if isinstance(url, str)\\n else None\\n )\\n if not matches:\\n return \\\"Invalid URL\\\", 400\\n playlist_id = matches.group(1)\\n query_url = \\\"https://api.spotify.com/v1/playlists/\\\" + playlist_id\\n query_headers = {\\\"Authorization\\\": \\\"Bearer {}\\\".format(info[\\\"access_token\\\"])}\\n # Get/create playlist\\n playlist_json = requests.get(query_url, headers=query_headers).json()\\n if \\\"error\\\" in playlist_json:\\n status = playlist_json[\\\"error\\\"].get(\\\"status\\\")\\n message = playlist_json[\\\"error\\\"].get(\\\"message\\\")\\n return (\\n message if message else \\\"Error retrieving playlist\\\",\\n status if status else 500,\\n )\\n playlist = Playlist(\\n name=playlist_json[\\\"name\\\"],\\n last_sync_spotify=timezone.now(),\\n spotify_id=playlist_id,\\n )\\n if \\\"user\\\" in info:\\n playlist.owner = PlaylstrUser.objects.filter(id=info[\\\"user\\\"]).first()\\n if \\\"owner\\\" in playlist_json:\\n playlist.spotify_creator_id = playlist_json[\\\"owner\\\"][\\\"id\\\"]\\n playlist.spotify_creator_name = playlist_json[\\\"owner\\\"][\\\"display_name\\\"]\\n playlist.save()\\n # Get playlist tracks\\n tracks_response = requests.get(query_url + \\\"/tracks\\\", headers=query_headers)\\n if tracks_response.status_code != 200:\\n return tracks_response.reason, 500\\n tracks_json = tracks_response.json()\\n if \\\"error_description\\\" in tracks_json:\\n return tracks_json[\\\"error_description\\\"], 500\\n # Get list of tracks\\n index = -1\\n while \\\"next\\\" in tracks_json and tracks_json[\\\"next\\\"] is not None:\\n for j in tracks_json[\\\"items\\\"]:\\n index += 1\\n track = track_from_spotify_json(j[\\\"track\\\"])\\n try:\\n PlaylistTrack.objects.create(\\n playlist=playlist, track=track, index=index\\n )\\n except IntegrityError as e:\\n print(\\\"Error adding track {}: {}\\\".format(str(track), str(e)))\\n continue\\n tracks_json = requests.get(tracks_json[\\\"next\\\"], headers=query_headers).json()\\n return str(playlist.playlist_id), 200\",\n \"def get_track_info(track_id):\\n items = spotify.track(track_id)\\n name = items[\\\"name\\\"]\\n artists_names = \\\", \\\".join([\\n items[\\\"artists\\\"][x][\\\"name\\\"]\\n for x in range(len(items[\\\"artists\\\"]))\\n ])\\n album_artists = \\\", \\\".join([\\n items[\\\"album\\\"][\\\"artists\\\"][x][\\\"name\\\"]\\n for x in range(len(items[\\\"album\\\"][\\\"artists\\\"]))\\n ])\\n album_type = items[\\\"album\\\"][\\\"album_type\\\"]\\n album_name = items[\\\"album\\\"][\\\"name\\\"]\\n album_release = items[\\\"album\\\"][\\\"release_date\\\"]\\n album_track_number = items[\\\"track_number\\\"]\\n track_duration = items[\\\"duration_ms\\\"]\\n images_link = items[\\\"album\\\"][\\\"images\\\"]\\n max_image_res = 0\\n max_icon_size = 0\\n image_link = \\\"\\\"\\n icon_link = \\\"\\\"\\n for image in images_link:\\n if image[\\\"height\\\"] * image[\\\"width\\\"] > max_image_res:\\n image_link = image[\\\"url\\\"]\\n max_image_res = image[\\\"height\\\"] * image[\\\"width\\\"]\\n if image[\\\"height\\\"] < 400:\\n if image[\\\"height\\\"] > max_icon_size:\\n max_icon_size = image[\\\"height\\\"]\\n icon_link = image[\\\"url\\\"]\\n track = {\\\"name\\\": name,\\n \\\"Artist(s)\\\": artists_names,\\n \\\"Album Artist(s)\\\": album_artists,\\n \\\"Album Type\\\": album_type,\\n \\\"Album Name\\\": album_name,\\n \\\"Album Release\\\": album_release,\\n \\\"Track Number\\\": album_track_number,\\n \\\"Track Duration (ms)\\\": track_duration,\\n \\\"Image Link\\\": image_link,\\n \\\"Icon Link\\\": icon_link\\n }\\n\\n for artist in artists_names.split(', '):\\n \\\"\\\"\\\"\\n Checks for lyrics with song name and artist names\\n combination until one is found.\\n \\\"\\\"\\\"\\n try:\\n lyrics = lyricwikia.get_lyrics(artist, name)\\n track['lyrics'] = lyrics\\n break\\n except lyricwikia.LyricsNotFound:\\n pass\\n\\n return track\",\n \"def get_icon(f):\\n\\n url = None\\n t = FileHelper.get_media_type(f)\\n if t == \\\"audio\\\":\\n url = \\\"/img/music.png\\\"\\n elif t == \\\"video\\\":\\n url = \\\"/img/video.png\\\"\\n elif t == \\\"image\\\":\\n return FileHelper.get_url(f)\\n for fn in os.listdir(os.path.dirname(f)):\\n if \\\"album\\\" in fn.lower():\\n uri = os.path.join(os.path.dirname(f), fn)\\n url = FileHelper.get_url(uri)\\n\\n return url\",\n \"def get_artist_info(self, artist):\\n self.clear()\\n ai = self._artist_info(artist)\\n if ai != 0:\\n return ai\\n else:\\n if 'the ' in artist:\\n ai = self._artist_info(artist.replace('the ', ''))\\n else:\\n ai = self._artist_info('the ' + artist)\\n if ai == 0:\\n if 'junior' in artist:\\n ai = self._artist_info(artist.replace('junior', 'jr.'))\\n if ai == 0:\\n if '-' in artist:\\n ai = self._artist_info(artist.replace('-', ' '))\\n return ai\",\n \"def get_artist_ids_from_spotify(artists, spotify_authorization):\\n spotify_artists = dict()\\n url = os.environ['SPOTIFY_SEARCH_URL']\\n headers = {\\n 'Authorization': f'Bearer {spotify_authorization[\\\"access_token\\\"]}'\\n }\\n for artist in artists:\\n params = '?q={}&type=artist&items=1'.format(artist)\\n response = json.loads(requests.get(url + params, headers=headers).text)\\n if not response['artists'].get('items', []):\\n spotify_artists.update({artist: None})\\n else:\\n spotify_artists.update({response['artists']['items'][0]['id']: artist})\\n\\n return spotify_artists\",\n \"def get_absolute_url(self):\\n\\n return reverse('song-detail', args=[str(self.id)])\",\n \"def getURLForThing(thing):\",\n \"def set_album_artist(self, album_artist: str) -> None:\\n self.album_artist = album_artist\",\n \"def play_music(sid):\\n # Get the parameters for the get_song_id request\\n artist = None\\n album = None\\n title = None\\n if not request.json:\\n # If no JSON parameters were given, just resume playing the song\\n db = sqlite3.connect('/home/tropius/TROPIUS/TROPIUS.db')\\n host = hosts.get_detail(db, sid)\\n spotify.resume(host['ip'])\\n return jsonify({})\\n else:\\n try:\\n # Get the host data from the database\\n db = sqlite3.connect('/home/tropius/TROPIUS/TROPIUS.db')\\n host = hosts.get_detail(db, sid)\\n artist = None\\n album = None\\n track = None\\n if request.json.has_key('track') and request.json.get('track'):\\n track = request.json.get('track')\\n elif request.json.has_key('album') and request.json.get('album'):\\n album = request.json.get('album')\\n elif request.json.has_key('artist') and request.json.get('artist'):\\n artist = request.json.get('artist')\\n else:\\n spotify.resume(host['ip'])\\n return jsonify({})\\n spotify.compound_play(host['ip'], artist=artist, album=album, song=track)\\n return jsonify({})\\n except:\\n abort(400)\",\n \"def wrap_spotify_link(item, text=''):\\n\\n # generate default text if no text has been given\\n if not text:\\n name = item['name']\\n if item['type'] == 'playlist':\\n user = SP.user(item['owner']['id'])['display_name']\\n text = f'{name} by {user}'\\n elif item['type'] == 'artist':\\n text = name\\n else:\\n artist = item['artists'][0]['name']\\n text = f'{name} by {artist}'\\n\\n link = item['external_urls']['spotify']\\n return f'<a href=\\\"{link}\\\">{text}</a>'\",\n \"def get_genius_page(self, artist: str, song: str) -> str:\\n\\n artist = self.just_replace_strings_with_dashes(artist)\\n song = self.just_replace_strings_with_dashes(song)\\n\\n url = self.gen_url + artist + '-' + song + '-lyrics'\\n\\n resp = requests.get(url)\\n\\n if resp.status_code == 200:\\n try:\\n content = bs4.BeautifulSoup(resp.content)\\n lyrics = content.text[content.text.rindex(\\n '[Verse 1]'):content.text.index('Embed')]\\n lyrics = self.clean_lyrics_response(lyrics)\\n return lyrics\\n\\n except (ValueError, IndexError) as e:\\n print('Lyrics not found {}, due to error {}'.format(song, e))\\n\\n try:\\n lyrics = content.text[content.text.rindex(\\n '[Verse]'):content.text.index('Embed')]\\n lyrics = self.clean_lyrics_response(lyrics)\\n return lyrics\\n\\n except ValueError as e:\\n print(\\n 'Lyrics not found {}, due to error {}, single verse song'.format(song, e))\",\n \"def get_track_correction(artist, track):\\n q_artist = quote(artist)\\n q_track = quote(track)\\n track_addr = \\\"http://ws.audioscrobbler.com/2.0/?method=track.getcorrection&artist=%s&track=%s&api_key=b25b959554ed76058ac220b7b2e0a026\\\" % (q_artist, q_track)\\n print track_addr \\n try:\\n tree = ET.parse(urllib2.urlopen(track_addr))\\n except urllib2.HTTPError:\\n print \\\"httperror\\\"\\n return (artist, track)\\n c_track = None\\n try:\\n c_track = tree.find(\\\"corrections\\\").find(\\\"correction\\\").find(\\\"track\\\").find(\\\"name\\\").text\\n except:\\n pass\\n\\n return (artist, c_track) if c_track else (artist, track)\",\n \"def make_album(artist, album, tracks=\\\"\\\"):\\n retval = {'artist': artist, 'album': album}\\n if tracks:\\n retval['tracks'] = tracks\\n return retval\",\n \"def get_albums_by_artist(albumtype, search_for, sort_on):\\n return list(dmla.list_albums_by_artist(albumtype, search_for, sort_on))\",\n \"def getSimilarArtists(artist_id, limit = 5):\\n\\tresponse = requests.get(\\\"https://api.spotify.com/v1/artists/%s/related-artists\\\"%artist_id).json()\\n\\t\\n\\treturn response.get('artists')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.83749163","0.73485065","0.7067173","0.6968523","0.68646127","0.66602623","0.6432892","0.632123","0.62950456","0.61599934","0.61227757","0.60696423","0.606751","0.6037092","0.59806633","0.5964562","0.5937355","0.5896755","0.5891374","0.5862065","0.5852023","0.585174","0.5843221","0.5836247","0.58265895","0.58251625","0.5820384","0.5808944","0.5796718","0.5793174","0.57787746","0.5772138","0.5722593","0.5673827","0.56713915","0.5665287","0.56588024","0.5650194","0.5615047","0.5612634","0.56123936","0.561226","0.5607951","0.5605609","0.5605514","0.56053334","0.5587994","0.55845505","0.55760574","0.556875","0.55680066","0.556034","0.55471295","0.55471295","0.55063325","0.55010766","0.5500025","0.54920727","0.54863167","0.54859304","0.5474465","0.54679346","0.5462347","0.5444203","0.54412466","0.54395384","0.5424759","0.5419672","0.541104","0.54054546","0.5380777","0.5378848","0.5377785","0.536849","0.5352534","0.5340878","0.53222096","0.5317258","0.531719","0.5313224","0.52984124","0.52856565","0.5275607","0.5261216","0.52599806","0.5231512","0.5219488","0.5216633","0.52139264","0.52131766","0.5210854","0.5210167","0.52049124","0.52036923","0.5200438","0.51923376","0.51862425","0.5179117","0.51782835","0.51762044"],"string":"[\n \"0.83749163\",\n \"0.73485065\",\n \"0.7067173\",\n \"0.6968523\",\n \"0.68646127\",\n \"0.66602623\",\n \"0.6432892\",\n \"0.632123\",\n \"0.62950456\",\n \"0.61599934\",\n \"0.61227757\",\n \"0.60696423\",\n \"0.606751\",\n \"0.6037092\",\n \"0.59806633\",\n \"0.5964562\",\n \"0.5937355\",\n \"0.5896755\",\n \"0.5891374\",\n \"0.5862065\",\n \"0.5852023\",\n \"0.585174\",\n \"0.5843221\",\n \"0.5836247\",\n \"0.58265895\",\n \"0.58251625\",\n \"0.5820384\",\n \"0.5808944\",\n \"0.5796718\",\n \"0.5793174\",\n \"0.57787746\",\n \"0.5772138\",\n \"0.5722593\",\n \"0.5673827\",\n \"0.56713915\",\n \"0.5665287\",\n \"0.56588024\",\n \"0.5650194\",\n \"0.5615047\",\n \"0.5612634\",\n \"0.56123936\",\n \"0.561226\",\n \"0.5607951\",\n \"0.5605609\",\n \"0.5605514\",\n \"0.56053334\",\n \"0.5587994\",\n \"0.55845505\",\n \"0.55760574\",\n \"0.556875\",\n \"0.55680066\",\n \"0.556034\",\n \"0.55471295\",\n \"0.55471295\",\n \"0.55063325\",\n \"0.55010766\",\n \"0.5500025\",\n \"0.54920727\",\n \"0.54863167\",\n \"0.54859304\",\n \"0.5474465\",\n \"0.54679346\",\n \"0.5462347\",\n \"0.5444203\",\n \"0.54412466\",\n \"0.54395384\",\n \"0.5424759\",\n \"0.5419672\",\n \"0.541104\",\n \"0.54054546\",\n \"0.5380777\",\n \"0.5378848\",\n \"0.5377785\",\n \"0.536849\",\n \"0.5352534\",\n \"0.5340878\",\n \"0.53222096\",\n \"0.5317258\",\n \"0.531719\",\n \"0.5313224\",\n \"0.52984124\",\n \"0.52856565\",\n \"0.5275607\",\n \"0.5261216\",\n \"0.52599806\",\n \"0.5231512\",\n \"0.5219488\",\n \"0.5216633\",\n \"0.52139264\",\n \"0.52131766\",\n \"0.5210854\",\n \"0.5210167\",\n \"0.52049124\",\n \"0.52036923\",\n \"0.5200438\",\n \"0.51923376\",\n \"0.51862425\",\n \"0.5179117\",\n \"0.51782835\",\n \"0.51762044\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8370671"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":84788,"cells":{"query":{"kind":"string","value":"Parse the trace.txt for each iteration, calculate DVFS residency state/frequencies and dump the result in csv and flush the data for next iteration."},"document":{"kind":"string","value":"def process_iteration_result(self, result, context):\n self.infile = os.path.join(context.output_directory, 'trace.txt')\n if os.path.isfile(self.infile):\n self.logger.debug('Running result_processor \"dvfs\"')\n self.outfile = os.path.join(settings.output_directory, 'dvfs.csv')\n self.flush_parse_initialize()\n self.calculate()\n self.percentage()\n self.generate_csv(context)\n self.logger.debug('Completed result_processor \"dvfs\"')\n else:\n self.logger.debug('trace.txt not found.')"},"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 spectrum_parser():\n from tools import file_importer, file_outporter\n from random import random\n # from math import log10\n \n print(\"this is spectrum parser\")\n \n relPath = \"bob/processed/OST-24-05-2017_combined.csv\"\n outPath = \"bob/processed/OST-24-05-2017_combined_no0_spectrum.csv\"\n inpF = file_importer(relPath)\n outF = file_outporter(outPath) \n headerFlag = True\n rowCount = 0\n for inpLine in inpF:\n if headerFlag: \n headerFlag = False\n spColCount = 0\n inpList = inpLine.split(\"\\t\")\n for headerI in inpList:\n if \"Peptides ST-1|Peptides ST-2|Peptides ST-3\" == headerI:\n break\n else: spColCount += 1\n outF.write(\"ID,Protein ID, Gene name,\") # write header into output file\n for headI in inpList[spColCount].split(\"|\"):\n outF.write(headI + \",\")\n for headI in inpList[spColCount + 1].split(\"|\")[:-1]:\n outF.write(headI + \",\")\n outF.write(inpList[spColCount + 1].split(\"|\")[-1] + \"\\n\")\n rowCount += 1\n continue\n \n outF.write(str(rowCount) + \",\")\n \n inpLine = inpLine.strip()\n inpItems = inpLine.split(\"\\t\")\n inpName = max(inpItems[0].split(\"|\"), key=len) # get unique protein ID\n inpGeneName = max(inpItems[6].split(\"|\"), key=len) # and gene name\n outF.write(inpName + \",\" + inpGeneName + \",\")\n \n inpSP = inpItems[spColCount].split(\"|\") + inpItems[spColCount + 1].split(\"|\") # get lfq intensity scores\n # print inpSP\n for lfqI in inpSP[:-1]: # write lfq values\n if lfqI == \"_\" or lfqI == \"0\":\n outF.write(str(random()) + \",\") ################## try with log10 values this time\n else:\n try:\n outF.write(str(lfqI) + \",\")\n except ValueError:\n print(inpItems)\n raise\n \n if inpSP[-1] == \"_\" or inpSP[-1] == \"0\": outF.write(str(random()) + \"\\n\")\n else: outF.write(inpSP[-1] + \"\\n\")\n \n \n \n rowCount += 1","def readAndRewrite(self):\n try:\n with open(self.dataFile, 'r') as source:\n self.initDictionnary()\n lineCount = 0\n filteredData = [] # array of filtered flights\n for line in source:\n lineCount += 1\n line = line.strip()\n if line != \"\" and line[0] != \"#\":\n f = Flight(line, self.vocabulary)\n if self.filter:\n f.rewrite(self.summaryDict)\n f.filter(filteredData, self.listOfTerms, self.threshold)\n print(\"End : Displaying general summary\")\n self.displaySummary(self.summaryDict, lineCount)\n print(\"-------------- End of general summary ---------------\")\n if len(filteredData) != 0:\n print(\"Beginning summary on filtered data (\" + str(len(filteredData)) + \" entries)\")\n for data in filteredData:\n data.rewrite(self.summaryFilteredDict)\n print(\"End of summary for filtered data\")\n self.displaySummary(self.summaryFilteredDict, len(filteredData))\n print(\"Finding correlations\")\n self.findLinkedTerms()\n print(\"Printing correlations with \" + str(self.listOfTerms) + \" and threshold : \" + str(self.threshold))\n #for key in self.correlationDict.keys():\n #print(str(key) + \" : \" + str(self.correlationDict[key]))\n self.findAtypicalTerms()\n print(\"Printing atypical terms with \" + str(self.listOfTerms) + \" and threshold : \" + str(self.threshold))\n #for term in self.atypicalTermsDict.keys():\n #print(str(term) + \" : \" + str(self.atypicalTermsDict[term]))\n display = Display(self.vocabulary)\n display.displayPieChartSummary(self.summaryDict, \"General Summary for 2008 flights in the USA\")\n display.displayPieChartSummary(self.summaryFilteredDict, \"General Summary for 2008 flights with \"+str(self.listOfTerms)+\" and threshold : \" + str(self.threshold))\n display.displayBubbleChart(self.correlationDict,\"Linked terms in 2008 flights with \" + str(self.listOfTerms) + \" and threshold = \" + str(self.threshold))\n display.displayBubbleChart(self.atypicalTermsDict,\"Atypical terms in 2008 flights with \" + str(self.listOfTerms) + \" and threshold = \" + str(self.threshold))\n else:\n print(\"Filter returned no entry\")\n except:\n raise Exception(\"Error while loading the dataFile %s\" % self.dataFile)","def lfq_parser_2x():\n from tools import file_importer, file_outporter\n # from random import random\n from math import log10\n \n print(\"this is lfq parser_2x\")\n \n relPath = \"bob/processed/OST-24-05-2017_combined.csv\"\n outPath = \"bob/processed/OST-24-05-2017_combined_no0_2.csv\"\n inpF = file_importer(relPath)\n outF = file_outporter(outPath) \n headerFlag = True\n rowCount = 0\n for inpLine in inpF:\n if headerFlag: \n headerFlag = False\n lfqColCount = 0\n inpList = inpLine.split(\"\\t\")\n for headerI in inpList:\n if \"LFQ intensity\" in headerI:\n break\n else: lfqColCount += 1\n outF.write(\"ID,Protein ID, Gene name,\") # write header into output file\n for headI in inpList[lfqColCount].split(\"|\"):\n outF.write(headI + \",\")\n for headI in inpList[lfqColCount + 1].split(\"|\")[:-1]:\n outF.write(headI + \",\")\n outF.write(inpList[lfqColCount + 1].split(\"|\")[-1] + \"\\n\")\n rowCount += 1\n continue\n \n inpLine = inpLine.strip()\n inpItems = inpLine.split(\"\\t\") \n inpLFQ = inpItems[lfqColCount].split(\"|\") + inpItems[lfqColCount + 1].split(\"|\") # get lfq intensity scores\n \n procLFQ = []\n for lfqi in inpLFQ:\n if lfqi == \"_\": procLFQ.append(0)\n else: procLFQ.append(int(lfqi))\n if sum(procLFQ[:3])<=sum(procLFQ[3:]): continue # get rid of contaminants in control sample\n \n sumOne = inpLFQ[1] + inpLFQ[2]\n sumTwo = inpLFQ[1] + inpLFQ[3]\n sumThree = inpLFQ[2] + inpLFQ[3]\n \n if sumOne == \"__\" or sumTwo == \"__\" or sumThree == \"__\": continue # test if protein is being detected in at least 2 OST samples\n \n outF.write(str(rowCount) + \",\")\n \n\n inpName = max(inpItems[0].split(\"|\"), key=len) # get unique protein ID\n inpGeneName = max(inpItems[6].split(\"|\"), key=len) # and gene name\n outF.write(inpName + \",\" + inpGeneName + \",\")\n \n inpLFQ = inpItems[lfqColCount].split(\"|\") + inpItems[lfqColCount + 1].split(\"|\") \n # print inpLFQ\n for lfqI in inpLFQ[:-1]: # write lfq values\n if lfqI == \"_\" or lfqI == \"0\":\n outF.write(str(0) + \",\") ################## try with log2 values this time\n else:\n try:\n outF.write(str(round(log10(int(lfqI)))) + \",\")\n except ValueError:\n print(inpItems)\n raise\n \n if inpLFQ[-1] == \"_\" or inpLFQ[-1] == \"0\": outF.write(str(0) + \"\\n\")\n else: outF.write(str(round(log10(int(inpLFQ[-1])))) + \"\\n\")\n \n \n rowCount += 1\n\n print(\"lfq parser 2x finished successfully\")","def processMachineLog(file_name):\n\n # labelling of data lists\n date = []\n timeDay = []\n iteration = []\n iterationTime = [] # time it takes to complete a single cycle\n timeElapsed = [] # time elapsed since start of test for the day\n \n \"\"\" sample of important lines from log\n ##### Begin Iteration # 1 at Wed Jan 27 16:32:27 EST 2016\n ##### Completed Iteration # 1 time: 13.643001secs Total time: 13.648001secs at Wed Jan 27 16:32:41 EST 2016\n \"\"\"\n\n # opens csv file and sorts the data into the lists\n # with open(file_name, 'rb') as csvfile:\n with open(file_name, 'rb') as logFile:\n data = logFile.readlines()\n for line in data:\n if line.startswith(\"##### Completed\"):\n iteration.append(line.split(\" \")[4])\n iterationTime.append(line.split(\" \")[7][:-4]) # remove \"secs\" from the value\n # Get the Day of week, month, and date to put into date list\n dayMoDate = line.split(\" \")[14] + \" \" + line.split(\" \")[15] + \" \" + line.split(\" \")[16] + \" \" + line.split(\" \")[19].rstrip()\n date.append(dayMoDate)\n # get the time in AM/PM format (because Jess can't read 24HR format to save her life)\n convertTime = time.strftime(\"%I:%M:%S %p\", (time.strptime(line.split(\" \")[17] , \"%H:%M:%S\")))\n timeDay.append(convertTime)\n # get the total time (H:M:S format) that has elapsed since the beginning of the test\n timeSecs = float(line.split(\" \")[11][:-4]) # remove \"secs\" from the value\n timeElapsed.append(datetime.timedelta(seconds=timeSecs))\n \n # form the dataframe with all the lists as columns\n df = pd.DataFrame({'Date': date, 'Time': timeDay, 'Cycle': iteration, 'Cycle Duration': iterationTime, 'Time Elapsed': timeElapsed})\n return df","def parse_trace(self):\n current = '' # current basic block being parsed\n previous = '0' # previous basic block beding parsed\n edge_count = 0\n uniq_count = 0\n with open(self._fifo_name, 'r') as fifo:\n for line in fifo:\n if line[6] == '4':\n continue\n # process traceed tbs\n current = line.split(':')[0]\n\n parse_edge = (previous, current)\n edge_count += 1\n if not parse_edge in TRACE_EDGES:\n TRACE_EDGES.add(parse_edge)\n uniq_count += 1\n previous = current","def analysis(N):\n\n http_log_paths = get_http_logs()\n\n httplogs = []\n\n for path in http_log_paths:\n file = path+'/http.log'\n if os.path.isfile(file):\n httplogs.append(file)\n else:\n pass #print(path)\n\n fields = []\n\n for log in httplogs:\n with open(log) as f:\n lines = f.readlines()\n rows = len(lines)\n filesize = sum([len(line) for line in lines])\n\n tss = [] # time series\n methods = []\n uris = []\n uas = []\n request_body_lens = []\n response_body_lens = []\n status_codes = []\n filenames = []\n\n tmp = []\n\n for line in lines[8:len(lines)-1]:\n fs = line.strip().split('\\t')\n\n \"\"\"\n ts = fileds[0]\n uid = fileds[1]\n orig_h = fileds[2]\n orig_p = fileds[3]\n resp_h = fileds[4]\n resp_p = fileds[5]\n trans_depth = fileds[6]\n method = fileds[7]\n host = fileds[8]\n uri = fileds[9]\n referrer = fileds[10]\n user_agent = fileds[11]\n request_body_len = fileds[12]\n response_body_len = fileds[13]\n status_code = fileds[14]\n status_msg = fileds[15]\n info_code = fileds[16]\n info_msg = fileds[17]\n filename = fileds[18]\n tags = fileds[19]\n username = fileds[20]\n password = fileds[21]\n proxied = fileds[22]\n orig_fuids = fileds[23]\n orig_mime_types = fileds[24]\n resp_fuids = fileds[25]\n resp_mime_types = fileds[26]\n\n tss.append(ts)\n methods.append(method)\n uris.append(uri)\n uas.append(user_agent)\n request_body_lens.append(request_body_len)\n response_body_lens.append(response_body_len)\n status_codes.append(status_code)\n filenames.append(filename)\n \"\"\"\n\n tmp.append(fs[N])\n\n #print(log, rows, ','.join(methods))\n\n # time intervals\n #tss_sorted = sorted(map(float,tmp))\n #tss_sorted = map(float, tmp)\n #intervals = map(int,[tss_sorted[i+1]-tss_sorted[i] for i in range(len(tss_sorted)-1)])\n #print('%s %s' % (log, ' '.join(map(str,intervals))))\n #file = urlparse(fs[N]).path.split('/')[-1].split('.')\n #if len(file)>1:\n # tmp.append(file[-1])\n #tmp.append(urlparse(fs[N]).path.split('/')[-1])\n #tmp.append(urlparse(fs[N]).path)\n\n #fields.append(set(tmp))\n #fields.append(intervals)\n fields.append(tmp)\n\n\n dic = {}\n for i in fields:\n for j in i:\n if j in dic:\n dic[j] += 1\n else:\n dic[j] = 1\n ls = sorted(dic.items(), lambda x,y: cmp(x[1], y[1]), reverse = True)\n for i in range(len(ls)):\n print('%s\\t%s' %(ls[i][0], ls[i][1]))\n #print('%s' % join(ls[i][1]))\n\n\n \"\"\"\n col = []\n for i in fields:\n for j in i:\n col.append(j)\n print('%s' % ' '.join(map(str,col)))\n \"\"\"\n\n\n \"\"\"\n dic = {}\n for i in fields:\n for j in i:\n sub = j.split('.')\n if sub[0] in dic:\n dic[sub[0]] += 1\n else:\n dic[sub[0]] = 1\n\n\n if len(sub) > 1:\n if sub[-2]+'.'+sub[-1] in dic:\n dic[sub[-2]+'.'+sub[-1]] += 1\n else:\n dic[sub[-2]+'.'+sub[-1]] = 1\n\n\n ls = sorted(dic.items(), lambda x, y: cmp(x[1], y[1]), reverse=True)\n for i in range(len(ls)):\n print('%s\\t%s' % (ls[i][0], ls[i][1]))\n # print('%s' % join(ls[i][1]))\n\n \"\"\"","def _log_file_processing_stats(self, known_file_paths):\n # File Path: Path to the file containing the DAG definition\n # PID: PID associated with the process that's processing the file. May\n # be empty.\n # Runtime: If the process is currently running, how long it's been\n # running for in seconds.\n # Last Runtime: If the process ran before, how long did it take to\n # finish in seconds\n # Last Run: When the file finished processing in the previous run.\n headers = [\"File Path\", \"PID\", \"Runtime\", \"# DAGs\", \"# Errors\", \"Last Runtime\", \"Last Run\"]\n\n rows = []\n now = timezone.utcnow()\n for file_path in known_file_paths:\n last_runtime = self.get_last_runtime(file_path)\n num_dags = self.get_last_dag_count(file_path)\n num_errors = self.get_last_error_count(file_path)\n file_name = os.path.basename(file_path)\n file_name = os.path.splitext(file_name)[0].replace(os.sep, \".\")\n\n processor_pid = self.get_pid(file_path)\n processor_start_time = self.get_start_time(file_path)\n runtime = (now - processor_start_time) if processor_start_time else None\n last_run = self.get_last_finish_time(file_path)\n if last_run:\n seconds_ago = (now - last_run).total_seconds()\n Stats.gauge(f\"dag_processing.last_run.seconds_ago.{file_name}\", seconds_ago)\n\n rows.append((file_path, processor_pid, runtime, num_dags, num_errors, last_runtime, last_run))\n\n # Sort by longest last runtime. (Can't sort None values in python3)\n rows.sort(key=lambda x: x[3] or 0.0)\n\n formatted_rows = []\n for file_path, pid, runtime, num_dags, num_errors, last_runtime, last_run in rows:\n formatted_rows.append(\n (\n file_path,\n pid,\n f\"{runtime.total_seconds():.2f}s\" if runtime else None,\n num_dags,\n num_errors,\n f\"{last_runtime:.2f}s\" if last_runtime else None,\n last_run.strftime(\"%Y-%m-%dT%H:%M:%S\") if last_run else None,\n )\n )\n log_str = (\n \"\\n\"\n + \"=\" * 80\n + \"\\n\"\n + \"DAG File Processing Stats\\n\\n\"\n + tabulate(formatted_rows, headers=headers)\n + \"\\n\"\n + \"=\" * 80\n )\n\n self.log.info(log_str)","def stat_parser():\n from tools import file_importer, file_outporter\n from math import log\n \n print(\"this is stat parser\")\n \n relPath = \"bob/processed/24h_bobdata_ed2.csv\"\n outPathUp = \"bob/processed/24h_bobprots_up_full.csv\"\n outPathDown = \"bob/processed/24h_bobprots_down_full.csv\"\n inpF = file_importer(relPath)\n outFUp = file_outporter(outPathUp)\n outFDown = file_outporter(outPathDown)\n \n \n skipFlag = True\n \n for inpLine in inpF:\n if skipFlag:\n skipFlag = False\n outFDown.write(\"ID,Uniprot ID,Gene name,unique peptides (unique+razor),KO1,KO2,KO3,WT1,WT2,WT3,enrichment,P value\\n\")\n outFUp.write(\"ID,Uniprot ID,Gene name,unique peptides (unique+razor),KO1,KO2,KO3,WT1,WT2,WT3,enrichment,P value\\n\")\n continue\n inpLine = inpLine.split(\"\\\" \\\"\")\n curLine = []\n for inpI in inpLine:\n curLine.append(inpI.strip(\"\\\"\\n\"))\n try: \n curLine[-1] = float(curLine[-1])\n except ValueError:\n curLine[-1] = 1 \n if curLine[-1] < 0.05 and int(curLine[3]) > 1: # check if protein has at least 2 unique peptides and has a significant p value\n curLine[4:10] = [int(x) for x in curLine[4:10]]\n enrScore = log((sum(curLine[4:7]) / 3.0)/(sum(curLine[7:10]) / 3.0),2) # calculate log2 enrichment score\n # print int(sum(curLine[4:7]) / 3.0), int(sum(curLine[7:10]) / 3.0)\n if sum(curLine[4:7]) / 3.0 > sum(curLine[7:10]) / 3.0: # if the mean of the KO intensities is higher than the wt \n for outI in curLine:\n outFDown.write(str(outI).strip(\" \"))\n if outI is not curLine[-1]:\n outFDown.write(\",\")\n if outI is curLine[-2]:\n outFDown.write(str(enrScore)+ \",\")\n else:\n outFDown.write(\"\\n\")\n # outFDown.write(curLine[1] + \",\" + curLine[2] + \"\\n\")\n else:\n # outFUp.write(curLine[1] + \",\" + curLine[2] + \"\\n\")\n for outI in curLine:\n outFUp.write(str(outI).strip(\" \"))\n if outI is not curLine[-1]:\n outFUp.write(\",\")\n if outI is curLine[-2]:\n outFUp.write(str(enrScore)+ \",\")\n else:\n outFUp.write(\"\\n\")\n \n inpF.close()\n outFUp.close()\n outFDown.close()\n print(\"stat_parser completed\")","def _read_traces(self, unpack_headers=False, headonly=False,\n yield_each_trace=False):\n self.traces = []\n # Determine the filesize once.\n if isinstance(self.file, io.BytesIO):\n pos = self.file.tell()\n self.file.seek(0, 2) # go t end of file\n filesize = self.file.tell()\n self.file.seek(pos, 0)\n else:\n filesize = os.fstat(self.file.fileno())[6]\n # Big loop to read all data traces.\n i = -1\n while True:\n # Read and as soon as the trace header is too small abort.\n try:\n trace = SEGYTrace(self.file, self.data_encoding, self.endian,\n unpack_headers=unpack_headers,\n filesize=filesize, headonly=headonly)\n i += 1\n if yield_each_trace:\n yield trace\n else:\n if self.hdf_writer == 0:\n self.traces.append(trace)\n else:\n if headonly and not self.hdf_writer.need_writing:\n self.hdf_writer.count_of_traces += 1\n elif self.hdf_writer.need_writing:\n self.hdf_writer.add_trace(trace, i)\n else:\n self.traces.append(trace)\n\n except SEGYTraceHeaderTooSmallError:\n break","def get_traces(self):\n\n self.rank = 0\n traces = []\n sub_traces = []\n current = []\n with open(self.file_path, 'r') as f:\n for line in f:\n current.append(line.strip('\\n').replace('<', '\\<').replace('>', '\\>'))\n sub_traces.append(current)\n traces.append(sub_traces)\n return traces","def read_results(self, filepath):\n \n if isinstance(filepath, str):\n finput = open(filepath)\n elif isinstance(filepath, file):\n finput = filepath\n else:\n raise Exception, \"filepath should be a path or a file descriptor\"\n \n i=0\n found_xsec_line = False\n for line in finput: \n # Exit as soon as we hit the xml part. Not elegant, but the part\n # below should eventually be xml anyway.\n if '<' in line:\n break\n i+=1\n if i == 1:\n def secure_float(d):\n try:\n return float(d)\n except ValueError:\n m=re.search(r'''([+-]?[\\d.]*)([+-]\\d*)''', d)\n if m:\n return float(m.group(1))*10**(float(m.group(2)))\n return \n\n data = [secure_float(d) for d in line.split()]\n self.axsec, self.xerru, self.xerrc, self.nevents, self.nw,\\\n self.maxit, self.nunwgt, self.luminosity, self.wgt, \\\n self.xsec = data[:10]\n if len(data) > 10:\n self.maxwgt = data[10]\n if len(data) >12:\n self.th_maxwgt, self.th_nunwgt = data[11:13]\n if self.mfactor > 1:\n self.luminosity /= self.mfactor\n continue\n try:\n l, sec, err, eff, maxwgt, asec = line.split()\n found_xsec_line = True\n except:\n break\n self.ysec_iter.append(secure_float(sec))\n self.yerr_iter.append(secure_float(err))\n self.yasec_iter.append(secure_float(asec))\n self.eff_iter.append(secure_float(eff))\n self.maxwgt_iter.append(secure_float(maxwgt))\n\n finput.seek(0)\n xml = []\n for line in finput:\n if re.match('^.*<.*>',line):\n xml.append(line)\n break\n for line in finput:\n xml.append(line)\n\n if xml:\n self.parse_xml_results('\\n'.join(xml)) \n \n # this is for amcatnlo: the number of events has to be read from another file\n if self.nevents == 0 and self.nunwgt == 0 and isinstance(filepath, str) and \\\n os.path.exists(pjoin(os.path.split(filepath)[0], 'nevts')): \n nevts = int((open(pjoin(os.path.split(filepath)[0], 'nevts')).read()).split()[0])\n self.nevents = nevts\n self.nunwgt = nevts","def process(self, terms):\n for entry in self.files:\n try:\n logger.info('file - {0}'.format(entry.path))\n\n # notional output file path\n path_sentences = self.path.joinpath('{0}.csv'.format(entry.path.stem))\n path_summary = self.path.joinpath('{0}-summary.csv'.format(entry.path.stem))\n logger.info('will save to - {0}'.format(path_sentences.resolve()))\n\n reports = self.inspect_doc(entry, terms)\n\n # receiving a list of dicts\n # therefore pandas can package into a useful outcome\n if len(reports) > 0:\n frame_sentences = pd.DataFrame(reports)\n\n frame_sentences = frame_sentences[['page', 'term', 'sentence']]\n logger.info('saving sentence file to - {0}'.format(path_sentences.resolve()))\n frame_sentences.to_csv(str(path_sentences.resolve()))\n \n frame_summary = frame_sentences.pivot_table(\n index='page',\n columns='term',\n aggfunc='size',\n fill_value=0\n )\n logger.info('saving summary file to - {0}'.format(path_sentences.resolve()))\n frame_summary.to_csv(str(path_summary.resolve()))\n\n\n except Exception as e:\n logger.error(e)","def lfq_parser():\n # from tools import file_importer, file_outporter\n from random import randint\n import os.path\n # from math import log10\n \n print(\"this is lfq parser\")\n \n \"\"\"\n relPath = \"bob/processed/OST-24-05-2017_combined.csv\"\n outPath = \"bob/processed/OST-24-05-2017_combined_no0_1000.csv\"\n inpF = file_importer(relPath)\n outF = file_outporter(outPath) \n \"\"\"\n inpF = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \"data\", \"cav1ko\", \"processed\", \"cav1ko-1.csv\"),\"r\")\n outF = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \"data\", \"cav1ko\", \"processed\", \"cav1ko-1_no0.csv\"),\"w\")\n \n headerFlag = True\n rowCount = 0\n for inpLine in inpF:\n if headerFlag: \n headerFlag = False\n lfqColCount = 0\n inpList = inpLine.split(\"\\t\")\n for headerI in inpList:\n if \"LFQ intensity\" in headerI:\n break\n else: lfqColCount += 1\n outF.write(\"ID,Protein ID, Gene name,\") # write header into output file\n if len(inpList[lfqColCount].split(\"|\")) > 1:\n for headI in inpList[lfqColCount].split(\"|\"):\n outF.write(headI + \",\")\n for headI in inpList[lfqColCount + 1].split(\"|\")[:-1]:\n outF.write(headI + \",\")\n outF.write(inpList[lfqColCount + 1].split(\"|\")[-1] + \"\\n\")\n else:\n outF.write(inpList[lfqColCount] + \",\")\n outF.write(inpList[lfqColCount + 1] + \",\")\n outF.write(inpList[lfqColCount + 2] + \"\\n\")\n rowCount += 1\n continue\n \n outF.write(str(rowCount) + \",\")\n \n inpLine = inpLine.strip()\n inpItems = inpLine.split(\"\\t\")\n inpName = max(inpItems[0].split(\"|\"), key=len) # get unique protein ID\n inpGeneName = max(inpItems[6].split(\"|\"), key=len) # and gene name\n outF.write(inpName + \",\" + inpGeneName + \",\")\n \n inpLFQ = inpItems[lfqColCount].split(\"|\") + inpItems[lfqColCount + 1].split(\"|\") + inpItems[lfqColCount + 2].split(\"|\")# get lfq intensity scores\n # print inpLFQ\n for lfqI in inpLFQ[:-1]: # write lfq values\n if lfqI == \"_\" or lfqI == \"0\":\n outF.write(str(randint(1,1000)) + \",\") ################## try with log10 values this time\n else:\n try:\n outF.write(str(int(lfqI)) + \",\")\n except ValueError:\n print(inpItems)\n raise\n \n if inpLFQ[-1] == \"_\" or inpLFQ[-1] == \"0\": outF.write(str(randint(1,1000)) + \"\\n\")\n else: outF.write(str(inpLFQ[-1]) + \"\\n\")\n \n \n \n rowCount += 1\n\n \n \n \"\"\"\n \n for inpI in inpItems[0:4]: # copy over gene name and such to new file\n outF.write(inpI)\n outF.write(\",\")\n \n commaCount = 0\n for inpJ in inpItems[4:]: # copy over lfq values while replacing 0-s with random values\n commaCount += 1\n if int(inpJ) == 0:\n randNum = randint(1,100)\n outF.write(str(randNum))\n else:\n outF.write(inpJ)\n if commaCount < 6:\n outF.write(\",\")\n outF.write(\"\\n\")\n inpF.close()\n outF.close()\n \n \"\"\"\n \n print(\"lfq parser finished successfully\")","def main():\n\n file_name_base = \"./lab-record/result/fairness/\"\n scenarios = ['lan', 'wan1', 'wan2']\n scenario = scenarios[2]\n\n algorithms = [\"bbr\", \"scalable\", \"bic\", \"highspeed\", \"htcp\", \"hybla\",\n \"illinois\", \"vegas\", \"yeah\"]\n names = [\"BBR\", \"Scalable\", \"BIC\", \"High Speed\",\n \"H-TCP\", \"Hybla\", \"Illinois\", \"Vegas\", \"YeAH\"]\n\n test_types = [\"vs_reno\", \"vs_cubic\", \"vs_itself\"]\n\n fsize = 36\n \n index_reno = []\n index_cubic = []\n index_itself = []\n\n data = []\n \n print 'Loadint statistics for ' + file_name_base + '/' + scenario\n\n for algorithm in algorithms:\n for test in test_types:\n path_base = file_name_base + \"/\" + scenario + \"/\" + test + \"/\" + \\\n algorithm + \"/\"\n if test == \"vs_itself\":\n exp_name = names[algorithms.index(algorithm)] + \"_1\"\n con_name = names[algorithms.index(algorithm)] + \"_2\"\n print path_base + exp_name\n print path_base + con_name\n exp_filename = \"/\" + algorithm + \"_1.log\"\n con_filename = \"/\" + algorithm + \"_2.log\"\n process(path_base, exp_filename, con_filename, index_itself)\n if test == \"vs_reno\":\n exp_name = names[algorithms.index(algorithm)]\n con_name = \"Reno\"\n print path_base + exp_name\n print path_base + con_name\n exp_filename = \"/\" + algorithm + \".log\"\n con_filename = \"/reno.log\"\n process(path_base, exp_filename, con_filename, index_reno)\n if test == \"vs_cubic\":\n con_name = \"CUBIC\"\n exp_name = names[algorithms.index(algorithm)]\n print path_base + exp_name\n print path_base + con_name\n exp_filename = \"/\" + algorithm + \".log\"\n con_filename = \"/cubic.log\"\n process(path_base, exp_filename, con_filename, index_cubic)\n\n size = 9\n x = numpy.arange(size)\n\n total_width, n = 1.2, 2.5\n width = 1.0 / n\n x = x - (total_width - width) / 2\n\n for i in range(0, len(x)):\n x[i] += 0.5 * i\n\n # Exp\n fig = plt.figure()\n\n # Con\n con_reno = plt.bar(x + 0 * width - 1.2,\n index_reno,\n width=width,\n label='Against Reno',\n alpha=0.5,\n color=\"darkorange\")\n\n con_cubic = plt.bar(x + 1 * width - 1.2,\n index_cubic,\n width=width,\n label='Against CUBIC',\n alpha=0.5,\n color=\"lawngreen\")\n\n con_itself = plt.bar(x + 2 * width - 1.2,\n index_itself,\n width=width,\n label='Against Another Same CCA',\n alpha=0.5,\n color=\"dodgerblue\")\n\n # Index\n plt.xticks(x + 1.5 * width - 1.2, [\"BBR\", \"Scalable\", \"BIC\", \"High Speed\",\n \"H-TCP\", \"Hybla\", \"Illinois\", \"Vegas\",\n \"YeAH\"],\n fontsize=fsize,\n rotation=\"45\")\n plt.ylabel(\"Jain`s Fairness Index\", fontsize=fsize)\n plt.yticks(fontsize=fsize)\n plt.ylim(0.5, 1.1)\n\n ax = plt.subplot(111)\n ax.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3,\n ncol=3, mode=\"expand\", borderaxespad=0., fontsize=fsize)\n\n plt.subplots_adjust(left=0.07, right=0.98, top=0.9, bottom=0.2)\n\n plt.show()","def Processrawtrace(self):\n \n tracedict = {}\n \n for l in open(self.paramsfile):\n tracedict[l.split(',')[0]] = (l.split(',')[1])\n \n tracedict['f1'] = int(tracedict['f1'])\n tracedict['f2'] = self.f2\n tracedict['fps'] = int(tracedict['fps'])\n tracedict['f_end'] = int(tracedict['f_end'])\n tracedict['flypic'] = dftf.getflypic('roi') \n tracedict['rawtrace'] = dftf.loadresultsfile(self.fname, 'Mean1')\n tracedict['msubtrace'] = msub(tracedict['rawtrace'][0:tracedict['f2']])\n \n return tracedict","def main(files, target_depth, tol_diff, depth_fld, temperature_fld,\n salinity_fld):\n ymd_fmt = \"{0}-{1}-{2}\"\n # Note change of line terminator to make it compatible with AWK\n writer = csv.writer(sys.stdout, lineterminator='\\n')\n writer.writerow([\"time\", \"bottle_number\", \"depth\",\n \"temperature\", \"salinity\"])\n for bottle_f in files:\n with bottle_f:\n for lineno, line in enumerate(bottle_f, start=1):\n if re.search('^(\\*|#)', line):\n continue\n if re.search('^ *bottle', line.lower()):\n databeg = lineno + 2\n continue\n if (lineno - databeg) % 2 == 0:\n parsedl = line.split()\n mm = _french_month(parsedl[1])\n if mm:\n fmt = '%Y-%m-%d %H:%M:%S'\n yyyymmdd = ymd_fmt.format(parsedl[3], mm, parsedl[2])\n else:\n fmt = '%Y-%b-%d %H:%M:%S'\n yyyymmdd = ymd_fmt.format(parsedl[3], parsedl[1],\n parsedl[2])\n bottle_no = parsedl[0]\n depth = parsedl[depth_fld - 1]\n temperature = parsedl[temperature_fld - 1]\n salinity = parsedl[salinity_fld - 1]\n else:\n if lineno <= databeg:\n continue\n hhmmss = line.split()[0]\n ymd = datetime.strptime(\"{0} {1}\".format(yyyymmdd,\n hhmmss), fmt)\n depth_dev = abs(float(depth) - target_depth)\n if (depth_dev < tol_diff):\n line_out = (ymd.strftime('%Y-%m-%d %H:%M:%S'),\n bottle_no, depth, temperature,\n salinity)\n writer.writerow(line_out)","def inner():\n for line in file_obj:\n logdata = tilak_haproxylog.parse_line(line)\n if logdata is not None:\n logdata[\"hits\"] = 1\n for value_key in value_keynames:\n if value_key not in logdata:\n logdata[value_key] = 0\n status_code = int(logdata[\"status_code\"])\n if 100 <= status_code <= 199:\n logdata[\"rsp_1xx\"] = 1\n elif 200 <= status_code <= 299:\n logdata[\"rsp_2xx\"] = 1\n elif 300 <= status_code <= 399:\n logdata[\"rsp_3xx\"] = 1\n elif 400 <= status_code <= 499:\n logdata[\"rsp_4xx\"] = 1\n elif 500 <= status_code <= 599:\n logdata[\"rsp_5xx\"] = 1\n else:\n logdata[\"rsp_other\"] = 1\n ret_data = dict(zip(index_keynames, (logdata[index_key] for index_key in index_keynames)))\n ret_data.update(dict(zip(value_keynames, (logdata[value_key] for value_key in value_keynames))))\n yield (logdata[\"ts\"], ret_data)","def produce_next_term_data(self):\n outputs = self.output()\n for termnum in self.term_range: # includes (end term + 1)\n test = self.test[self.test.termnum == termnum]\n\n # remove cold start recordsif requested\n test = self.handle_cold_start(test)\n\n term_outputs = outputs[termnum]\n trainf, testf = term_outputs['train'], term_outputs['test']\n with trainf.open('w') as ftrain, testf.open('w') as ftest:\n self.write_libfm_data(ftrain, ftest, self.train, test)\n\n self.transfer_term(termnum) # modify train/test sets in place\n # intentionally skip writing the last time this is run\n\n # TODO: this code converts the same records to libFM format multiple\n # times. Each subsequent train set contains records in the last train\n # set. These could be cached to avoid all of the string format\n # conversion overhead.","def record_trace(self):\n\n tfname = str(int(time.time())) + \".obd2_reader.trace\"\n self.tf_out = open(tfname, 'a')\n self.RecordTrace = 1\n print \"Recoding trace to:\", tfname","def analysis(file):\n\n fields = []\n\n with open(file) as f:\n lines = f.readlines()\n rows = len(lines)\n filesize = sum([len(line) for line in lines])\n\n tmp = []\n\n for line in lines[8:len(lines)-1]:\n fs = line.strip().split('\\t')\n\n \"\"\"\n fields:\n ts\n uid\n id.orig_h\n id.orig_p\n id.resp_h\n id.resp_p\n proto\n trans_id\n query\n qclass\n qclass_name\n qtype\n qtype_name\n rcode\n rcode_name\n AA\n TC\n RD\n RA\n Z\n answersTTLs\n rejected\n \"\"\"\n\n tmp.append(fs[N])\n\n #print(log, rows, ','.join(methods))\n\n # time intervals\n #tss_sorted = sorted(map(float,tmp))\n #tss_sorted = map(float, tmp)\n #intervals = map(int,[tss_sorted[i+1]-tss_sorted[i] for i in range(len(tss_sorted)-1)])\n #print('%s %s' % (log, ' '.join(map(str,intervals))))\n #file = urlparse(fs[N]).path.split('/')[-1].split('.')\n #if len(file)>1:\n # tmp.append(file[-1])\n #tmp.append(urlparse(fs[N]).path.split('/')[-1])\n #tmp.append(urlparse(fs[N]).path)\n\n #fields.append(set(tmp))\n #fields.append(intervals)\n fields.append(tmp)\n\n\n dic = {}\n for i in fields:\n for j in i:\n if j in dic:\n dic[j] += 1\n else:\n dic[j] = 1\n ls = sorted(dic.items(), lambda x,y: cmp(x[1], y[1]), reverse = True)\n for i in range(len(ls)):\n print('%s\\t%s' %(ls[i][0], ls[i][1]))\n #print('%s' % join(ls[i][1]))","def run(self):\n lineage_csv_gz = self.input_files_local[0][0]\n output_db = self.output_files_local()[0]\n log.write(f\"input: {lineage_csv_gz} output: {output_db}\")\n\n with IdSeqDictForUpdate(output_db, IdSeqDictValue.VALUE_TYPE_ARRAY) as lineage_dict:\n batch_list = {}\n with gzip.open(lineage_csv_gz, \"rt\") as gzf:\n for line in gzf:\n fields = line.rstrip().split(\",\")\n taxid = fields[0]\n species, genus, family = fields[-1:-4:-1]\n batch_list[taxid] = [species, genus, family]\n if len(batch_list) >= BATCH_INSERT_SIZE:\n lineage_dict.batch_inserts(batch_list.items())\n batch_list = {}\n lineage_dict.batch_inserts(batch_list.items())","def read_trace(self, trace):\n csv_reader = csv.DictReader(self.csv_fd)\n for row in csv_reader:\n new_trace = RiscvInstructiontTraceEntry()\n new_trace.rd = row['rd']\n new_trace.rd_val = row['rd_val']\n new_trace.addr = row['addr']\n new_trace.binary = row['binary']\n new_trace.instr_str = row['str']\n trace.append(new_trace)","def parse_file(self):\n file_time = ''\n num_dir = 0\n num_freq = 0\n freq_w_band = 0.0\n freq_0 = 0.0\n start_dir = 0.0\n\n dspec_matrix = []\n\n # Extract the file time from the file name\n input_file_name = self._stream_handle.name\n\n match = FILE_NAME_MATCHER.match(input_file_name)\n\n if match:\n file_time = match.group(1)\n else:\n error_message = 'Unable to extract file time from DSpec input file name: %s '\\\n % input_file_name\n log.warn(error_message)\n self._exception_callback(RecoverableSampleException(error_message))\n\n # read the first line in the file\n line = self._stream_handle.readline()\n\n # loop over all lines in the data file\n while line:\n\n if EMPTY_LINE_MATCHER.match(line):\n # ignore blank lines, do nothing\n pass\n\n elif HEADER_MATCHER.match(line):\n\n # we need header records to extract useful information\n for matcher in HEADER_MATCHER_LIST:\n header_match = matcher.match(line)\n\n if header_match is not None:\n\n # Look for specific header lines and extract header fields\n if matcher is DIR_FREQ_MATCHER:\n num_dir = int(header_match.group(1))\n num_freq = int(header_match.group(2))\n\n elif matcher is FREQ_BAND_MATCHER:\n freq_w_band = header_match.group(1)\n freq_0 = header_match.group(2)\n\n elif matcher is START_DIR_MATCHER:\n start_dir = header_match.group(1)\n\n else:\n #ignore\n pass\n\n elif DSPEC_DATA_MATCHER.match(line):\n\n # Extract a row of the Directional Surface Spectrum matrix\n sensor_match = DSPEC_DATA_MATCHER.match(line)\n data = sensor_match.group(1)\n values = [int(x) for x in data.split()]\n\n num_values = len(values)\n\n # If the number of values in a line of data doesn't match num_dir,\n # Drop the record, throw a recoverable exception and continue parsing\n if num_values != num_dir:\n error_message = 'Unexpected Number of directions in line: expected %s, got %s'\\\n % (num_dir, num_values)\n log.warn(error_message)\n self._exception_callback(RecoverableSampleException(error_message))\n else:\n # Add the row to the dspec matrix\n dspec_matrix.append(values)\n\n else:\n # Generate a warning for unknown data\n error_message = 'Unexpected data found in line %s' % line\n log.warn(error_message)\n self._exception_callback(RecoverableSampleException(error_message))\n\n # read the next line in the file\n line = self._stream_handle.readline()\n\n # Check to see if the specified number of frequencies were retrieved from the data\n dspec_matrix_length = len(dspec_matrix)\n if dspec_matrix_length != num_freq:\n error_message = 'Unexpected Number of frequencies in DSpec Matrix: expected %s, got %s'\\\n % (num_freq, dspec_matrix_length)\n log.warn(error_message)\n self._exception_callback(RecoverableSampleException(error_message))\n\n # Construct the parsed data list to hand over to the Data Particle class for particle creation\n parsed_data = [\n file_time, # ('file_time', 0, str),\n num_dir, # ('num_dir', 1, int),\n num_freq, # ('num_freq', 2, int),\n freq_w_band, # ('freq_w_band', 3, float),\n freq_0, # ('freq_0', 4, float),\n start_dir, # ('start_dir', 5, float),\n dspec_matrix # ('directional_surface_spectrum', 6, list)]\n ]\n\n # Extract a particle and append it to the record buffer\n particle = self._extract_sample(AdcptMDspecInstrumentDataParticle, None, parsed_data)\n self._record_buffer.append(particle)","def process_spike_sim_log(spike_log, csv):\n logging.info(\"Processing spike log : %s\" % spike_log)\n instr_cnt = 0\n spike_instr = \"\"\n\n RD_RE = re.compile(r\"(?P<pri>\\d) 0x(?P<addr>[a-f0-9]+?) \" \\\n \"\\((?P<bin>.*?)\\) x\\s*(?P<reg>\\d*?) 0x(?P<val>[a-f0-9]+)\")\n CORE_RE = re.compile(r\"core.*0x(?P<addr>[a-f0-9]+?) \\(0x(?P<bin>.*?)\\) (?P<instr>.*?)$\")\n INSTR_RE = re.compile(r\"(?P<instr>[a-z\\.]+?)(\\s+?)(?P<operand>.*)\")\n GPR_RE = re.compile(r\"^[a-z][0-9a-z]$\")\n CSR_RE = re.compile(r\"csr\")\n ILLE_RE = re.compile(r\"trap_illegal_instruction\")\n\n # Remove all the init spike boot instructions\n cmd = (\"sed -i '/core.*0x0000000000001010/,$!d' %s\" % spike_log)\n os.system(cmd)\n # Remove all instructions after ecall (end of program excecution)\n cmd = (\"sed -i '/ecall/q' %s\" % spike_log)\n os.system(cmd)\n\n gpr = {}\n gpr[\"zero\"] = 0\n\n with open(spike_log, \"r\") as f, open(csv, \"w\") as csv_fd:\n trace_csv = RiscvInstructiontTraceCsv(csv_fd)\n trace_csv.start_new_trace()\n for line in f:\n # Extract instruction infromation\n m = CORE_RE.search(line)\n if m:\n spike_instr = m.group(\"instr\")\n rv_instr_trace = RiscvInstructiontTraceEntry()\n rv_instr_trace.instr_str = spike_instr\n rv_instr_trace.addr = m.group(\"addr\")\n rv_instr_trace.binary = m.group(\"bin\")\n if spike_instr == \"wfi\":\n trace_csv.write_trace_entry(rv_instr_trace)\n continue\n nextline = f.readline()\n if nextline != \"\":\n if ILLE_RE.search(nextline):\n continue\n m = RD_RE.search(nextline)\n if m:\n # Extract RD information\n instr_cnt += 1\n rv_instr_trace.rd = gpr_to_abi(\"x%0s\" % m.group(\"reg\"))\n rv_instr_trace.rd_val = m.group(\"val\")\n rv_instr_trace.privileged_mode = m.group(\"pri\")\n gpr[rv_instr_trace.rd] = rv_instr_trace.rd_val\n s = INSTR_RE.search(spike_instr)\n if s:\n rv_instr_trace.instr = s.group(\"instr\")\n operand_str = s.group(\"operand\").replace(\" \", \"\")\n if operand_str != \"\" :\n operands = operand_str.split(\",\")\n if CSR_RE.search(s.group(\"instr\")):\n # CSR instruction\n operand = operands[-1]\n if GPR_RE.search(operand) or operand == \"zero\":\n rv_instr_trace.rs1 = operand\n rv_instr_trace.rs1_val = gpr[operand]\n else:\n rv_instr_trace.imm = operand\n else:\n # Non CSR instruction\n for i in range(1, len(operands)):\n operand = operands[i]\n if GPR_RE.search(operand) or operand == \"zero\":\n if i == 1:\n rv_instr_trace.rs1 = operand\n rv_instr_trace.rs1_val = gpr[operand]\n else:\n rv_instr_trace.rs2 = operands[i]\n rv_instr_trace.rs2_val = gpr[operand]\n else:\n rv_instr_trace.imm = operand\n trace_csv.write_trace_entry(rv_instr_trace)\n logging.info(\"Processed instruction count : %d\" % instr_cnt)","def flush_parse_initialize(self):\n self.current_cluster = 0\n self.current_frequency_of_clusters = []\n self.timestamp = []\n self.currentstates_of_clusters = []\n self.state_time_map = {}\n self.cpuid_time_map = {}\n self.cpu_freq_time_spent = {}\n self.cpuids_of_clusters = []\n self.parse() # Parse trace.txt generated from trace-cmd instrumentation\n # Initialize the states of each core of clusters and frequency of\n # each clusters with its minimum freq\n # cpu_id is assigned for each of clusters.\n # For IKS devices cpuid remains same in other clusters\n # and for other it will increment by 1\n count = 0\n for cluster, cores_number in enumerate(self.numberofcores_in_cluster):\n self.currentstates_of_clusters.append([-1 for dummy in range(cores_number)])\n self.current_frequency_of_clusters.append(self.minimum_frequency_cluster[cluster])\n if self.device.scheduler == 'iks':\n self.cpuids_of_clusters.append([j for j in range(cores_number)])\n else:\n self.cpuids_of_clusters.append(range(count, count + cores_number))\n count += cores_number\n\n # Initialize the time spent in each state/frequency for each core.\n for i in range(self.device.number_of_cores * self.multiply_factor):\n self.cpu_freq_time_spent[\"cpu{}\".format(i)] = {}\n for j in self.unique_freq():\n self.cpu_freq_time_spent[\"cpu{}\".format(i)][j] = 0\n # To determine offline -1 state is added\n offline_value = -1\n self.cpu_freq_time_spent[\"cpu{}\".format(i)][offline_value] = 0\n if 0 not in self.unique_freq():\n self.cpu_freq_time_spent[\"cpu{}\".format(i)][0] = 0","def run(self):\n\t\tdf_iter = self.file_to_df(50000)\n\t\tdf_airport = self.airport_file_to_df()\n\t\tfor df in df_iter: # type: pd.DataFrame\n\t\t\tdf.drop_duplicates(inplace=True)\n\t\t\tdf = self.transform(df, df_airport)\n\n\t\t\tdf_result = self.get_only_new_records(\n\t\t\t\tdf=df,\n\t\t\t\tdf_columns=self.join_columns,\n\t\t\t\ttable_columns=self.join_columns\n\t\t\t)\n\n\t\t\tif len(df_result) > 0:\n\t\t\t\t# df_result.drop(self.table_columns, axis=1)\n\n\t\t\t\tself.save(\n\t\t\t\t\tdf=df_result,\n\t\t\t\t\ttable_name=\"travel_dimension\",\n\t\t\t\t\tdf_columns=self.table_columns,\n\t\t\t\t\ttable_colums=self.table_columns\n\t\t\t\t)","def writeRawFCD():\n global vehId, vehIdDict\n vehIdDict = {}\n vehId = 0\n day = 0\n\n def getVehId(orgId):\n \"\"\"creates new vehicle id's which consists only numerics\"\"\"\n global vehId, vehIdDict\n value = vehIdDict.get(orgId, vehId)\n if value is vehId:\n vehIdDict[orgId] = vehId\n vehId = (vehId + 1) % 65500\n return value\n\n outputFile = open(path.FQrawFCD, 'w')\n\n for period, quota, vtypeDictR, taxiSum in generatePeriodQuotaSets():\n day += 86400\n # reset dict so that every taxi (even if the vehicle is chosen several\n # times) gets its own id\n vehIdDict = {}\n # dataset=0\n sortedKeys = vtypeDictR.keys()\n sortedKeys.sort()\n for timestep in sortedKeys:\n taxiList = vtypeDictR[timestep]\n for tup in taxiList: # all elements in this timestep\n # calc timestep ->for every period /quota set a new day\n time = timestep + day\n time = calcTime.getDateFromDepart(time)\n # dataset+=1\n # print ouptut\n # veh_id date (time to simDate+time) x (remove and\n # set comma new)\n outputFile.write(str(getVehId(tup[0])) + '\\t' + time + '\\t' + tup[3][0:2] + '.' + tup[3][2:7] + tup[3][8:] +\n # y (remove and set comma new)\n # status speed form m/s in km/h\n '\\t' + tup[4][0:2] + '.' + tup[4][2:7] + tup[4][8:] + '\\t' + \"90\" + '\\t' + str(int(round(tup[2] * 3.6))) + '\\n')\n # print dataset, time\n print(vehId)\n outputFile.close()","def readOptimizationResultsFile(self):\n requiredLineNo = 0\n self.createParamters()\n \n self.optimizationResultsFile = open(self.fileName, 'r')\n \n for lineIndex, line in enumerate(self.optimizationResultsFile):\n if lineIndex == 0:\n startingPhase1, startingPhase2 = line.split()\n self.startingPhase1, self.startingPhase2 = int(startingPhase1), int(startingPhase2)\n\n elif lineIndex == 1:\n init1, init2, elapsedGreen1, elapsedGreen2 = line.split()\n self.init1, self.init2 = float(init1), float(init2)\n\n elif lineIndex == 2:\n self.processPhaseDuration(line, self.leftCriticalPointsRing1, self.leftCriticalPointsRing2)\n self.processPhaseSequence()\n\n elif lineIndex == 3:\n self.processPhaseDuration(line, self.leftCriticalPointsRing1, self.leftCriticalPointsRing2)\n self.processPhaseSequence()\n\n elif lineIndex == 4:\n self.processPhaseDuration(line, self.leftCriticalPointsRing1, self.leftCriticalPointsRing2)\n self.processPhaseSequence()\n\n elif lineIndex == 5:\n self.processPhaseDuration(line, self.rightCriticalPointsRing1, self.rightCriticalPointsRing2)\n\n elif lineIndex == 6:\n self.processPhaseDuration(line, self.rightCriticalPointsRing1, self.rightCriticalPointsRing2)\n\n elif lineIndex == 7:\n self.processPhaseDuration(line, self.rightCriticalPointsRing1, self.rightCriticalPointsRing2)\n\n elif lineIndex == 14:\n noOfRequest = int(line)\n requiredLineNo = 15 + noOfRequest\n # break\n \n elif lineIndex >=15 and lineIndex < requiredLineNo:\n self.getPriorityRequests(line)\n \n elif lineIndex >=15 and lineIndex >= requiredLineNo:\n break\n # self.optimizationResultsFile = open(self.fileName, 'r')\n # for i, line in enumerate(self.optimizationResultsFile):\n # if i in range(15, requiredLineNo):\n\n self.optimizationResultsFile.close()\n # self.getPriorityRequests(requiredLineNo)\n \n self.getCummulativeValues()\n self.generateTimePhaseDiagram()","def run():\n\n import matplotlib.pyplot as plt\n\n anomalies_t = []\n anomalies_v = []\n anomalies_c = []\n\n all_t = []\n all_v = []\n\n rows = []\n for i, row in dataSet.iterrows():\n\n inputData = row.to_dict()\n\n detectorValues = handleRecord(inputData)\n\n if (detectorValues[0] > 0.65):\n anomalies_t.append(inputData[\"timestamp\"])\n anomalies_v.append(inputData[\"value\"])\n anomalies_c.append(detectorValues[0])\n\n all_t.append(inputData[\"timestamp\"])\n all_v.append(inputData[\"value\"])\n\n outputRow = list(row) + list(detectorValues)\n\n rows.append(outputRow)\n\n # Progress report\n if (i % 1000) == 0:\n print \".\",\n sys.stdout.flush()\n\n fig, ax = plt.subplots()\n\n ax.plot(all_t, all_v)\n ax.plot(anomalies_t, anomalies_v, 'ro')\n\n plt.show()\n\n ans = pandas.DataFrame(rows)\n return ans","def _read_trajectory_files(self):\n dflist = []\n self.Ntimes = {}\n for downD in self.case.downstreamD:\n outputs = self.case.get_outputs(self.method,downD)\n print(outputs['trajectory_file'])\n df = pd.read_csv(outputs['trajectory_file'],\n header=None,\n usecols=[0,1,2])\n df.columns = ['t','y','z']\n df['x'] = downD * self.case.turbine.D\n df['z'] -= self.case.turbine.zhub\n df = df.set_index(['t','x'])[['y','z']]\n self.Ntimes[downD] = len(df.index.levels[0])\n dflist.append(df)\n self.df = pd.concat(dflist).sort_index()","def run_analysis(self):\n ### skip some snapshots for testing purposes\n nskip = 199\n read_char.skip_snapshots(self.hfile, self.ifile, nskip)\n ### read in the first two steps (required for velocity related computations\n xs_old, ys_old, lx_old, ly_old, tstep_old, natoms_old = read_char.read_snapshot(self.hfile, self.ifile)\n x_old = xs_old*lx_old\n y_old = ys_old*ly_old\n xs,ys,lx,ly,tstep,natoms = read_char.read_snapshot(self.hfile, self.ifile)\n x = xs*lx\n y = ys*ly\n ### loop over all steps of the input file\n for step in range(nskip+1,self.nsteps-1):\n print step\n ### read in coordinates (as required)\n xs_new,ys_new,lx_new,ly_new,tstep_new,natoms_new = read_char.read_snapshot(self.hfile, self.ifile)\n x_new = xs_new*lx_new\n y_new = ys_new*ly_new\n ### compute further current per/atom quantities\n phi = misc_tools.compute_orientation(x,y,lx,ly,self.npol)\n vx,vy = misc_tools.compute_velocity(x_old,y_old, x_new, y_new, lx, ly, tstep_old, tstep_new, natoms)\n ### start desired analysis methods\n # density\n if self.density_flag:\n self.density.compute(step,x,y,lx,ly,natoms, plot = 'False')\n # number fluctuations\n if self.nf_flag:\n self.numberfluctuation.compute(step,xs,ys, plot = 'False')\n # voronoi density\n if self.voronoi_flag:\n self.voronoidensity.compute(step,x,y,lx,ly,natoms, plot = 'False')\n # velocity / worticity\n if self.velocity_flag:\n self.velocityworticity.compute(step,x,y,vx,vy,natoms,lx,ly, plot = 'False')\n # orientation / velocity\n if self.orientvel_flag:\n self.orientvel.compute(step,x,y,vx,vy,phi,natoms, plot = 'False')\n # defect points\n if self.pointdefects_flag:\n self.pointdefects.compute(step,x,y,phi,lx,ly,natoms)\n ### move coordinate arrays\n xs_old = np.copy(xs)\n ys_old = np.copy(ys)\n x_old = np.copy(x)\n y_old = np.copy(y)\n tstep_old = tstep\n xs = np.copy(xs_new)\n ys = np.copy(ys_new)\n x = np.copy(x_new)\n y = np.copy(y_new)\n tstep = tstep_new\n return","def run(self, d):\n\n feeds,feedidx,_ = self.getFeeds(d,'all')\n\n tod_shape = d[f'{self.level2}/averaged_tod'].shape\n \n scanedges = d[f'{self.level2}/Statistics/scan_edges'][...]\n nfeeds = 20\n nchannels = 8\n \n self.all_tod = np.zeros((20, nchannels, tod_shape[-1])) \n self.all_weights = np.zeros((20, nchannels, tod_shape[-1])) \n self.all_frequency = np.zeros((nchannels)) \n self.all_auto = np.zeros((20,nchannels)) \n self.all_mask = np.zeros((20,tod_shape[-1]))\n self.all_cal_factors = np.zeros((20,4,64))\n # Read in data from each feed\n for ifeed,feed in enumerate(tqdm(feeds,desc='Looping over feeds')):\n if feeds[ifeed] == 20:\n continue\n feed_tod,feed_weights,mask = self.clean_tod(d,ifeed,feed)\n\n if self.astro_cal:\n feed_tod,feed_weights,cal_factors = self.calibrate_tod(d,feed_tod,feed_weights,ifeed,feed)\n else:\n cal_factors = 1\n\n self.all_tod[feed-1],self.all_weights[feed-1], self.all_auto[feed-1], self.all_frequency = self.average_tod(d,feed_tod,feed_weights,mask) \n self.all_mask[feed-1] = mask\n self.all_cal_factors[feed-1] = cal_factors","def post_process(self, filename):\n title = self.title\n\n outfile = open(filename, 'r')\n data = outfile.readlines()\n\n name = data[0].strip()\n mode = data[1].strip()\n ops = data[2].strip().split(',')\n nl = 'True' in ops[0]\n ln = 'True' in ops[1]\n drv = 'True' in ops[2]\n\n data = data[3:]\n npt = len(data)\n\n t1u = np.empty((npt, ))\n t3u = np.empty((npt, ))\n t5u = np.empty((npt, ))\n flag = np.empty((npt, ), dtype=np.bool)\n x_dv = np.empty((npt, ))\n x_state = np.empty((npt, ))\n x_proc = np.empty((npt, ))\n\n for j, line in enumerate(data):\n x_dv[j], x_state[j], x_proc[j], flag[j], t1u[j], t3u[j], t5u[j] = line.strip().split(',')\n\n if np.any(flag):\n use_flag = True\n else:\n use_flag = False\n\n # Times are all normalized.\n t1 = t1u/t1u[0]\n t3 = t3u/t3u[0]\n t5 = t5u/t5u[0]\n\n if mode == 'state':\n x = x_state\n xlab = \"Number of states.\"\n elif mode == 'desvar':\n xlab = \"Number of design vars.\"\n x = x_dv\n elif mode == 'proc':\n x = x_proc\n xlab = \"Number of processors.\"\n\n if use_flag:\n\n flagtxt = self.flagtxt\n\n # Split them up. We know the pattern.\n t1F = t1[0::2]\n t1T = t1[1::2]\n t3F = t3[0::2]\n t3T = t3[1::2]\n t5F = t5[0::2]\n t5T = t5[1::2]\n\n xT = x[0::2]\n xF = x[1::2]\n\n # Generate plots\n\n if nl:\n plt.figure(1)\n plt.loglog(xF, t1F, 'bo-')\n plt.loglog(xT, t1T, 'ro-')\n\n plt.xlabel(xlab)\n plt.ylabel('Nonlinear Solve: Normalized Time')\n plt.title(title)\n plt.grid(True)\n if self.equal_axis:\n plt.axis('equal')\n plt.legend(['Default', flagtxt], loc=0)\n plt.savefig(\"%s_%s_%s.png\" % (name, mode, 'nl'))\n\n if ln:\n plt.figure(2)\n plt.loglog(xF, t3F, 'o-')\n plt.loglog(xT, t3T, 'ro-')\n\n plt.xlabel(xlab)\n plt.ylabel('Compute Totals: Normalized Time')\n plt.title(title)\n plt.grid(True)\n if self.equal_axis:\n plt.axis('equal')\n plt.legend(['Default', flagtxt], loc=0)\n plt.savefig(\"%s_%s_%s.png\" % (name, mode, 'ln'))\n\n if drv:\n plt.figure(3)\n plt.loglog(xF, t5F, 'o-')\n plt.loglog(xT, t5T, 'ro-')\n\n plt.xlabel(xlab)\n plt.ylabel(self.title_driver + ': Normalized Time')\n plt.title(title)\n plt.grid(True)\n if self.equal_axis:\n plt.axis('equal')\n plt.legend(['Default', flagtxt], loc=0)\n plt.savefig(\"%s_%s_%s.png\" % (name, mode, 'drv'))\n\n if self.special_plot_driver_on_linear:\n\n # Plot whatever driver does (e.g., coloring) on the same axis and normalization as linear time.\n t5 = t5u/t3u[0]\n t5F = t5[0::2]\n t5T = t5[1::2]\n\n plt.figure(4)\n plt.loglog(xF, t3F, 'o-')\n plt.loglog(xT, t3T, 'ro-')\n plt.loglog(xT, t5T, 'mo-')\n\n plt.xlabel(xlab)\n plt.ylabel('Normalized Time')\n plt.title(title)\n plt.grid(True)\n if self.equal_axis:\n plt.axis('equal')\n plt.legend(['Compute Totals', 'Compute Totals: ' + flagtxt, self.title_driver], loc=0)\n plt.savefig(\"%s_%s_%s.png\" % (name, mode, 'spec1'))\n\n else:\n\n # Generate plots\n\n if nl:\n plt.figure(1)\n plt.loglog(x, t1, 'o-')\n\n plt.xlabel(xlab)\n plt.ylabel('Nonlinear Solve: Normalized Time')\n plt.title(title)\n plt.grid(True)\n if self.equal_axis:\n plt.axis('equal')\n plt.savefig(\"%s_%s_%s.png\" % (name, mode, 'nl'))\n\n if ln:\n plt.figure(2)\n plt.loglog(x, t3, 'o-')\n\n plt.xlabel(xlab)\n plt.ylabel('Compute Totals: Normalized Time')\n plt.title(title)\n plt.grid(True)\n if self.equal_axis:\n plt.axis('equal')\n plt.savefig(\"%s_%s_%s.png\" % (name, mode, 'ln'))\n\n # For procs, we also view the time/proc as a function of number of procs.\n if mode == 'proc':\n plt.figure(3)\n plt.loglog(x, t3/x, 'o-')\n\n plt.xlabel(xlab)\n plt.ylabel('Compute Totals: Normalized Time per Processor')\n plt.title(title)\n plt.grid(True)\n if self.equal_axis:\n plt.axis('equal')\n plt.savefig(\"%s_%s_%s_per_proc.png\" % (name, mode, 'ln'))\n\n plt.show()\n print('done')","def start_new_trace(self):\n fields = [\"instr\", \"rd\", \"rd_val\", \"rs1\", \"rs1_val\", \"rs2\", \"rs2_val\",\n \"imm\", \"str\", \"addr\", \"binary\", \"csr\", \"mode\"]\n self.csv_writer = csv.DictWriter(self.csv_fd, fieldnames=fields)\n self.csv_writer.writeheader()","def process_file(self):\n self._processing_logger.log_info('Start processing')\n self.parsing_start_time = datetime.datetime.now()\n if os.path.exists(self.tmp_stat_file_path) \\\n and not HcsParsingUtils.active_processing_exceed_timeout(self.tmp_stat_file_path):\n self._processing_logger.log_info('This file is processed by another parser, skipping...')\n return 2\n self.create_tmp_stat_file()\n hcs_index_file_path = self.hcs_root_dir + MEASUREMENT_INDEX_FILE_PATH\n time_series_details = self._extract_time_series_details(hcs_index_file_path)\n self.generate_ome_xml_info_file()\n xml_info_tree = ET.parse(self.ome_xml_info_file_path).getroot()\n plate_width, plate_height = self._get_plate_configuration(xml_info_tree)\n wells_tags = self.read_wells_tags()\n if wells_tags:\n self._processing_logger.log_info(\"Tags \" + str(wells_tags))\n if not TAGS_PROCESSING_ONLY and not EVAL_PROCESSING_ONLY:\n if not self._localize_related_files():\n self._processing_logger.log_info('Some errors occurred during copying files from the bucket, exiting...')\n return 1\n else:\n self._processing_logger.log_info('Localization is finished.')\n local_preview_dir = os.path.join(self.tmp_local_dir, 'preview')\n hcs_local_index_file_path = get_path_without_trailing_delimiter(self.tmp_local_dir) \\\n + MEASUREMENT_INDEX_FILE_PATH\n for sequence_id, timepoints in time_series_details.items():\n self._processing_logger.log_info('Processing sequence with id={}'.format(sequence_id))\n sequence_index_file_path = self.extract_sequence_data(sequence_id, hcs_local_index_file_path)\n conversion_result = os.system('bash \"{}\" \"{}\" \"{}\" {}'.format(\n OME_TIFF_SEQUENCE_CREATION_SCRIPT, sequence_index_file_path, local_preview_dir, sequence_id))\n if conversion_result != 0:\n self._processing_logger.log_info('File processing was not successful...')\n return 1\n sequence_overview_index_file_path, wells_grid_mapping = self.build_sequence_overview_index(sequence_index_file_path)\n conversion_result = os.system('bash \"{}\" \"{}\" \"{}\" {} \"{}\"'.format(\n OME_TIFF_SEQUENCE_CREATION_SCRIPT, sequence_overview_index_file_path, local_preview_dir,\n sequence_id, 'overview_data.ome.tiff'))\n if conversion_result != 0:\n self._processing_logger.log_info('File processing was not successful: well preview generation failure')\n return 1\n self.write_dict_to_file(os.path.join(local_preview_dir, sequence_id, 'wells_map.json'),\n self.build_wells_map(sequence_id, wells_grid_mapping, wells_tags))\n if LOCALIZE_USE_PIPE == \"true\":\n cloud_transfer_result = os.system('pipe storage cp -f -r \"{}\" \"{}\"'\n .format(local_preview_dir,\n HcsParsingUtils.extract_cloud_path(self.hcs_img_service_dir)))\n else:\n cloud_transfer_result = os.system('aws s3 sync \"{}\" \"{}\"'\n .format(local_preview_dir,\n HcsParsingUtils.extract_cloud_path(self.hcs_img_service_dir)))\n if cloud_transfer_result != 0:\n self._processing_logger.log_info('Results transfer was not successful...')\n return 1\n self._write_hcs_file(time_series_details, plate_width, plate_height)\n if not EVAL_PROCESSING_ONLY:\n tags_processing_result = self.try_process_tags(xml_info_tree, wells_tags)\n if TAGS_PROCESSING_ONLY:\n if wells_tags:\n for sequence_id, timepoints in time_series_details.items():\n path = os.path.join(self.hcs_img_service_dir, sequence_id, 'wells_map.json')\n self.write_dict_to_file(path, self.update_wells_json(path, wells_tags))\n return tags_processing_result\n if not TAGS_PROCESSING_ONLY:\n eval_processing_result = self.try_process_eval()\n if EVAL_PROCESSING_ONLY:\n return eval_processing_result\n self.create_stat_file()\n return 0","def read_tracers(datadir = 'data/', fileName = 'tracers.dat', zlim = [], head_size = 3, post = False):\n \n class data_struct:\n def __init__(self):\n self.xi = []\n self.yi = []\n self.xf = []\n self.yf = []\n self.zf = []\n self.l = []\n self.q = []\n\n data = []\n data = data_struct()\n\n # compute the offset in order to skip Fortran's header byte\n if (post):\n head_size = 0\n off = 2\n if (head_size == 3):\n off = 2\n if (head_size == 5):\n off = 3\n\n # read the cpu structure\n dim = pc.read_dim(datadir = datadir)\n if (dim.nprocz > 1):\n print(\": number of cores in z-direction > 1\")\n return -1\n\n # read the parameters\n params = pc.read_param(datadir = datadir, quiet = True)\n\n # read the grid\n grid = pc.read_grid(datadir = datadir, quiet = True)\n\n # determine the file structure\n if (post):\n n_proc = 1\n tracer_file = open(datadir+fileName, 'rb')\n trace_sub = struct.unpack(\"f\", tracer_file.read(4))[0]\n tracer_file.close()\n n_times = int((os.path.getsize(datadir+fileName)-4)/(4*7*int(dim.nx*trace_sub)*int(dim.ny*trace_sub)))\n # sub sampling of the tracers\n if (not(post)):\n n_proc = dim.nprocx*dim.nprocy\n trace_sub = params.trace_sub\n n_times = int(os.path.getsize(datadir+'proc0/'+fileName)/(4*(head_size + 7*np.floor(dim.nx*trace_sub)*np.floor(dim.ny*trace_sub)/dim.nprocx/dim.nprocy)))\n\n # prepare the output arrays\n tracers = np.zeros((int(dim.nx*trace_sub), int(dim.ny*trace_sub), n_times, 7))\n mapping = np.zeros((int(dim.nx*trace_sub), int(dim.ny*trace_sub), n_times, 3))\n\n # temporary arrays for one core\n if (post):\n tracers_core = tracers\n mapping_core = mapping\n else:\n tracers_core = np.zeros((int(int(dim.nx*trace_sub)/dim.nprocx), int(int(dim.ny*trace_sub)/dim.nprocy), n_times, 7))\n mapping_core = np.zeros((int(int(dim.nx*trace_sub)/dim.nprocx), int(np.floor(dim.ny*trace_sub)/dim.nprocy), n_times, 3))\n\n # set the upper z-limit to the domain boundary\n if zlim == []:\n zlim = grid.z[-dim.nghostz-1]\n\n # read the data from all cores\n for i in range(n_proc):\n # read the cpu structure\n if (post):\n dim_core = pc.read_dim(datadir = datadir, proc = -1)\n dim_core.ipx = 0\n dim_core.ipy = 0\n else:\n dim_core = pc.read_dim(datadir = datadir, proc = i)\n stride = int(dim_core.nx*trace_sub)*int(dim_core.ny*trace_sub)\n llen = head_size + 7*stride + post\n\n if (post):\n tracer_file = open(datadir+fileName, 'rb')\n else:\n tracer_file = open(datadir+'proc{0}/'.format(i)+fileName, 'rb')\n tmp = array.array('f')\n tmp.read(tracer_file, int((head_size + post + 7*int(dim_core.nx*trace_sub)*int(dim_core.ny*trace_sub))*n_times)+post)\n tracer_file.close()\n\n t = []\n\n for j in range(n_times):\n t.append(tmp[off-1+j*llen])\n data.xi = tmp[off+j*llen : off+1*stride+j*llen]\n data.yi = tmp[off+1*stride+j*llen : off+2*stride+j*llen]\n data.xf = tmp[off+2*stride+j*llen : off+3*stride+j*llen]\n data.yf = tmp[off+3*stride+j*llen : off+4*stride+j*llen]\n data.zf = tmp[off+4*stride+j*llen : off+5*stride+j*llen]\n data.l = tmp[off+5*stride+j*llen : off+6*stride+j*llen]\n data.q = tmp[off+6*stride+j*llen : off+7*stride+j*llen]\n\n # Squeeze the data into 2d array. This make the visualization much faster.\n for l in range(len(data.xi)):\n tracers_core[l%(int(dim_core.nx*trace_sub)),int(l/(int(dim_core.nx*trace_sub))),j,:] = \\\n [data.xi[l], data.yi[l], data.xf[l], data.yf[l], data.zf[l], data.l[l], data.q[l]]\n if data.zf[l] >= zlim:\n if (data.xi[l] - data.xf[l]) > 0:\n if (data.yi[l] - data.yf[l]) > 0:\n mapping_core[l%(int(dim_core.nx*trace_sub)),int(l/(int(dim_core.nx*trace_sub))),j,:] = [0,1,0]\n else:\n mapping_core[l%(int(dim_core.nx*trace_sub)),int(l/(int(dim_core.nx*trace_sub))),j,:] = [1,1,0]\n else:\n if (data.yi[l] - data.yf[l]) > 0:\n mapping_core[l%(int(dim_core.nx*trace_sub)),int(l/(int(dim_core.nx*trace_sub))),j,:] = [0,0,1]\n else:\n mapping_core[l%(int(dim_core.nx*trace_sub)),int(l/(int(dim_core.nx*trace_sub))),j,:] = [1,0,0]\n else:\n mapping_core[l%(int(dim_core.nx*trace_sub)),int(l/(int(dim_core.nx*trace_sub))),j,:] = [1,1,1]\n\n # copy single core data into total data arrays\n if (not(post)):\n tracers[np.round(dim_core.ipx*int(dim_core.nx*trace_sub)):np.round((dim_core.ipx+1)*np.floor(dim_core.nx*trace_sub)), \\\n np.round(dim_core.ipy*int(dim_core.ny*trace_sub)):np.round((dim_core.ipy+1)*np.floor(dim_core.ny*trace_sub)),j,:] = \\\n tracers_core[:,:,j,:]\n mapping[np.round(dim_core.ipx*int(dim_core.nx*trace_sub)):np.round((dim_core.ipx+1)*np.floor(dim_core.nx*trace_sub)), \\\n np.round(dim_core.ipy*int(dim_core.ny*trace_sub)):np.round((dim_core.ipy+1)*np.floor(dim_core.ny*trace_sub)),j,:] = \\\n mapping_core[:,:,j,:]\n\n # swap axes for post evaluation\n tracers = tracers.swapaxes(0, 1)\n mapping = mapping.swapaxes(0, 1)\n\n return tracers, mapping, t","def createOutput():\n\n firstPeriod = True\n # get edge No\n edgesNo = 0\n edgesSet = set()\n for timestep, taxiList in vtypeDict.iteritems():\n for tup in taxiList:\n edgesSet.add(tup[1])\n edgesNo = len(edgesSet)\n\n outputFile = open(path.FQoutput, 'w')\n outputFile.write('<?xml version=\"1.0\"?>\\n')\n outputFile.write('<paramEffects aggregationInterval=\"%d\" vehicles=\"%d\" edges=\"%d\">\\n' % (\n aggInterval, vehSum, edgesNo))\n for period, quota, vtypeDictR, taxiSum in generatePeriodQuotaSets(True):\n if quota is None:\n if not firstPeriod:\n outputFile.write(\"\\t</periods>\\n\")\n else:\n firstPeriod = False\n outputFile.write('\\t<periods period=\"%d\">\\n' % (period))\n else:\n simpleTaxiMeanVList = [0, 1]\n simpleEdgeMeanVList = [0, 1]\n drivenEdgesSet = set()\n\n if len(vtypeDictR) == 0: # if the processed FCD returns no Values\n print(\"noData p\", period, \" q\", quota)\n drivenEdgesSet.add(0)\n else: # create mean from all taxi speed values\n for timestep, taxiList in vtypeDictR.iteritems():\n for tup in taxiList: # all elements in this timestep\n simpleTaxiMeanVList[0] += tup[2]\n simpleTaxiMeanVList[1] += 1\n drivenEdgesSet.add(tup[1])\n # create mean from all edge speed values which are driven by the\n # chosen taxis\n drivenEdgesList = list(drivenEdgesSet)\n drivenEdgesList.sort()\n # print \"dataSets \",simpleTaxiMeanVList[1]\n\n # --edgeDump-- #\n \"\"\"\n for i in edgeDumpDict.keys(): #all intervals\n for edge,v in edgeDumpDict[i]:\n if BinarySearch.isElmInList(drivenEdgesList,edge):\n simpleEdgeMeanVList[0]+=v\n simpleEdgeMeanVList[1]+=1\n \"\"\"\n # --vtype-- #\n\n for timestep, taxiList in vtypeDict.iteritems():\n for tup in taxiList:\n if BinarySearch.isElmInList(drivenEdgesList, tup[1]):\n simpleEdgeMeanVList[0] += tup[2]\n simpleEdgeMeanVList[1] += 1\n\n # calc values for output\n detectedEdges = len(drivenEdgesSet)\n relDetectedEdges = detectedEdges * 100.0 / edgesNo\n vSim = simpleEdgeMeanVList[0] / simpleEdgeMeanVList[1]\n vSimFCD = simpleTaxiMeanVList[0] / simpleTaxiMeanVList[1]\n vAbsDiff = vSimFCD - vSim\n if vSim != 0:\n vRelDiff = vAbsDiff / vSim * 100\n else:\n vRelDiff = 100\n if vRelDiff < -40:\n vRelDiff = -35\n\n outputFile.write('\\t\\t<values taxiQuota=\"%f\" taxis=\"%d\" simMeanSpeed=\"%f\" simFcdMeanSpeed=\"%f\" ' % (\n quota, taxiSum, vSim, vSimFCD,))\n outputFile.write('detectedEdges=\"%d\" notDetectedEdges=\"%d\" ' % (\n detectedEdges, edgesNo - detectedEdges))\n outputFile.write('absSpeedDiff=\"%f\" relSpeedDiff=\"%f\" relDetectedEdges=\"%f\" relNotDetectedEdges=\"%f\"/>\\n' %\n (vAbsDiff, vRelDiff, relDetectedEdges, 100 - relDetectedEdges))\n outputFile.write(\"\\t</periods>\\n</paramEffects>\")\n outputFile.close()","def process_csv(self):\n with open(self.filepath, mode=\"r\") as csv_file:\n csv_reader = csv.reader(csv_file, delimiter=\",\")\n header = next(csv_reader)\n\n date_idx = self._get_header_position(header, \"Label\")\n power_idx = self._get_header_position(header, \"kW\")\n\n if self.inverter_id not in header[power_idx]:\n raise Exception(\"Inverter data returned for the incorrect meter.\")\n\n for row in csv_reader:\n date_obj = self.csv_str_to_date(row[date_idx])\n power = float(row[power_idx] or 0)\n\n current_date = self.date_to_final_str(date_obj)\n rounded_time = self.round_up_to_quarter_hour(date_obj)\n\n if current_date not in self.intermediate_readings:\n self.intermediate_readings[\n current_date\n ] = self.build_intermediate_dict()\n\n current_reading = self.intermediate_readings[current_date][rounded_time]\n # Here's where we sum power readings together - in to fifteen min intervals\n self.intermediate_readings[current_date][rounded_time] = (\n current_reading + power\n )\n\n actual_time = self.date_to_intermediate_time_str(date_obj)\n if rounded_time == actual_time:\n # Here's where we average power readings together, in fifteen minute intervals\n self.intermediate_readings[current_date][rounded_time] = round(\n float(\n self.intermediate_readings[current_date][rounded_time] / 3\n ),\n 2,\n )\n\n return self.finalize_readings()","def ddf_parser():\n num_available, total = 0, 0\n indicator_twn_tuples = list() # format of a single tuple: (indicator_name, #twn rows, earliest available year)\n concept_metadata = dict() # {top_tag: second_layer_tag:\n\n # parse all ddf files provided by GapMinder and find how many of them with Taiwan statistics\n for f_path in glob.glob(os.path.join('statistics', '*datapoints*.csv')):\n total += 1\n df = pd.read_csv(f_path)\n if 'twn' in df.geo.unique():\n num_available += 1\n indicator = f_path.replace('statistics/ddf--datapoints--', '').replace('--by--geo--time.csv', '')\n # print('[Indicator]', indicator)\n print(f\"\\t{len(df[df.geo == 'twn'])} indicators including Taiwan statistics.\")\n\n # stat_name = df.columns[-1]\n # df_p = df.pivot(index='geo', columns='time')[stat_name]\n # df_p.insert(loc=0, column='indicator', value=stat_name)\n # df_p.to_csv(f'statistics_transformed/{stat_name}.csv', sep=';')\n\n indicators.append(indicator)\n\n\n # print(\"{:.1f}% datapoints have Taiwan statistics\".format(num_available / float(total) * 100))\n\n\n\n df_c = pd.read_csv(CONCEPT_CSV_PATH)\n df_t = pd.read_csv(TAG_CSV_PATH)\n df = pd.merge(df_c, df_t, how='left', left_on='tags', right_on='tag')\n for idr, num_rows, earliest_year in indicator_twn_tuples:\n ancestors = list()\n\n row_values = df[df['concept'] == idr].values[0]\n name_catalog, parent, ancestor = (row_values[i] for i in [9, 17, 18])\n if type(parent) is str:\n ancestors.append(parent)\n\n # get ancestors recursively\n while type(ancestor) is str:\n tag_row_values = df_t[df_t['tag'] == ancestor].values[0]\n ancestors.append(tag_row_values[1])\n ancestor = tag_row_values[2]\n\n # build concept structure\n ancestors.insert(0, name_catalog)\n print('/'.join(ancestors[::-1]))","def _read_traces(self, unpack_headers=False, headonly=False,\n yield_each_trace=False):\n self.traces = []\n # Big loop to read all data traces.\n while True:\n # Read and as soon as the trace header is too small abort.\n try:\n # Always unpack with IEEE\n trace = SEGYTrace(self.file, 5, self.endian,\n unpack_headers=unpack_headers,\n headonly=headonly)\n if yield_each_trace:\n yield trace\n else:\n self.traces.append(trace)\n except SEGYTraceHeaderTooSmallError:\n break","def parse_results(results_file, measure_text):\r\n \r\n #Read in results file\r\n with open(results_file) as f_in:\r\n results_text = f_in.readlines()\r\n \r\n #Set-up output data frame\r\n results_df = pd.DataFrame(columns=('effect', 'time_window', 'electrodes'))\r\n \r\n r = -1 #data frame row index\r\n \r\n #Parse lines and read relevant results into data frame\r\n for i in range(len(results_text)):\r\n \r\n line = results_text[i]\r\n \r\n #Starting to parse a new simulation\r\n if 'SIMULATION SUMMARY' in line:\r\n r += 1\r\n \r\n #Parse basic simulation parameters\r\n elif 'Simulated experiments' in line:\r\n (field, value) = line.split('\\t')\r\n results_df.loc[r, 'n_experiments'] = int(value)\r\n \r\n elif 'Permutations' in line:\r\n (field, value) = line.split('\\t')\r\n results_df.loc[r, 'n_permutations'] = int(value)\r\n \r\n elif 'Sample size' in line:\r\n (field, value) = line.split('\\t')\r\n results_df.loc[r, 'n_subjects'] = int(value)\r\n \r\n elif 'Effect:' in line:\r\n (field, value) = line.split('\\t')\r\n results_df.loc[r, 'effect'] = os.path.basename(value).strip()\r\n \r\n elif 'Time window' in line:\r\n (field, value) = line.split('\\t')\r\n results_df.loc[r, 'time_window'] = value.strip()\r\n \r\n elif 'Electrodes:' in line:\r\n (field, value) = line.split('\\t')\r\n results_df.loc[r, 'electrodes'] = value.strip()\r\n \r\n elif 'Trials =' in line:\r\n (field, value) = line.split('\\t')\r\n results_df.loc[r, 'n_trials'] = int(value.split()[0])\r\n \r\n elif 'MEAN WINDOW' in line:\r\n (field, value) = results_text[i+1].split('\\t')\r\n results_df.loc[r, 'mean_amp'] = float(value)\r\n \r\n #Find correction method for current point in file\r\n elif 'UNCORRECTED' in line:\r\n method = 'uncorrected'\r\n elif 'SIDAK' in line:\r\n method = 'sidak'\r\n elif 'FMAX' in line:\r\n method = 'Fmax'\r\n elif 'CLUSTER 0.05' in line:\r\n method = 'cluster_05'\r\n elif 'CLUSTER 0.01' in line:\r\n method = 'cluster_01'\r\n elif 'BH' in line:\r\n method = 'BH'\r\n elif 'BY' in line:\r\n method = 'BY'\r\n elif 'BKY' in line:\r\n method = 'BKY'\r\n \r\n #Get the measure of interst and associate with method (from above)\r\n elif measure_text in line:\r\n (field, value) = line.split('\\t')\r\n results_df.loc[r, method] = float(value)\r\n \r\n return results_df","def collect_data(self):\n categories = []\n list_of_feature_lists = []\n feature_sets = set()\n with open(self.csv_path, \"r\") as f:\n reader = csv.DictReader(f)\n # collecting some stats for FDR calculation:\n self.PSM_count = 0\n self.decoy_count = 0\n\n if self[\"dump_svm_matrix\"]:\n self.init_svm_matrix_dump()\n additional_matrix_info = []\n\n for i, row in enumerate(\n sorted(\n reader,\n reverse=self[\"bigger_scores_better\"],\n key=lambda d: float(d[self.col_for_sorting]),\n )\n ):\n\n features = self.row_to_features(row)\n\n if tuple(features) in feature_sets:\n continue\n feature_sets.add(tuple(features))\n\n category, psm_FDR = self.get_psm_category(row)\n\n list_of_feature_lists.append(features)\n categories.append(category)\n\n if self[\"dump_svm_matrix\"]:\n label = -1 if row_is_decoy(row) else 1\n sequence = \"{0}.{1}#{2}.{3}\".format(\n row[\"Sequence Pre AA\"].strip(),\n row[\"Sequence\"].strip(),\n row[\"Modifications\"].strip(),\n row[\"Sequence Post AA\"].strip(),\n )\n additional_matrix_info.append(\n {\n \"psm_id\": row[\"Spectrum Title\"].strip(),\n \"label\": label,\n \"scannr\": row[\"Spectrum Title\"].strip().split(\".\")[-2],\n \"peptide\": sequence,\n \"proteins\": self.parse_protein_ids(row[\"Protein ID\"]),\n }\n )\n\n if i % 1000 == 0:\n score_val = float(row[self.col_for_sorting])\n msg = (\n \"Generating feature matrix from input csv \"\n \"(line ~{0}) with score {1} and FDR \"\n \"{2}\".format(i, score_val, psm_FDR)\n )\n print(msg, end=\"\\r\")\n\n # All data points are collected in one big matrix, to make standardization possible\n print(\"\\nConverting feature matrix to NumPy array...\")\n X_raw = np.array(list_of_feature_lists, dtype=float)\n\n print(\"Replacing empty/NaN values with the mean of each column...\")\n self.nan_replacer = Imputer()\n self.nan_replacer.fit(X_raw)\n X_raw = self.nan_replacer.transform(X_raw)\n # Standardize input matrix to ease machine learning! Scaled data has zero mean and unit variance\n print(\"Standardizing input matrix...\")\n self.scaler = SCALER.fit(X_raw)\n self.X = self.scaler.transform(X_raw)\n self.categories = np.array(categories)\n print()\n\n if self[\"dump_svm_matrix\"]:\n print(\"Dumping SVM matrix to\", self[\"dump_svm_matrix\"])\n\n for i, matrix_row in enumerate(self.X):\n matrix_row_info = additional_matrix_info[i]\n self.dump_svm_matrix_row(\n row=list(matrix_row),\n psm_id=matrix_row_info[\"psm_id\"],\n label=matrix_row_info[\"label\"],\n scannr=matrix_row_info[\"scannr\"],\n peptide=matrix_row_info[\"peptide\"],\n proteins=matrix_row_info[\"proteins\"],\n )\n\n print(\"Dumped SVM matrix to\", self[\"dump_svm_matrix\"])\n return","def preproc_data(base_dir):\n n_users = 182\n user_datas = []\n\n for user in tqdm(range(n_users)): \n #iterate through each trace of user \n user_traces = []\n if (len(str(user)) == 1): \n user_id = '00' + str(user)\n elif (len(str(user)) == 2): \n user_id = '0' + str(user)\n else: \n user_id = str(user)\n dir_name = base_dir + user_id + '/Trajectory/'\n for filename in os.listdir(dir_name): \n #load trajectory\n trajectory_raw = pd.read_csv(\n dir_name + filename,\n delimiter = ',', header = None, skiprows = 6,\n names = ['lat','lon', '0', 'altitude', 't_1899', 'date', 'time' ])\n\n #modify time\n traj = trajectory_raw.copy()\n traj.drop(columns = '0', inplace = True)\n\n traj['t_1899'] = (trajectory_raw['t_1899'] - trajectory_raw['t_1899'].values[0]) * 24 * 60 * 60\n traj_newcols = np.array(traj.columns)\n traj_newcols[traj_newcols == 't_1899'] = 'seconds'\n traj.columns = traj_newcols\n\n #get X_vals: \n R_earth = 6.371e6\n deg_to_rad = np.pi / 180\n traj['X'] = R_earth * np.cos(deg_to_rad * traj['lat'].values) * np.cos(deg_to_rad * traj['lon'].values)\n traj['Y'] = R_earth * np.cos(deg_to_rad * traj['lat'].values) * np.sin(deg_to_rad * traj['lon'].values)\n\n #Normalize to first point: \n origin_x = traj['X'].values[0]\n origin_y = traj['Y'].values[0]\n\n traj['X'] = traj['X'] - origin_x\n traj['Y'] = traj['Y'] - origin_y\n\n txy = traj.copy()\n txy = traj[['seconds', 'X', 'Y']]\n txy.columns = ['T', 'X', 'Y']\n if not np.isnan(txy.values).any(): \n user_traces.append(txy.values)\n\n user_datas.append(user_traces)\n return user_datas","def prepareAccumulatedMetrics(self):\n displayDF = analyzeMetricsDF(self.resultList)\n displayDF.to_csv(\"data/results.csv\")","def process(self):\n parser = csv.reader(self.reader,delimiter=self.delimiter_DIC[self.delim])\n firstRec = True\n for fields in parser:\n if firstRec:\n fieldNames = fields\n firstRec = False\n else:\n self.dicts.append({})\n for i,f in enumerate(fields):\n try:\n self.dicts[-1][fieldNames[i]] = f\n except:\n import pdb\n pdb.set_trace()\n if self.eng is \"spectrumMill\":\n for i,row in enumerate(self.dicts):\n fileSM = row[self.engine[self.eng][0]]\n acNoSM = row[self.engine[self.eng][1]]\n masSM=row[self.engine[self.eng][2]]\n chrgeSM=row[self.engine[self.eng][3]]\n preAmSM=row[self.engine[self.eng][4]].replace('(','').replace(')','')\n pepSM=row[self.engine[self.eng][5]]\n nAmSM=row[self.engine[self.eng][6]].replace('(','').replace(')','')\n modSM=row[self.engine[self.eng][7]].split('\\s')+row[self.engine[self.eng][8]].split('\\s')\n modLis = [mod.strip() for mod in modSM if mod!=' ']\n modSM = ';'.join(modLis)\n scoreSM=row[self.engine[self.eng][9]]\n descrimentSM=row[self.engine[self.eng][10]]\n if modSM !='':\n modPepInHupaFormat=self.modTermDic.spectrumMill(preAmSM,pepSM,nAmSM,modSM,self.eng)\n parsedData=acNoSM+'\\t'+masSM+'\\t'+chrgeSM+'\\t'+modPepInHupaFormat+'\\t'+scoreSM+'\\n'\n data = self.mapCaller(parsedData,self.eng)\n #print >>self.writer,data\n else:\n parsedData=acNoSM+'\\t'+masSM+'\\t'+chrgeSM+'\\t'+preAmSM+'.'+pepSM+'.'+nAmSM+'\\t'+'-'+'\\t'+scoreSM+'\\n'\n data = self.mapCaller(parsedData,self.eng)\n #print >>self.writer,data\n\n if self.eng is \"mascot\":\n \"\"\"\n In Mascot, under every gi (protein) corresponding peptide information will be there\n \"\"\"\n giFound=True\n for i,row in enumerate(self.dicts):\n if row[self.engine[self.eng][0]]!='':\n giAsKey = row[self.engine[self.eng][0]]\n giFound=False\n if giFound==False:\n massM=row[self.engine[self.eng][1]]\n chargeM=row[self.engine[self.eng][2]]\n preAmM=row[self.engine[self.eng][3]]\n pepM=row[self.engine[self.eng][4]]\n nAmM = row[self.engine[self.eng][5]]\n modM=row[self.engine[self.eng][6]]\n modSiteM=row[self.engine[self.eng][7]]\n scoreM=row[self.engine[self.eng][8]]\n evalM=row[self.engine[self.eng][9]]\n if modM !='':\n \"\"\"\n modificationFormat from modification.py creates a MASTER_UNIMOD dictionary \n Where all modifications of unimod would be available. \n At same time formatMod function in modificationFormat class would convert modification format \"\"\"\n modPepInHupaFormat=self.modTermDic.mascot(preAmM,pepM,nAmM,modSiteM,modM,self.eng)\n parsedData=giAsKey+'\\t'+massM+'\\t'+chargeM+'\\t'+modPepInHupaFormat+'\\t'+scoreM+'\\n'\n data=self.mapCaller(parsedData,self.eng)\n #print >>self.writer,data\n else:\n \n parsedData=giAsKey+'\\t'+massM+'\\t'+chargeM+'\\t'+preAmM+'.'+pepM+'.'+nAmM+'\\t'+'-'+'\\t'+scoreM+'\\n'\n data=self.mapCaller(parsedData,self.eng)\n #print >>self.writer,data\n\n if self.eng is \"inspect\":\n \"\"\"\n InSpect does not have mass information in TSV file\n So we need to fetch it from spectrum file (this is not yet done)\n \"\"\"\n for i,row in enumerate(self.dicts):\n data = row[self.engine[self.eng][0]]+'\\t'+row[self.engine[self.eng][1]]+'\\t'+row[self.engine[self.eng][2]]+'\\t'+row[self.engine[self.eng][3]]+'\\t'+row[self.engine[self.eng][4]]+'\\t'+row[self.engine[self.eng][5]]+'\\n'\n #return data\n #data = self.mapCaller(data)\n #self.writer.write(data)\n\n if self.eng is \"omssa\":\n #OMSSA csv doesnot contain start and last residue of the peptide, instead contains position. So start and last residue need to fetch from protein sequence\n for i,row in enumerate(self.dicts):\n giO = row[self.engine[self.eng][6]]\n massO= row[self.engine[self.eng][5]]\n chargeO=row[self.engine[self.eng][8]]\n preAmO = row[self.engine[self.eng][1]]#position in protein\n pepO = row[self.engine[self.eng][2]]\n nextAmO = row[self.engine[self.eng][3]] #position in protein\n scoreO= row[self.engine[self.eng][4]]\n modO=row[self.engine[self.eng][7]]\n if modO !='':\n #parsedData=giO+'#'+massO+'#'+chargeO+'#'+preAmO+'.'+pepO+'.'+nextAmO+'#'+modO+'#'+scoreO\n modPepInHupaFormat=self.modTermDic.omssa(preAmO,pepO,nextAmO,modO,self.eng)\n parsedData=giO+'\\t'+massO+'\\t'+chargeO+'\\t'+modPepInHupaFormat+'\\t'+scoreO+'\\n'\n self.mapCaller(parsedData,self.eng)\n else:\n parsedData=giO+'\\t'+massO+'\\t'+chargeO+'\\t'+preAmO+'.'+pepO+'.'+nextAmO+'\\t'+'-'+'\\t'+scoreO+'\\n'\n self.mapCaller(parsedData,self.eng)","def _calc_stats(self):\n\n for res in self.rsts:\n _LOG.info(\"Calculate statistics for '%s'\", res.reportid)\n res.calc_stats(regexs=self._stats_colnames, funcnames=self._stats_funcs)","def process_stat_files(param):\n\n #get the files that are actually in the output directory\n call = ['cp', '-R']\n call.append(param['working_dir']+'results/featureCount/')\n call.append(param['working_dir']+'report/')\n _, _ = subprocess.Popen(call,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE).communicate()\n\n featurecount_file = (param['working_dir']+\n 'results/featureCount/featureCount_stats.txt')\n #extract table\n table = []\n filehandle = open(featurecount_file)\n #header\n table.append(filehandle.readlines()[0].rstrip().split('\\t'))\n table[0] = table[0][1:]\n filehandle.close()\n\n #total number of aligned reads\n tot_reads = param['bam_qc']['unique_aligned_reads']\n counter = [0] * len(param['bam_qc']['unique_aligned_reads'])\n \n filehandle = open(featurecount_file)\n for line in filehandle.readlines()[1:]:\n cur_line = line.rstrip().split('\\t')\n cur_line[0] = re.sub(r'_',' ',cur_line[0])\n if cur_line[0] not in ['Unassigned MultiMapping','Assigned']:\n counter = [ct + int(cr) for ct, cr in zip(counter, cur_line[1:])]\n perc = ([cur_line[0]]+\n MODULE_HELPER.get_percentage(cur_line[1:],\n tot_reads,\n len(cur_line)-1))\n table.append(perc)\n filehandle.close()\n assigned = [tot_reads[idx] - counter[idx] for idx in range(len(tot_reads))]\n perc = ['Assigned'] + MODULE_HELPER.get_percentage(assigned,\n tot_reads,\n len(counter))\n return table","def freqchk_method():\n y = 0\n csvfile = open('KIE_Output.csv', 'wb')\n outputwriter = csv.writer(csvfile, dialect='excel')\n outputwriter.writerow([\"GS_file\"] + [\"TS_File\"] + [\"Temperature\"] + [\"Pressure\"] + [\"Scale_factor\"] + [\"Chem_symbol\"] + [\"GS_number\"] + [\"TS_number\"] + [\"Labeled_isotope\"] + [\"KIE\"] + [\"KIE_tunneling\"])\n heading = [\"GS_file\", \"TS_File\", \"Temperature\", \"Pressure\", \"Scale_factor\", \"Chem_symbol\", \"GS_number\", \"TS_number\", \"Labeled_isotope\", \"KIE\", \"KIE_tunneling\"]\n x=0\n for each_GS in GS_chkpt_file:\n for each_TS in TS_chkpt_file:\n for each_item in isotope_changes: #split the changes to the isotope\n for each_temp in temp:\n if len(each_GS) > x:\n x = len(each_GS)\n if len(each_TS) > x:\n x = len(each_TS)\n y += 1\n chem_sym = []\n gs_num = []\n ts_num = []\n isotope_mass = []\n output = []\n i = 0\n while i < len(each_item):\n chem_sym.append(each_item[i])\n gs_num.append(each_item[i+1])\n ts_num.append(each_item[i+2])\n isotope_mass.append(each_item[i+3])\n i += 4\n \n # run freqchk for TS without a marker\n run_freqchk_TS_no_marker(each_TS, hyperchem_files, each_temp, pressure, scale_factor, gradient_direction)\n #run freqchk for TS with a marker\n run_freqchk_TS_marker(each_TS, hyperchem_files, each_temp, pressure, scale_factor, gradient_direction, ts_num, isotope_mass, number_atoms_TS)\n #run freqchk for GS without a marker\n run_freqchk_GS_no_marker(each_GS, hyperchem_files, each_temp, pressure, scale_factor, gradient_direction)\n #run freqchk for GS with a marker\n run_freqchk_GS_marker(each_GS, hyperchem_files, each_temp, pressure, scale_factor, gradient_direction, gs_num, isotope_mass, number_atoms_GS)\n\n #get frequencies from .txt file\n frequency_TS_natural = map(float, get_frequencies(\"freq_TS_no_marker.txt\"))\n frequency_TS_isotope = map(float, get_frequencies(\"freq_TS_marker.txt\"))\n frequency_GS_natural = map(float, get_frequencies(\"freq_GS_no_marker.txt\"))\n frequency_GS_isotope = map(float, get_frequencies(\"freq_GS_marker.txt\"))\n\n #remove freqchk output files\n os.system(\"rm freq_TS_no_marker.txt freq_TS_marker.txt freq_GS_no_marker.txt freq_GS_marker.txt\")\n\n # create array with u values\n u_TS_natural = np.array(calc_u(frequency_TS_natural, each_temp, scale_factor))\n u_TS_isotope = np.array(calc_u(frequency_TS_isotope, each_temp, scale_factor))\n u_GS_natural = np.array(calc_u(frequency_GS_natural, each_temp, scale_factor))\n u_GS_isotope = np.array(calc_u(frequency_GS_isotope, each_temp, scale_factor))\n if u_TS_natural[0] < 0:\n u_neg_TS_natural= u_TS_natural[0] #negative u value\n u_TS_natural = u_TS_natural[1:] #allows calculation on all u values that are positive\n u_neg_TS_isotope = u_TS_isotope[0] #negative u value\n u_TS_isotope = u_TS_isotope[1:] #allows calculation on all u values that are positive\n else:\n u_neg_TS_natural =[]\n u_neg_TS_isotope = []\n\n # create array with exp(u/2) values\n exp_TS_natural = np.array(exp_u_half(u_TS_natural))\n exp_TS_isotope = np.array(exp_u_half(u_TS_isotope))\n exp_GS_natural = np.array(exp_u_half(u_GS_natural))\n exp_GS_isotope = np.array(exp_u_half(u_GS_isotope))\n\n # create array with 1-exp(-u) values\n one_minus_exp_TS_natural = np.array(calc_one_minus_exp(u_TS_natural))\n one_minus_exp_TS_isotope = np.array(calc_one_minus_exp(u_TS_isotope))\n one_minus_exp_GS_natural = np.array(calc_one_minus_exp(u_GS_natural))\n one_minus_exp_GS_isotope = np.array(calc_one_minus_exp(u_GS_isotope))\n\n # create array with prod values\n prod_TS_natural = np.array(calc_prod(u_TS_natural, exp_TS_natural, one_minus_exp_TS_natural))\n prod_TS_isotope = np.array(calc_prod(u_TS_isotope, exp_TS_isotope, one_minus_exp_TS_isotope))\n prod_GS_natural = np.array(calc_prod(u_GS_natural, exp_GS_natural, one_minus_exp_GS_natural))\n prod_GS_isotope = np.array(calc_prod(u_GS_isotope, exp_GS_isotope, one_minus_exp_GS_isotope))\n \n # calculate FTS\n if u_neg_TS_natural:\n FTS_TS_natural = calc_FTS_TS(prod_TS_natural, u_neg_TS_natural)\n FTS_TS_isotope = calc_FTS_TS(prod_TS_isotope, u_neg_TS_isotope)\n FTS_GS_natural = calc_FTS(prod_GS_natural)\n FTS_GS_isotope = calc_FTS(prod_GS_isotope)\n else:\n FTS_TS_natural = calc_FTS(prod_TS_natural)\n FTS_TS_isotope = calc_FTS(prod_TS_isotope)\n FTS_GS_natural = calc_FTS(prod_GS_natural)\n FTS_GS_isotope = calc_FTS(prod_GS_isotope)\n \n # calcualte qt for TS\n if u_neg_TS_natural:\n qt_TS_natural = calc_qt(u_neg_TS_natural)\n qt_TS_isotope = calc_qt(u_neg_TS_isotope)\n else:\n qt_TS_natural = calc_qt(u_TS_natural[0])\n qt_TS_isotope = calc_qt(u_TS_isotope[0])\n\n # build dictionary with elements and get the mass of the\n # elements being used\n elements = {'H':1, 'He':4, 'Li':7, 'B':11, 'C':12, 'N':14, 'O':16, 'Ne':20, 'Mg':24, 'Si':28, 'S':32, 'Cl':35, 'Ar':40, 'K':39, 'Ca':40, 'Ti':48, 'Cr':52, 'Fe':56, 'Ni':58, 'Cu':63, 'Zn':64, 'Ga':69, 'Ge':74, 'Se':80, 'Br':79, 'Kr':84, 'Sr':88, 'Zr':90, 'Mo':98, 'Ru':102, 'Pd':106, 'Ag':107, 'Cd':114, 'Sn':120, 'Sb':121, 'Te':126, 'Xe':132, 'Ba':138, 'Ce':140, 'Nd':142, 'Sm':152, 'Eu':153, 'Gd':158, 'Dy':164, 'Er':166, 'Yb':174, 'Hf':180, 'W':184, 'Os':192, 'Ir':193, 'Pt':195, 'Hg':202, 'Tl':205, 'Pb':208}\n temp_sym = ' '.join(chem_sym[0])\n temp_isotope_mass = isotope_mass[0]\n temp_isotope_mass = \"\".join(repr(temp_isotope_mass))\n temp_isotope_mass = int(temp_isotope_mass)\n\n # calculate KIE\n for a in elements.keys():\n if a == ''.join(temp_sym):\n if elements[a] > temp_isotope_mass:\n KIE1 = (FTS_TS_isotope / FTS_TS_natural)\n KIE2 = (FTS_GS_natural / FTS_GS_isotope)\n KIE3 = KIE2 * KIE1\n KIE = 1 / KIE3\n else:\n KIE1 = (FTS_TS_isotope / FTS_TS_natural)\n KIE2 = (FTS_GS_natural / FTS_GS_isotope)\n KIE = KIE2 * KIE1\n\n #calculate KIE with tunneling\n KIE_tunneling = KIE * qt_TS_natural / qt_TS_isotope\n\n #convert to strings\n gs_num = map(str, gs_num)\n ts_num = map(str, ts_num)\n isotope_mass = map(str, isotope_mass)\n KIE = str(KIE)\n KIE_tunneling = str(KIE_tunneling)\n\n each_temp = ''.join(each_temp)\n pressure = ''.join(pressure)\n scale_factor = ''.join(scale_factor)\n chem_sym = ', '.join(chem_sym)\n gs_num = ', '.join(gs_num)\n ts_num = ', '.join(ts_num)\n isotope_mass = ', '.join(isotope_mass)\n \n output.append(each_GS)\n output.append(each_TS)\n output.append(each_temp)\n output.append(pressure)\n output.append(scale_factor)\n output.append(chem_sym)\n output.append(gs_num)\n output.append(ts_num)\n output.append(isotope_mass)\n output.append(KIE)\n output.append(KIE_tunneling)\n master_output.append(output)\n\n outputwriter.writerow([each_GS] + [each_TS] + [each_temp] + [pressure] + [scale_factor] + [chem_sym] + [gs_num] + [ts_num] + [isotope_mass] + [KIE] + [KIE_tunneling])\n csvfile.close()\n\n print ' '.join(heading)\n for each_entry in master_output:\n print ' '.join(each_entry)\n \n print \"\\n\", \"All KIE's have been calculated!\", \"\\n\"","def process_trace(n_tr, tr, sta, orig_time, cmps, cfg):\n cmp = tr.stats.channel[2:3]\n sta[cmp] = {}\n sta[cmp][\"times\"] = tr.times(reftime=orig_time)\n\n sta[cmp][\"tr_results\"] = np.zeros(\n (len(cfg.picking.FILT_WINS[\"P\"]), sta[\"lenD\"])\n )\n sta[cmp][\"f1_results\"] = np.zeros(\n (len(cfg.picking.FILT_WINS[\"P\"]), len(cfg.picking.KURT_WINS),\n sta[\"lenD\"])\n )\n sta[cmp][\"f1_mean\"] = np.zeros(sta[\"lenD\"])\n sta[cmp][\"f3_results\"] = np.zeros(\n (len(cfg.picking.FILT_WINS[\"P\"]),\n len(cfg.picking.KURT_WINS), sta[\"lenD\"])\n )\n sta[cmp][\"f3_mean_smooth\"] = np.zeros(\n (len(cfg.picking.CF_MEAN_SMOOTH_WIND), sta[\"lenD\"])\n )\n sta[cmp][\"f4_all\"] = np.zeros((len(cfg.picking.CF_MEAN_SMOOTH_WIND),\n sta[\"lenD\"]))\n sta[cmp][\"f1_mean_smooth\"] = np.zeros(sta[\"lenD\"])\n # Get suitable filters (exclude those fully outside Nyquist freq.)\n for phase in [\"P\", \"S\"]:\n if cmp in cmps[phase]:\n sta[\"picks\"][\"poss_obs\"][phase][cmp] = {}\n sta[cmp][\"filtwins_check\"] = [\n filt_win for filt_win in cfg.picking.FILT_WINS[phase]\n if filt_win[0] < sta[\"samplerate\"] / 2\n ]\n if cfg.picking.INTEGRATE_S is True:\n tr.integrate()\n\n for n_filt, filt in enumerate(sta[cmp][\"filtwins_check\"]):\n # Ensure that filter covers sample rate / 2\n if (tr.stats.sampling_rate / 2) <= filt[0]:\n print(\"Skipping this Kurtosis run due to sample rate/2<f\")\n continue\n tr.filter(\"bandpass\", freqmin=filt[0], freqmax=filt[1])\n try:\n sta[cmp][\"tr_results\"][n_filt] = tr.data\n except ValueError: # If input array length is inconsistent\n continue\n # Loop over kurtosis windows\n for n_kurt, kurt_win_s in enumerate(cfg.picking.KURT_WINS):\n f1 = CF_kurtosis(kurt_win_s, tr)\n sta[cmp][\"f1_results\"][n_filt, n_kurt] = f1 # Needed for weights\n f2 = kurt_transform_f2(f1, kurt_win_s, tr)\n f3 = kurt_transform_f3(f2, kurt_win_s, tr)\n\n sta[cmp][\"f3_results\"][n_filt, n_kurt] = f3\n sta[cmp][\"f1_mean\"] = np.nanmean(sta[cmp][\"f1_results\"], axis=0)[0]\n sta[cmp][\"f1_mean_smooth\"] = do_smooth(\n sta[cmp][\"f1_mean\"], cfg.picking.CF_MEAN_SMOOTH_WIND[0],\n tr.stats.sampling_rate\n )\n # ^ Throws up a warning first time due to NaN slices\n # Compute mean CF and final kurtosis transform\n f3_mean = np.nanmean(sta[cmp][\"f3_results\"], axis=0)[0]\n\n for nsm, smooth_wind in enumerate(cfg.picking.CF_MEAN_SMOOTH_WIND):\n sta[cmp][\"f3_mean_smooth\"][nsm] = do_smooth(\n f3_mean, smooth_wind, tr.stats.sampling_rate\n )\n f4 = kurt_transform_f4(sta[cmp][\"f3_mean_smooth\"][nsm],\n np.max(cfg.picking.KURT_WINS), tr)\n sta[cmp][\"f4_all\"][nsm] = f4\n\n # Now pick (avoiding end and beginning of signal)\n # Pick the P-waves\n if cmp in cmps[\"P\"]:\n sta[\"picks\"][\"poss_obs\"][\"P\"][cmp][nsm] = []\n # Find points where Kurt<0 & doesn't look like S-wave\n p_cands = np.argwhere((f4 < 0.0))\n for idx in p_cands.tolist():\n kurt_wgt = np.min(np.where(np.array(\n cfg.picking.KURT2WGHT[\"P\"]\n <= sta[cmp][\"f1_mean_smooth\"][idx])))\n sta[\"picks\"][\"poss_obs\"][\"P\"][cmp][nsm].append([\n orig_time+sta[cmp][\"times\"][idx][0], f4[idx][0],\n tr.stats.channel, kurt_wgt, idx,\n sta[cmp][\"times\"][idx][0]\n ])\n # Pick the S-waves\n if cmp in cmps[\"S\"]:\n sta[\"picks\"][\"poss_obs\"][\"S\"][cmp][nsm] = []\n\n # Find points where Kurt<0 & doesn't look like S-wave\n s_cands = np.argwhere((f4 < 0.0))\n for idx in s_cands.tolist():\n kurt_wgt = np.min(np.where(np.array(cfg.picking.KURT2WGHT[\"S\"]\n <= sta[cmp][\"f1_mean_smooth\"][idx]))\n )\n sta[\"picks\"][\"poss_obs\"][\"S\"][cmp][nsm].append([\n orig_time+sta[cmp][\"times\"][idx][0], f4[idx][0],\n tr.stats.channel, kurt_wgt, idx,\n sta[cmp][\"times\"][idx][0]\n ])\n return(sta)","def analyze_from_tailed_file(self, a_file_paths, a_go_to_the_end = True): #pylint: disable-msg=R0912\n files = []\n for f_path in a_file_paths:\n files.append(open(f_path, 'r'))\n \n f_iter = multitail.MultiFileTailer.tail(files, delay=0.4, go_to_the_end = a_go_to_the_end)\n \n last_time_display = None\n on_error = False\n \n try:\n \n #init print\n self.print_on_display(self.display, None)\n \n for (f_line, _) in f_iter:\n \n #process only tuples (other lines should be ignored)\n matched = Analyzer.expr_re.match(f_line)\n if matched:\n \n line = matched.group('line')\n filename = matched.group('filename')\n \n # sometimes the tail can eat (bug) part of the line\n # ignore this exception\n try:\n self.analyze(self.mem_db, line, filename)\n except tellicastlog_parser.InvalidTellicastlogFormatError, err:\n error_str = utils.get_exception_traceback()\n Analyzer.LOG.error(\"Parser Exception %s, traceback %s\" %(err, error_str))\n \n last_time_display = self.print_on_display(self.display, last_time_display)\n \n kb_input = self.display.check_for_input()\n if kb_input and kb_input == 'QUIT':\n break # quit loop\n elif kb_input and kb_input == 'STOPACCEPTING':\n Analyzer.LOG.error(\"*********** Stop Accepting\")\n self._accepting_new = False\n elif kb_input and kb_input == 'RESTARTACCEPTING':\n Analyzer.LOG.error(\"*********** Restart Accepting\")\n self._accepting_new = True\n elif kb_input and kb_input == 'OLDEST':\n Analyzer.LOG.error(\"*********** OLDEST records first\")\n self._sort_criteria = 'OLDEST'\n elif kb_input and kb_input == 'NEWEST':\n Analyzer.LOG.error(\"*********** NEWEST records first\")\n self._sort_criteria = 'NEWEST'\n \n else:\n #force update\n self.print_on_display(self.mem_db, self.display, None)\n \n except KeyboardInterrupt:\n \n #CTRL^C pressed so silently quit\n sys.exit(0)\n except Exception, err:\n \n Analyzer.LOG.error(\"In Error\")\n \n error_str = utils.get_exception_traceback()\n \n Analyzer.LOG.error(\"received error %s. Traceback = %s\" %(err, error_str))\n \n on_error = True\n finally:\n #whatever the case always reset the screen\n self.display.reset_screen()\n if on_error:\n print(\"Exiting on error\")\n return 1 #pylint: disable-msg=W0150\n else:\n print(\"Exiting gracefully\")\n return 0 #pylint: disable-msg=W0150","def produce_all_term_data(self):\n # remove cold start records if requested\n test = self.test.copy()\n test = self.handle_cold_start(test)\n\n outputs = self.output()\n trainf, testf = outputs['train'], outputs['test']\n with trainf.open('w') as ftrain, testf.open('w') as ftest:\n self.write_libfm_data(ftrain, ftest, self.train, test)\n\n # Write the term-to-id guide\n test = test.sort(('termnum'))\n test['rownum'] = np.arange(len(test))\n guide = test.groupby('termnum').max()['rownum']\n with self.output()['guide'].open('w') as f:\n guide.to_csv(f, index_label='termnum', header=True)","def __init__ (self, fTrace, pTrace, traceType, precision, recall, totalNodes, startTime, endTime):\n\n self.traceType = traceType\n self.precision = precision\n self.recall = recall\n self.totalNodes = totalNodes\n self.startTime = startTime\n self.endTime = endTime\n self.fTraceHandle = open (fTrace, \"r\")\n self.pTraceHandle = open (pTrace, \"w\")\n\n self.readNextTraceLine (self.fTraceHandle)\n\n self.totalEvents = 0\n self.predictedEvents = 0\n self.correctPredictions = 0\n self.totalPredictions = 0","def summaryD4(self):\r\n\r\n if len(self.window.diff_tabs.lst_indices_present)!=0:\r\n \r\n for index in self.window.diff_tabs.lst_indices_present:\r\n if index==1:\r\n \r\n dfD4_temp1_pos1= pd.read_csv('raw_text_D4_1_1.txt')\r\n dfD4_temp1_pos2= pd.read_csv('raw_text_D4_1_2.txt')\r\n dfD4_temp1_pos3= pd.read_csv('raw_text_D4_1_3.txt')\r\n dfD4_temp1_pos4= pd.read_csv('raw_text_D4_1_4.txt')\r\n \r\n D4summary_temp1=pd.concat([dfD4_temp1_pos1,dfD4_temp1_pos2,dfD4_temp1_pos3,dfD4_temp1_pos4],axis=1)\r\n D4summary_temp1.to_csv('D4summary_temp1.txt',index=False)\r\n \r\n if index==2:\r\n \r\n dfD4_temp2_pos1= pd.read_csv('raw_text_D4_2_1.txt')\r\n dfD4_temp2_pos2= pd.read_csv('raw_text_D4_2_2.txt')\r\n dfD4_temp2_pos3= pd.read_csv('raw_text_D4_2_3.txt')\r\n dfD4_temp2_pos4= pd.read_csv('raw_text_D4_2_4.txt')\r\n \r\n D4summary_temp2=pd.concat([dfD4_temp2_pos1,dfD4_temp2_pos2,dfD4_temp2_pos3,dfD4_temp2_pos4],axis=1)\r\n D4summary_temp2.to_csv('D4summary_temp2.txt',index=False)\r\n \r\n if index==3:\r\n \r\n dfD4_temp3_pos1= pd.read_csv('raw_text_D4_3_1.txt')\r\n dfD4_temp3_pos2= pd.read_csv('raw_text_D4_3_2.txt')\r\n dfD4_temp3_pos3= pd.read_csv('raw_text_D4_3_3.txt')\r\n dfD4_temp3_pos4= pd.read_csv('raw_text_D4_3_4.txt')\r\n \r\n D4summary_temp3=pd.concat([dfD4_temp3_pos1,dfD4_temp3_pos2,dfD4_temp3_pos3,dfD4_temp3_pos4],axis=1)\r\n D4summary_temp3.to_csv('D4summary_temp3.txt',index=False)","def scanData(run, precisionLabel, s06Cfg, tarList):\n try:\n tfp = open(tarList)\n except:\n print(\"ERROR opening\", tarList)\n sys.exit(1)\n\n tRemove = set()\n tFinished = set()\n tFinishedStart = True\n tSurplusData = set()\n nDataFinish = None\n nExtra = 0\n nBadMeasure = 0\n nMissing = 0\n first = True\n for line in tfp:\n corrFile, linesPerTime = line.split()\n corrFile = re.sub('CFG', s06Cfg, corrFile)\n corrFilePath = os.path.join(run, \"data\", precisionLabel, corrFile)\n linesPerTime = int(linesPerTime)\n\n try:\n stat = os.stat(corrFilePath)\n except OSError:\n if first:\n print(\"ERROR: can't find required file\", corrFilePath)\n print(\"Listing of any other missing files will be suppressed\")\n first = False\n nMissing += 1\n tFinished = set()\n tFinishedStart = False\n continue\n\n # Get stanza count from the number of lines in the file\n cmd = ' '.join([\"wc -l\", corrFilePath, \"| awk '{print $1}'\"])\n try:\n haveLines = subprocess.check_output(cmd, shell=True)\n except subprocess.CalledProcessError as e:\n # If we can't find the file, no chance of recovery\n print(\"ERROR: can't count lines in\", corrFile, \"return code\", e.returncode, \".\")\n return tFinished, tRemove, nExtra, nBadMeasure, nMissing\n\n # Check line count\n haveLines = int(haveLines.rstrip().decode())\n if haveLines % linesPerTime != 0:\n nBadMeasure += 1\n \n n = haveLines//int(linesPerTime)\n\n # Get list of source times in the correlator file\n cmd = ' '.join(['grep \"antiquark_source_origin:\"', corrFilePath, \n \"| awk '{print $6}'\"])\n try:\n tFoundList = subprocess.check_output(cmd, shell=True).splitlines()\n except subprocess.CalledProcessError as e:\n # If we can't find the file, no chance of recovery\n print(\"ERROR: can't find source times in\", corrFile, \"return code\", e.returncode, \".\")\n return tFinished, tRemove, nExtra, nBadMeasure, nMissing\n # Decode byte encoding\n tFound = set([c.decode() for c in tFoundList])\n\n if verbose:\n print(\"For\", corrFilePath, \"found\", haveLines, \"lines with\", \n linesPerTime, \"values per time\")\n print(\"Found times\", tFound)\n\n # Consistency check\n if n > len(tFound):\n nExtra += 1\n elif n < len(tFound):\n print(\"FATAL:\", corrFilePath, \"lists more time values than its length permits\")\n sys.exit(1)\n\n # tFinished will be a list of all times common to all correlators\n if tFinishedStart:\n tFinished = tFound\n tFinishedStart = False\n else:\n tFinished = tFinished.intersection(tFound)\n\n # tRemove will be a list of all times not common to all correlators\n tSpare = tFound.difference(tFinished)\n if len(tSpare) > 0:\n tRemove.update(tSpare)\n\n if nDataFinish == None:\n nDataFinish = n\n elif n < nDataFinish:\n nDataFinish = n\n\n # Get the locations of the JobID lines\n cmd = ' '.join([\"grep -n JobID\", corrFilePath, \"| awk -F: '{print $1}'\"])\n try:\n jobIDLines = subprocess.check_output(cmd, shell=True).splitlines()\n except subprocess.CalledProcessError as e:\n # If we can't find the file, no chance of recovery\n print(\"ERROR: can't count lines in\", corrFilePath, \"return code\", e.returncode, \".\")\n return tFinished, tRemove, nExtra, nBadMeasure, nMissing\n # Decode byte encoding\n jobIDLines = [int(c.decode()) for c in jobIDLines]\n\n # Check locations of JobID lines\n if len(jobIDLines) == 0:\n print(\"ERROR: No JobID lines in\", corrFilePath)\n tFinished = set()\n return tFinished, tRemove, nExtra, nBadMeasure, nMissing\n if jobIDLines[0] != 2:\n print(\"ERROR: First JobID line is at line no\", jobIDLines[0], \n \"but should be at line 2 in\", corrFilePath)\n # Add an extrapolated location for the last stanza\n jobIDLines += [haveLines + 2]\n \n # Check for correct spacing of jobID lines\n for k in range(1,len(jobIDLines)):\n linect = jobIDLines[k] - jobIDLines[k-1]\n if linect < linesPerTime:\n t0 = int(tFoundList[k-1].decode())\n if t0 in tFinished:\n print(\"ERROR: stanza for time\", t0, \"in\", corrFilePath, \n \"has line count\", linect, \"but wanted\", linesPerTime)\n print(\"That time will be dropped\")\n tFinished.discard(t0)\n tRemove.update([t0])\n elif linect > linesPerTime:\n t0 = int(tFoundList[k-1].decode())\n if t0 not in tSurplusData:\n print(\"ERROR: stanza for time\", t0, \"in\", corrFilePath, \"has line count\", \n linect, \"but wanted\", linesPerTime)\n print(\"The extra lines will be dropped\")\n tSurplusData.update([t0])\n\n if nExtra > 0:\n print(\"ERROR: in\", nExtra, precisionLabel,\n \"correlator files there was a mismatch between the time stanza count\",\n \"and the number of unique source times\")\n if nBadMeasure > 0:\n print(\"ERROR: In\", nBadMeasure, precisionLabel, nBadMeasure,\n \"correlator files the line count was not an integer multiple of the fiducial count\",\n \"per stanza, indicating either extra or missing lines.\")\n\n return tFinished, tRemove, nExtra, nBadMeasure, nMissing","def write_tsvs(raw_dir: Path, bids_dir: Path):\n\n print(\"Writing tsvs.\")\n\n for path_to_onset in Path(raw_dir/\"onset_textfiles\").glob(\"*.txt\"):\n\n onsets_as_lines_with_too_much_whitespace = path_to_onset.read_text().splitlines()\n onsets = [line.strip() for line in onsets_as_lines_with_too_much_whitespace]\n\n tsv_lines_without_a_header = [onset + \"\\t\" + \"4\" for onset in onsets]\n tsv_lines = [\"onset\" + \"\\t\" + \"duration\"] + tsv_lines_without_a_header\n full_text_of_tsv = \"\\n\".join(tsv_lines)\n\n subject_id = subject_id_of(path_to_onset)\n task_id = path_to_onset.stem.split(\"_\")[1]\n\n func_path_to_imitate = the_path_that_matches(f\"*_task-{task_id}*.nii\", in_directory=bids_dir/f\"sub-{subject_id}/func\")\n func_stem_split_into_parts = func_path_to_imitate.stem.split(\"_\")\n tsv_stem_split_into_parts = func_stem_split_into_parts[:-1] + [\"events\"]\n tsv_stem = \"_\".join(tsv_stem_split_into_parts)\n tsv_path = func_path_to_imitate.with_name(tsv_stem + \".tsv\")\n\n tsv_path.write_text(full_text_of_tsv)","def modelfactors(trace_files: List[str], trace_processes: Dict):\n traces = [load(file) for file in trace_files]\n df_mfactors = pd.DataFrame(columns=MOD_FACTORS_DOC.values())\n reference = True\n for (hdf5_file, trace, cpus) in zip(trace_files, traces, trace_processes.values()):\n MOD_FACTORS_VAL['num_processes'] = cpus\n print(\n f\"==INFO== Analysing {hdf5_file} ({MOD_FACTORS_VAL['num_processes']} processes, {human_readable(os.path.getsize(hdf5_file))})\")\n\n # Computes raw data\n ipc, freq, runtime, runtime_id, useful_av, useful_max, useful_tot, useful_id, useful_inst, useful_cyc = get_raw_data(\n trace, cmdl_args)\n\n MOD_FACTORS_VAL['ipc'] = ipc\n MOD_FACTORS_VAL['freq'] = freq\n MOD_FACTORS_VAL['runtime'] = runtime\n MOD_FACTORS_VAL['runtime_id'] = runtime_id\n MOD_FACTORS_VAL['useful_av'] = useful_av\n MOD_FACTORS_VAL['useful_max'] = useful_max\n MOD_FACTORS_VAL['useful_tot'] = useful_tot\n MOD_FACTORS_VAL['useful_id'] = useful_id\n MOD_FACTORS_VAL['useful_ins'] = useful_inst\n MOD_FACTORS_VAL['useful_cyc'] = useful_cyc\n\n # Computes efficiencies after getting the raw data\n parallel_eff, load_balance, comm_eff, serial_eff, transfer_eff = get_efficiencies(\n MOD_FACTORS_VAL['runtime'],\n MOD_FACTORS_VAL['runtime_id'],\n MOD_FACTORS_VAL['useful_av'],\n MOD_FACTORS_VAL['useful_max'],\n MOD_FACTORS_VAL['useful_id'],\n MOD_FACTORS_VAL['comp_scale'])\n\n MOD_FACTORS_VAL['parallel_eff'] = parallel_eff\n MOD_FACTORS_VAL['load_balance'] = load_balance\n MOD_FACTORS_VAL['comm_eff'] = comm_eff\n MOD_FACTORS_VAL['serial_eff'] = serial_eff\n MOD_FACTORS_VAL['transfer_eff'] = transfer_eff\n\n # Adds the new row with the raw data and efficiencies to the dataframe\n df_mfactors.loc[len(df_mfactors), :] = list(MOD_FACTORS_VAL.values())\n\n # Computes scalabilities\n df_mfactors = get_scalabilities(df_mfactors, cmdl_args)\n\n return df_mfactors","def process(filename, debug_mode=False):\n if debug_mode:\n global DO_REPORT\n DO_REPORT = debug_mode\n\n try:\n signal = preprocessing(filename)\n except BaseException as e:\n print(e)\n sys.exit()\n\n labels, num_of_speakers = diarization(signal)\n segments = lab2seg(labels)\n res_filename = create_csv(filename, segments)\n return res_filename, num_of_speakers","def read_traveltime(self):\r\n \r\n #### read Travel time from txt file\r\n \r\n \r\n #### Particle travel time branch 1\r\n excelfile_surface_branch1_high = r'excel\\flow_rate\\particle_surface_branch1_high.xlsx'\r\n inarray_surface_branch1_high = pd.read_excel(excelfile_surface_branch1_high).to_numpy() \r\n \r\n excelfile_surface_branch1_medium = r'excel\\flow_rate\\particle_surface_branch1_medium.xlsx'\r\n inarray_surface_branch1_medium = pd.read_excel(excelfile_surface_branch1_medium).to_numpy() \r\n \r\n excelfile_surface_branch1_low = r'excel\\flow_rate\\particle_surface_branch1_low.xlsx'\r\n inarray_surface_branch1_low = pd.read_excel(excelfile_surface_branch1_low).to_numpy()\r\n \r\n excelfile_bottom_branch1_high = r'excel\\flow_rate\\particle_bottom_branch1_high.xlsx'\r\n inarray_bottom_branch1_high = pd.read_excel(excelfile_bottom_branch1_high).to_numpy()\r\n \r\n excelfile_bottom_branch1_medium = r'excel\\flow_rate\\particle_bottom_branch1_medium.xlsx'\r\n inarray_bottom_branch1_medium = pd.read_excel(excelfile_bottom_branch1_medium).to_numpy()\r\n \r\n excelfile_bottom_branch1_low = r'excel\\flow_rate\\particle_bottom_branch1_low.xlsx'\r\n inarray_bottom_branch1_low = pd.read_excel(excelfile_bottom_branch1_low).to_numpy()\r\n \r\n \r\n #### Tracer travel time branch 1\r\n excelfile_tracer_branch1_high = r'excel\\flow_rate\\tracer_branch1_high.xlsx'\r\n inarray_tracer_branch1_high = pd.read_excel(excelfile_tracer_branch1_high).to_numpy()\r\n \r\n excelfile_tracer_branch1_medium = r'excel\\flow_rate\\tracer_branch1_medium.xlsx'\r\n inarray_tracer_branch1_medium = pd.read_excel(excelfile_tracer_branch1_medium).to_numpy()\r\n \r\n excelfile_tracer_branch1_low = r'excel\\flow_rate\\tracer_branch1_low.xlsx'\r\n inarray_tracer_branch1_low = pd.read_excel(excelfile_tracer_branch1_low).to_numpy()\r\n \r\n self.inarrays_branch1 = [inarray_surface_branch1_high, inarray_surface_branch1_medium, inarray_surface_branch1_low, \\\r\n inarray_bottom_branch1_high, inarray_bottom_branch1_medium, inarray_bottom_branch1_low, \\\r\n inarray_tracer_branch1_high, inarray_tracer_branch1_medium, inarray_tracer_branch1_low]\r\n \r\n \r\n #### Particle travel time branch 5\r\n excelfile_surface_branch5_high = r'excel\\flow_rate\\particle_surface_branch5_high.xlsx'\r\n inarray_surface_branch5_high = pd.read_excel(excelfile_surface_branch5_high).to_numpy()\r\n \r\n excelfile_surface_branch5_medium = r'excel\\flow_rate\\particle_surface_branch5_medium.xlsx'\r\n inarray_surface_branch5_medium = pd.read_excel(excelfile_surface_branch5_medium).to_numpy()\r\n \r\n excelfile_surface_branch5_low = r'excel\\flow_rate\\particle_surface_branch5_low.xlsx'\r\n inarray_surface_branch5_low = pd.read_excel(excelfile_surface_branch5_low).to_numpy()\r\n \r\n excelfile_bottom_branch5_high = r'excel\\flow_rate\\particle_bottom_branch5_high.xlsx'\r\n inarray_bottom_branch5_high = pd.read_excel(excelfile_bottom_branch5_high).to_numpy()\r\n \r\n excelfile_bottom_branch5_medium = r'excel\\flow_rate\\particle_bottom_branch5_medium.xlsx'\r\n inarray_bottom_branch5_medium = pd.read_excel(excelfile_bottom_branch5_medium).to_numpy()\r\n \r\n excelfile_bottom_branch5_low = r'excel\\flow_rate\\particle_bottom_branch5_low.xlsx'\r\n inarray_bottom_branch5_low = pd.read_excel(excelfile_bottom_branch5_low).to_numpy()\r\n \r\n \r\n #### Tracer travel time branch 5\r\n excelfile_tracer_branch5_high = r'excel\\flow_rate\\tracer_branch5_high.xlsx'\r\n inarray_tracer_branch5_high = pd.read_excel(excelfile_tracer_branch5_high).to_numpy()\r\n \r\n excelfile_tracer_branch5_medium = r'excel\\flow_rate\\tracer_branch5_medium.xlsx'\r\n inarray_tracer_branch5_medium = pd.read_excel(excelfile_tracer_branch5_medium).to_numpy()\r\n \r\n excelfile_tracer_branch5_low = r'excel\\flow_rate\\tracer_branch5_low.xlsx'\r\n inarray_tracer_branch5_low = pd.read_excel(excelfile_tracer_branch5_low).to_numpy()\r\n \r\n \r\n self.inarrays_branch5 = [inarray_surface_branch5_high, inarray_surface_branch5_medium, inarray_surface_branch5_low, \\\r\n inarray_bottom_branch5_high, inarray_bottom_branch5_medium, inarray_bottom_branch5_low, \\\r\n inarray_tracer_branch5_high, inarray_tracer_branch5_medium, inarray_tracer_branch5_low]","def main():\n start = time.time()\n fname = \"C:/Users/alexa/OneDrive/Desktop/Thesis/Bitbucket/thesisforex2/preprocessed_data/tweets_sentiment_D.txt\"\n freq = 'D'\n print ('preprocessing...\\n')\n data = d.data_tweets(fname, freq)\n size = data.get_length() \n returns_daily = data.get_return()\n tscv_outer = TimeSeriesSplit(n_splits=3)\n tscv_inner = TimeSeriesSplit(n_splits=2)\n for train, test in tscv_outer.split(returns_daily):\n X_train_outer = returns_daily.values.ravel()[train]\n adf_test(X_train_outer)\n for train_inner, val in tscv_inner.split(X_train_outer):\n adf_test(X_train_outer[train_inner])\n\n fname = \"C:/Users/alexa/OneDrive/Desktop/Thesis/Bitbucket/thesisforex2/preprocessed_data/tweets_sentiment_H.txt\"\n freq = 'H'\n print ('preprocessing...\\n')\n data = d.data_tweets(fname, freq)\n size = data.get_length() \n returns_daily = data.get_return()\n tscv_outer = TimeSeriesSplit(n_splits=10)\n tscv_inner = TimeSeriesSplit(n_splits=5)\n for train, test in tscv_outer.split(returns_daily):\n X_train_outer = returns_daily.values.ravel()[train]\n adf_test(X_train_outer)\n for train_inner, val in tscv_inner.split(X_train_outer):\n adf_test(X_train_outer[train_inner])\n\n end = time.time()\n print(end - start)","def process_timestamps(self):\n self.conn = sqlite3.connect(':memory:')\n self.cursor = self.conn.cursor()\n self.cursor.execute('CREATE TABLE tracklog(dt PRIMARY KEY, lat REAL, lon REAL, elev REAL)')\n num_points = 0\n for d in gps.parse_gpx_iter(self.gpx_file):\n self.cursor.execute('INSERT INTO tracklog VALUES(?,?,?,?)', d)\n num_points += 1\n sys.stderr.write('The GPX file contained %d Points\\n' % num_points)\n self.conn.commit()","def parse_data(filepath):\n settings = dict()\n intensity = list()\n # Boolean flags to check when to start/stop\n # reading parameters\n read_params = False\n read_int = False\n read_zeeman = False\n finished = False\n fieldoff_intensities = list()\n fieldon_intensities = list()\n with open(filepath) as read_file:\n for line in read_file:\n if \"*****\" in line:\n read_int = False\n if finished is True:\n break\n if \"Scan\" in line:\n if \"[Field ON]\" in line:\n read_zeeman = True\n scan_details = line.split()\n settings[\"ID\"] = int(scan_details[1])\n # settings[\"Date\"] = str(scan_details[4])\n read_params = True\n read_int = False\n continue\n if read_int is True:\n if read_zeeman is False:\n fieldoff_intensities += [float(value) for value in line.split()]\n else:\n fieldon_intensities += [float(value) for value in line.split()]\n finished = True\n if read_params is True and len(line.split()) > 1:\n # Read in the frequency step, frequency, and other info\n # needed to reconstruct the frequency data\n scan_params = line.split()\n shift = 1\n settings[\"Frequency\"] = float(scan_params[0])\n settings[\"Frequency step\"] = float(scan_params[1])\n if len(scan_params) == 4:\n settings[\"Multiplier\"] = 1.\n shift = 0\n # If the multiplier data is there, we don't shift the read\n # index over by one\n else:\n settings[\"Multiplier\"] = float(scan_params[2])\n settings[\"Center\"] = float(scan_params[2 + shift])\n settings[\"Points\"] = int(scan_params[3 + shift])\n read_params = False\n # Start reading intensities immediately afterwards\n read_int = True\n continue\n fieldoff_intensities = np.array(fieldoff_intensities)\n fieldon_intensities = np.array(fieldon_intensities)\n\n # Generate the frequency grid\n settings[\"Frequency step\"] = settings[\"Frequency step\"] * settings[\"Multiplier\"]\n # This calculates the length of either side\n side_length = settings[\"Frequency step\"] * (settings[\"Points\"] // 2)\n start_freq = settings[\"Frequency\"] - side_length\n end_freq = settings[\"Frequency\"] + side_length\n frequency = np.linspace(start_freq, end_freq, settings[\"Points\"])\n\n return frequency, fieldoff_intensities, fieldon_intensities, settings","def parse_trflp(lines):\r\n\r\n sample_ids = []\r\n otu_ids = []\r\n data = []\r\n non_alphanum_mask = re.compile('[^\\w|^\\t]')\r\n # not sure why the above regex doesn't cover the following regex...\r\n dash_space_mask = re.compile('[_ -]')\r\n\r\n for i, line in enumerate(lines):\r\n elements = line.strip('\\n').split('\\t')\r\n\r\n # special handling for the first line only\r\n if i == 0:\r\n # validating if the file has a header\r\n if elements[0] == '':\r\n for otu_id in elements[1:]:\r\n otu_ids.append(non_alphanum_mask.sub('_', otu_id))\r\n continue\r\n else:\r\n for j, otu_id in enumerate(elements[1:]):\r\n otu_ids.append(non_alphanum_mask.sub('_', 'Bin%3d' % j))\r\n\r\n # handling of all other lines\r\n current_row = []\r\n\r\n # converting each value in the row to int\r\n for count in elements[1:]:\r\n try:\r\n current_row.append(int(round(float(count), 0)))\r\n except ValueError:\r\n current_row.append(0)\r\n\r\n # if the sum of all the values is equial to 0 ignore line\r\n if sum(current_row) == 0:\r\n continue\r\n\r\n # adding sample header to list\r\n sample_ids.append(non_alphanum_mask.sub('.',\r\n dash_space_mask.sub('.', elements[0])))\r\n\r\n # validating the size of the headers to add missing columns\r\n # this is only valid when there is no header\r\n if len(current_row) > len(otu_ids):\r\n # modify header data\r\n extra_cols = []\r\n for j in range(len(otu_ids), len(current_row)):\r\n extra_cols.append(non_alphanum_mask.sub('_', 'Bin%3d' % j))\r\n # modify data\r\n for j in range(len(data)):\r\n data[j].extend([0] * (len(current_row) - len(otu_ids)))\r\n\r\n otu_ids.extend(extra_cols)\r\n elif len(current_row) < len(otu_ids):\r\n # modify data\r\n current_row.extend([0] * (len(otu_ids) - len(current_row)))\r\n\r\n data.append(current_row)\r\n\r\n return sample_ids, otu_ids, asarray(data).transpose()","def update_term_count_dataframes(self):\n logging.info('Starting method that updates missing Term COUNT info on disk')\n list_records_no_termcount_data_on_disk = self.__look__missing_termcount_info()\n num_missing_tc_entries = len(list_records_no_termcount_data_on_disk)\n counter = 0\n num_vids_success = 0\n percent_tracker = PercentTracker(num_missing_tc_entries,\n int_output_every_x_percent=1, log_level='info')\n logging.info(str(num_missing_tc_entries) + \" records don't have term-COUNT data on disk.\")\n for a_vid in list_records_no_termcount_data_on_disk:\n execution_should_continue = self.var_mgr.var_retrieve(my_globals.str_execution_may_go_on)\n if not execution_should_continue:\n break\n # we'll only update the timestamp in the SimpleDS if there is an actual change\n # to the transcript. So here, we'll keep the existing timestamp\n timestamp_updated = self.transcripts_ds.fetch_lastupdated(a_vid)\n logging.info('Updating term COUNT for record # ' + str(counter + 1) + ' of ' + str(num_missing_tc_entries))\n transcript = Transcript(a_vid)\n transcript.set_transcript_directory(self.str_path_to_transcripts_files)\n transcript.load_transcript_object_from_dictionary(self.transcripts_ds.fetch_data(a_vid))\n transcript.get_transcript_from_disk()\n transcript.construct_terms_count()\n saved_to_disk_successfully = transcript.save_df_terms_count_2disk()\n dict_for_ds = transcript.dump_transcript_metadata_to_dictionary()\n self.transcripts_ds.update_entry(a_vid, dict_for_ds, timestamp_updated)\n logging.debug('Added (to SimpleDS) the term-COUNT data for entry: ' + a_vid)\n if saved_to_disk_successfully:\n num_vids_success += 1\n counter += 1\n percent_tracker.update_progress(counter, show_time_remaining_estimate=True,\n str_description_to_include_in_logging='Updating Term Count files.')\n logging.info(\"Successfully saved to disk term-count data for \" + str(num_vids_success) + ' records.')\n logging.info(\"Records processed: \" + str(counter))\n self.transcripts_ds.save2disk()","def readFiles(self):\n #return a list of traces\n alltraces = []\n for dfile in self._datafiles:\n traces,headers = readgeonet(dfile)\n alltraces += traces\n return alltraces","def parse(self, f):\n \n for line in f:\n self.parse_line(line)","def processData(inputDataPath):\n\n\t### Define paths\n\tfileParts = inputDataPath.split('/')\n\tSUBJ = fileParts[-2]\n\tOUTPUT_dir = ('/').join(fileParts[:-1])\n\n\tEXP_dir = ('/').join(fileParts[:-3])\n\tSTIM_dir = join(EXP_dir, 'Stimuli')\n\n\t# Read raw data as dataframe\n\traw_df = pd.read_table(inputDataPath)\n\n\t# loop through all unique trials\n\tfor i, trial in enumerate(np.unique(raw_df['trialNum'])):\n\n\t\t# grab trial data\n\t\ttrial_df = raw_df[(raw_df.trialNum == trial)]\n\n\t\t#####################################\n\t\t### Step 1: Filter Raw Data\n\t\t#####################################\n\t\ttrial_filtered = filt.filterRaw(trial_df)\n\n\t\t\n\t\t#####################################\n\t\t### Step 2: Define Fixations on filtered dataframe\n\t\t#####################################\n\t\ttrial_filtered = filt.defineFixations(trial_filtered)\n\n\n\t\t#####################################\n\t\t### Step 3: Summarize Each Fixation\n\t\t#####################################\n\t\t\n\t\t# check if there's an AOI for this trial\n\t\tstimName = trial_filtered.imageName.iloc[0]\n\t\tAOI_name = stimName.split('/')[1][:-4] + '_AOIs.png'\n\t\tAOI_path = join(STIM_dir, 'AOIs/finished_AOIs', AOI_name)\n\t\tif not os.path.exists(AOI_path):\n\t\t\tAOI_path = None\n\n\t\t# summarize fixations (label AOIs, if applicable)\n\t\ttrial_fixations= filt.summarizeFixations(trial_filtered, AOI_path)\n\n\n\t\t#####################################\n\t\t### Step 4: Summarize Trial Overall\n\t\t#####################################\n\t\ttrial_summary = filt.summarizeTrial(trial_fixations)\n\n\n\t\t#####################################\n\t\t### Store this trial's output in master dataframes\n\t\t#####################################\n\t\tif i == 0:\n\t\t\tallTrials_filtered = trial_filtered.copy()\n\t\t\tallTrials_fixations = trial_fixations.copy()\n\t\t\tallTrials_summaries = pd.DataFrame(trial_summary).T # convert trial_summary from series to dataframe\n\t\telse:\n\t\t\tallTrials_filtered = pd.concat([allTrials_filtered, trial_filtered], ignore_index=True)\n\t\t\tallTrials_fixations = pd.concat([allTrials_fixations, trial_fixations], ignore_index=True)\n\t\t\tallTrials_summaries = pd.concat([allTrials_summaries, pd.DataFrame(trial_summary).T], ignore_index=True)\n\n\n\t### Write all output to the disk for this subject\n\t# filtered data\n\tallTrials_filtered.to_csv(join(OUTPUT_dir, (SUBJ + '_filtered.tsv')), \n\t\t\t\t\t\t\t\tsep='\\t',\n\t\t\t\t\t\t\t\theader=True,\n\t\t\t\t\t\t\t\tindex=False,\n\t\t\t\t\t\t\t\tfloat_format='%.3f')\n\t\n\t# fixation data\n\tfixColOrder = ['trialNum', 'imageName', 'crossX', 'crossY',\n\t\t\t\t\t'fixNumber', 'duration','fixPosX', 'fixPosY',\n\t\t\t\t\t'dirFromPrev', 'distFromPrev', 'distFromCenter',\n\t\t\t\t\t'AOI', 'horizHemi', 'vertHemi']\n\tallTrials_fixations[fixColOrder].to_csv(join(OUTPUT_dir, (SUBJ + '_fixations.tsv')), \n\t\t\t\t\t\t\t\tsep='\\t',\n\t\t\t\t\t\t\t\theader=True,\n\t\t\t\t\t\t\t\tindex=False,\n\t\t\t\t\t\t\t\tfloat_format='%.2f')\n\n\t# summary data\n\tsummaryColOrder = ['trialNum', 'imageName', 'leftEye', 'rightEye', 'eyesCombined',\n\t\t\t\t\t\t'nose', 'mouth', 'none', 'nonFixation',\n\t\t\t\t\t\t'left', 'right', 'top', 'bot']\n\tallTrials_summaries[summaryColOrder].to_csv(join(OUTPUT_dir, (SUBJ + '_trialSummary.tsv')), \n\t\t\t\t\t\t\t\tsep='\\t',\n\t\t\t\t\t\t\t\theader=True,\n\t\t\t\t\t\t\t\tindex=False,\n\t\t\t\t\t\t\t\tfloat_format='%.2f')","def perform(self):\n if self.driver.owner != self.name:\n self.driver.owner = self.name\n\n channel = self.driver.get_channel(self.trace)\n data = channel.read_data_complete(self.highres)\n\n msg = 'Coupling {}, Average number {}'\n oscillo_config = msg. format(channel.sweep, data['VERT_COUPLING'])\n self.write_in_database('oscillo_config', oscillo_config)\n\n # if the TrigArray lentgh is null, it's a simple single sweep waveform\n if data['TRIGTIME_ARRAY'][0] == 0:\n arr = np.rec.fromarrays([data['SingleSweepTimesValuesArray'],\n data['Volt_Value_array']],\n names=['Time (s)', 'Voltage (V)'])\n self.write_in_database('trace_data', arr)\n else:\n arr = np.rec.fromarrays([data['SEQNCEWaveformTimesValuesArray'],\n data['Volt_Value_array']],\n names=['Time (s)', 'Voltage (V)'])\n self.write_in_database('trace_data', )","def read_results(self):\n\n myfile = open(os.path.join(self.directory, 'results.tag'), 'r')\n self.lines = myfile.readlines()\n myfile.close()\n\n # print('atoms before read', self.atoms)\n # print('atoms_input before read', self.atoms_input)\n\n self.atoms = self.atoms_input\n\n charges, energy, free_energy = self.read_charges_and_energy()\n if charges is not None:\n self.results['charges'] = charges\n\n self.results['energy'] = energy\n self.results['free_energy'] = free_energy\n\n if self.do_forces:\n forces = self.read_forces()\n self.results['forces'] = forces\n\n self.mmpositions = None\n\n # stress stuff begins\n sstring = 'stress'\n have_stress = False\n stress = list()\n for iline, line in enumerate(self.lines):\n if sstring in line:\n have_stress = True\n start = iline + 1\n end = start + 3\n for i in range(start, end):\n cell = [float(x) for x in self.lines[i].split()]\n stress.append(cell)\n if have_stress:\n stress = -np.array(stress) * Hartree / Bohr**3\n self.results['stress'] = stress.flat[[0, 4, 8, 5, 2, 1]]\n # stress stuff ends\n\n # TODO: these two seem wrong with DFTB+ master but compatible with 19.1\n # eigenvalues and fermi levels\n #fermi_levels = self.read_fermi_levels()\n #if fermi_levels is not None:\n # self.results['fermi_levels'] = fermi_levels\n #\n #eigenvalues = self.read_eigenvalues()\n #if eigenvalues is not None:\n # self.results['eigenvalues'] = eigenvalues\n\n # calculation was carried out with atoms written in write_input\n os.remove(os.path.join(self.directory, 'results.tag'))","def readOutputfile(filename, verbose=False):\n\n # -----------------------------------------------------------------------------\n # Defining the classes for data structure\n T_Simulation = namedtuple('Simulation', ['step'])\n T_Step = namedtuple('Step', ['element', 'node'])\n\n T_Displacement = namedtuple('Displacement', ['ux', 'uy'])\n\n T_Element = namedtuple('Element', ['gp', 'avstrain', 'avstress', 'eqstrain'])\n T_GP = namedtuple('GP', ['stress', 'strain'])\n T_Stresses = namedtuple('Stresses', ['xx', 'yy', 'zz', 'yz', 'zx', 'xy'])\n T_Strains = namedtuple('Strains', ['xx', 'yy', 'zz', 'yz', 'zx', 'xy'])\n # -----------------------------------------------------------------------------\n\n nSteps = 0 # Simulation step counter\n\n SimData = T_Simulation(list())\n\n with open(filename) as f:\n line = f.readline() # Read in the first line of the input file\n while True: # Loop over all lines of the input file\n # Read the nodes displacements\n #line = f.readline()\n #print(line)\n if line == 'DofManager output:\\n': # String starts a list of nodes displacement information\n nSteps += 1 # The above string starts a new simulation step\n line = f.readline() # Cancel ---------- seperator\n line = f.readline()\n Nodes = list() # Initialize/clear list of nodes\n\n while line != '\\n' and line != 'Element output:\\n': # Strings that finish the list\n #\t\t\t\tnNode = int(line.strip().split()[1]) # Node id\n line = f.readline()\n dim1 = float(line.strip().split()[3]) # Displacement dim1\n line = f.readline()\n dim2 = float(line.strip().split()[3]) # Displacement dim2\n Nodes.append(\n T_Displacement(dim1, dim2)) # Append displacements of the current node to the node list\n line = f.readline()\n\n\n if verbose:\n print('Step {}: Dofs completed.\\n'.format(nSteps))\n print('---------------------------------\\n')\n\n # Read the stresses an strains at Gauss points\n elif line == 'Element output:\\n': # String starts a list elements, GPs, strains and stresses\n line = f.readline() # Cancel ---------- seperator\n line = f.readline()\n Elements = list() # Initialize/clear list of elements\n\n while line != '\\n' and line != '\\tR E A C T I O N S O U T P U T:\\n': # Strings that finish the list\n #\t\t\t\t\tnElement = line.strip().split()[2] # Element id\n line = f.readline()\n GPs = T_Element(list(), 0, 0, 0) # List of Gauss points\n\n while line != '\\n' and line.strip().split()[0] == 'GP': # String that starts a new GP\n #\t\t\t\t\t\tnGP = int(line.strip().split()[1].split('.')[1]) # GP id\n tmp = [float(i) for i in line.strip().split()[4:10]] # Read the strains\n strain = T_Strains(tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5])\n line = f.readline()\n tmp = [float(i) for i in line.strip().split()[1:7]] # Read the stresses\n stress = T_Stresses(tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5])\n GPs.gp.append(\n T_GP(stress, strain)) # Append stresses and strains of the current GP to the GP list\n line = f.readline()\n\n\n Elements.append(GPs) # Append GP list of the current element to the element list\n\n if verbose:\n print('Step {}: GPs completed.\\n'.format(nSteps))\n print('---------------------------------\\n')\n\n SimData.step.append(T_Step(Elements, Nodes)) # Append element and node list of the current step to the step list\n #print('the file input ends')\n #print(nSteps)\n # only needed with a while loop\n # Jump over the lines until we reach the next time step (Caught by if-clause)\n try:\n line = f.readline() # Will generate an error if files end is reached\n if line == \"\":\n raise EOFError\n except:\n if verbose: print(\"End of file reached.\\n\")\n break # Break the 'while True' loop\n\n # -----------------------------------------------------------------------------\n\n\n print('averaging the stress')\n # Averaging of strains and stress of GPs of each element\n for istep in range(len(SimData.step)):\n\n for ielement in range(len(SimData.step[istep].element)):\n print(len)\n # Initialization before each element\n stresses = np.array([0., 0., 0., 0., 0., 0.])\n strains = np.array([0., 0., 0., 0., 0., 0.])\n\n for igp in range(len(SimData.step[istep].element[ielement])):\n print(igp)\n # Add up all data of all GPs\n #stresses[:] += SimData.step[istep].element[ielement].gp[igp].stress[:]\n strains[:] += SimData.step[istep].element[ielement].gp[igp].strain[:]\n\n # Divide GP sum by number of GPs\n stresses /= len(SimData.step[istep].element[ielement])\n strains /= len(SimData.step[istep].element[ielement])\n # Replace the field (initialized with 0) with new information\n SimData.step[istep].element[ielement] = SimData.step[istep].element[ielement]._replace(\n avstress=T_Stresses(stresses[0], stresses[1], stresses[2], stresses[3], stresses[4], stresses[5]))\n SimData.step[istep].element[ielement] = SimData.step[istep].element[ielement]._replace(\n avstrain=T_Strains(strains[0], strains[1], strains[2], strains[3], strains[4], strains[5]))\n print('Analysis finished')\n return SimData","def process_meter():\n\n if not os.path.isdir(out_dir):\n os.mkdir(out_dir)\n\n allRhymeInfo = {}\n\n for filename in os.listdir(in_dir):\n if not filename.endswith(\".txt\"):\n continue\n\n fileRhymeInfo = {\n \"scheme\": [],\n \"endWords\": [],\n \"tidied\": [],\n }\n\n with open(in_dir + filename, \"r\", encoding=\"utf-8\") as f:\n txt = f.read()\n\n # Assume standard line break structure.\n # Split on \"\\n\\n\"\n segs = txt.split(\"\\n\\n\")\n\n # Print to a new file\n with open(out_dir + filename, \"w\", encoding=\"utf-8\") as f:\n for seg in segs:\n scheme, rhymingWords, tidiedLines = findRhymes(seg)\n\n # add info to file's dictionary to be returned\n fileRhymeInfo[\"segs\"].append(seg)\n fileRhymeInfo[\"scheme\"].append(scheme)\n fileRhymeInfo[\"endWords\"].append(rhymingWords)\n fileRhymeInfo[\"tidied\"].append(tidiedLines)\n\n # write info out to file\n for i, ln in enumerate(tidiedLines):\n # First line in seg is header; no rhymes\n if i == 0:\n print(ln, file=f)\n continue\n\n # Later lines: print original line, plus a rhyme tag\n w = rhymingWords[i-1]\n s = scheme[i-1]\n\n print(f\"{ln:45s} [{w:^12s}]: ({s})\", file=f)\n print(file=f)\n\n allRhymeInfo[filename] = fileRhymeInfo\n return allRhymeInfo","def read_snfit_results(self, snfit_res_path='../sugar_analysis_data/results/results_snfit.txt'):\n\n snfit_res = open (snfit_res_path)\n \n self.sn_name = []\n self.z = []\n self.x0 =[]\n self.x0_err = []\n self.x1 =[]\n self.x1_err = []\n self.c = []\n self.c_err = []\n self.mb = []\n self.mb_err = []\n self.cov_x0_x1 = [] \n self.cov_x0_c = []\n self.cov_x1_c = []\n self.cov_mb_x1 = []\n self.cov_mb_c = []\n self.snfit_chi2 = []\n snfit_lines = snfit_res.readlines()\n \n line_name = 0\n \n for line in range(len(snfit_lines)):\n \n snfit_lines[line] = snfit_lines[line].strip()\n snfit_lines[line] = snfit_lines[line].split(' ')\n snfit_lines[line]=[x.replace('\\n','') for x in snfit_lines[line]]\n snfit_lines[line]=[x.replace(\"'\",'') for x in snfit_lines[line]]\n \n if snfit_lines[line][0] == 'sn_name': \n self.sn_name.append(snfit_lines[line][1])\n line_name = line\n \n if snfit_lines[line][0] == 'Redshift' and line == line_name + 35 : \n self.z.append(float(snfit_lines[line][1])) \n \n if snfit_lines[line][0] == 'X0' and line == line_name + 37: \n self.x0.append(float(snfit_lines[line][1])) \n self.x0_err.append(float(snfit_lines[line][2]))\n \n if snfit_lines[line][0] == 'X1' and line == line_name + 38 : \n self.x1.append(float(snfit_lines[line][1])) \n self.x1_err.append(float(snfit_lines[line][2]))\n \n if snfit_lines[line][0] == 'Color' and line == line_name + 36: \n self.c.append(float(snfit_lines[line][1]))\n self.c_err.append(float(snfit_lines[line][2]))\n \n if snfit_lines[line][0] == 'RestFrameMag_0_B' and line == line_name + 39 : \n self.mb.append(float(snfit_lines[line][1])) \n self.mb_err.append(float(snfit_lines[line][2]))\n \n if snfit_lines[line][0] == 'CovX0X1' and line == line_name + 52: \n self.cov_x0_x1.append(float(snfit_lines[line][1]))\n \n if snfit_lines[line][0] == 'CovColorX0' and line == line_name + 43: \n self.cov_x0_c.append(float(snfit_lines[line][1])) \n \n \n if snfit_lines[line][0] == 'CovColorX1' and line == line_name + 44: \n self.cov_x1_c.append(float(snfit_lines[line][1]))\n \n if snfit_lines[line][0] == 'CovColorRestFrameMag_0_B' and line == line_name + 42: \n self.cov_mb_c.append(float(snfit_lines[line][1]))\n \n if snfit_lines[line][0] == 'CovRestFrameMag_0_BX1' and line == line_name + 50: \n self.cov_mb_x1.append(float(snfit_lines[line][1])) \n\n if snfit_lines[line][0] == '@CHI2_LC' and line == line_name + 56: \n self.snfit_chi2.append(float(snfit_lines[line][1])) \n \n self.sn_name = np.array(self.sn_name,str)\n self.z = np.array(self.z)\n self.x0 = np.array(self.x0)\n self.x0_err = np.array(self.x0_err)\n self.x1 = np.array(self.x1)\n self.x1_err = np.array(self.x1_err) \n self.c = np.array(self.c)\n self.c_err = np.array(self.c_err)\n self.mb = np.array(self.mb)\n self.mb_err = np.array(self.mb_err)\n self.cov_x0_x1 = np.array(self.cov_x0_x1)\n self.cov_x0_c = np.array(self.cov_x0_c)\n self.cov_x1_c = np.array(self.cov_x1_c)\n self.cov_mb_x1 = np.array(self.cov_mb_x1)\n self.cov_mb_c = np.array(self.cov_mb_c) \n self.snfit_chi2 = np.array(self.snfit_chi2)","def crapome_parser():\n import os.path\n \n # contTreshold = 30 # set this to the desired contamination score\n resD = {}\n \n # crapFile = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \"data\", \"cav1ko\", \"processed\", \"1503486016360_gp-1.txt\"),\"rU\")\n crapFile = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \"data\", \"Crapome-all-proteins-ptpn22-ip-ctl.txt\"),\"rU\")\n \n headerFlag = True\n \n fileLength = 0\n for inpLine in crapFile: # parse crapome output file\n if headerFlag:\n headerFlag = False\n continue\n fileLength += 1\n lineList = inpLine.split(\"\\t\")\n if lineList[2] == \"\": continue\n elif len(lineList) > 2: contScore = int(lineList[2].split(\"/\")[0])\n else: contScore = 0\n \n # if contScore < contTreshold:\n resD[lineList[0]] = contScore\n \n # print \"Contaminant treshold: \" + str(contTreshold)\n \n print(\"lines parsed: \" + str(fileLength))\n print(\"Number of results: \" + str(len(resD)))\n \n # inpFile = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \"data\", \"cav1ko\", \"processed\", \"cav1ko-1_no0.csv\"),\"r\")\n # outF = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \"data\", \"cav1ko\", \"processed\", \"cav1ko-1_no0_crapome.csv\"),\"w\")\n inpFile = open(os.path.join(\"/home/mate/workspace/katamari/src/ed/bob/processed\", \"OST-24-05-2017_combined_ttest_ed_2.csv\"),\"rU\")\n outF = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \"data\", \"processed\", \"OST-24-05-2017_combined_ttest_ed_2_cr.csv\"),\"w\")\n\n \n \n headerFlag = True\n for inpLine in inpFile: # parse the input file for crapome and add crapome results to it\n inpList = inpLine.rstrip(\"\\n\").split(\",\")\n for inpI in inpList:\n outF.write(inpI + \",\")\n \n if headerFlag: \n outF.write(\"Crapome score\")\n headerFlag = False\n elif inpList[2].upper() in resD: outF.write(str(resD[inpList[2].upper()]))\n else: outF.write(\"0\")\n \n outF.write(\"\\n\")\n print(\"results written to file\")","def read_results(self):\n\n with open(os.path.join(self.directory, 'results.tag'), 'r') as fd:\n self.lines = fd.readlines()\n\n self.atoms = self.atoms_input\n self.results['energy'] = float(self.lines[1])*Hartree\n forces = self.read_forces()\n self.results['forces'] = forces\n\n # stress stuff begins\n sstring = 'stress'\n have_stress = False\n stress = list()\n for iline, line in enumerate(self.lines):\n if sstring in line:\n have_stress = True\n start = iline + 1\n end = start + 3\n for i in range(start, end):\n cell = [float(x) for x in self.lines[i].split()]\n stress.append(cell)\n if have_stress:\n stress = -np.array(stress) * Hartree / Bohr**3\n self.results['stress'] = stress.flat[[0, 4, 8, 5, 2, 1]]\n # stress stuff ends\n\n # calculation was carried out with atoms written in write_input\n os.remove(os.path.join(self.directory, 'results.tag'))","def process_results(stadict,dir,ot):\n # If the absolute value of linearity \n ignore_linearity=0.90\n # Process our output\n csvfile=\"%s/Results.csv\" % (dir)\n csv=open(csvfile,'r')\n hl=csv.readline() # Read the header\n for line in csv:\n lvals=line.split(',')\n nsl=\"%s-%s-%s\" % (lvals[0],lvals[1],lvals[2])\n difference=float(lvals[3])-float(lvals[4])\n linearity=np.abs(float(lvals[6]))\n if linearity>=ignore_linearity: #Could move this to the plot section but it adds complexity if you do\n stadict=add_azi_measurement(stadict,nsl,ot,difference,linearity)\n return stadict","def tracers(traceField = 'bb', hMin = 2e-3, hMax = 2e4, lMax = 500, tol = 1e-2,\n interpolation = 'weighted', trace_sub = 1, intQ = [''], varfile = 'VAR0',\n ti = -1, tf = -1,\n integration = 'simple', datadir = 'data/', destination = 'tracers.dat', nproc = 1):\n\n # returns the tracers for the specified starting locations\n def subTracers(q, vv, p, tracers0, iproc, hMin = 2e-3, hMax = 2e4, lMax = 500, tol = 1e-2, \n interpolation = 'weighted', integration = 'simple', intQ = ['']):\n \n tracers = tracers0\n mapping = np.zeros((tracers.shape[0], tracers.shape[1], 3))\n \n for ix in range(tracers.shape[0]):\n for iy in range(tracers.shape[1]):\n xx = tracers[ix, iy, 2:5].copy()\n s = pc.stream(vv, p, interpolation = interpolation, integration = integration, hMin = hMin, hMax = hMax, lMax = lMax, tol = tol, xx = xx)\n tracers[ix, iy, 2:5] = s.tracers[s.sl-1]\n tracers[ix, iy, 5] = s.l\n if (any(intQ == 'curlyA')):\n for l in range(s.sl-1):\n aaInt = pc.vecInt((s.tracers[l+1] + s.tracers[l])/2, aa, p, interpolation)\n tracers[ix, iy, 6] += np.dot(aaInt, (s.tracers[l+1] - s.tracers[l]))\n \n # create the color mapping\n if (tracers[ix, iy, 4] > grid.z[-2]):\n if (tracers[ix, iy, 0] - tracers[ix, iy, 2]) > 0:\n if (tracers[ix, iy, 1] - tracers[ix, iy, 3]) > 0:\n mapping[ix, iy, :] = [0,1,0]\n else:\n mapping[ix, iy, :] = [1,1,0]\n else:\n if (tracers[ix, iy, 1] - tracers[ix, iy, 3]) > 0:\n mapping[ix, iy, :] = [0,0,1]\n else:\n mapping[ix, iy, :] = [1,0,0]\n else:\n mapping[ix, iy, :] = [1,1,1]\n \n q.put((tracers, mapping, iproc))\n \n \n # multi core setup\n if (np.isscalar(nproc) == False) or (nproc%1 != 0):\n print(\"error: invalid processor number\")\n return -1\n queue = mp.Queue()\n \n # read the data\n # make sure to read the var files with the correct magic\n if (traceField == 'bb'):\n magic = 'bb'\n if (traceField == 'jj'):\n magic = 'jj'\n if (traceField == 'vort'):\n magic = 'vort'\n \n # convert intQ string into list\n if (isinstance(intQ, list) == False):\n intQ = [intQ]\n intQ = np.array(intQ)\n \n grid = pc.read_grid(datadir = datadir, trim = True, quiet = True) \n dim = pc.read_dim(datadir = datadir) \n tol2 = tol**2\n \n # check if user wants a tracer time series\n if ((ti%1 == 0) and (tf%1 == 0) and (ti >= 0) and (tf >= ti)):\n series = True\n n_times = tf-ti+1\n else:\n series = False\n n_times = 1\n \n tracers = np.zeros([int(trace_sub*dim.nx), int(trace_sub*dim.ny), n_times, 6+len(intQ)])\n mapping = np.zeros([int(trace_sub*dim.nx), int(trace_sub*dim.ny), n_times, 3])\n t = np.zeros(n_times)\n \n for tIdx in range(n_times):\n if series:\n varfile = 'VAR' + str(tIdx)\n \n # read the data\n var = pc.read_var(varfile = varfile, datadir = datadir, magic = magic, quiet = True, trimall = True) \n grid = pc.read_grid(datadir = datadir, quiet = True, trim = True)\n t[tIdx] = var.t\n \n # extract the requested vector traceField\n vv = getattr(var, traceField)\n if (any(intQ == 'curlyA')):\n aa = var.aa\n \n # initialize the parameters\n p = pc.pClass()\n p.dx = var.dx; p.dy = var.dy; p.dz = var.dz\n p.Ox = var.x[0]; p.Oy = var.y[0]; p.Oz = var.z[0]\n p.Lx = grid.Lx; p.Ly = grid.Ly; p.Lz = grid.Lz\n p.nx = dim.nx; p.ny = dim.ny; p.nz = dim.nz\n \n # initialize the tracers\n for ix in range(int(trace_sub*dim.nx)):\n for iy in range(int(trace_sub*dim.ny)):\n tracers[ix, iy, tIdx, 0] = grid.x[0] + int(grid.dx/trace_sub)*ix\n tracers[ix, iy, tIdx, 2] = tracers[ix, iy, tIdx, 0]\n tracers[ix, iy, tIdx, 1] = grid.y[0] + int(grid.dy/trace_sub)*iy\n tracers[ix, iy, tIdx, 3] = tracers[ix, iy, tIdx, 1]\n tracers[ix, iy, tIdx, 4] = grid.z[0]\n \n # declare vectors\n xMid = np.zeros(3)\n xSingle = np.zeros(3)\n xHalf = np.zeros(3)\n xDouble = np.zeros(3)\n \n tmp = []\n subTracersLambda = lambda queue, vv, p, tracers, iproc: \\\n subTracers(queue, vv, p, tracers, iproc, hMin = hMin, hMax = hMax, lMax = lMax, tol = tol,\n interpolation = interpolation, integration = integration, intQ = intQ)\n proc = []\n for iproc in range(nproc):\n proc.append(mp.Process(target = subTracersLambda, args = (queue, vv, p, tracers[iproc::nproc,:,tIdx,:], iproc)))\n for iproc in range(nproc):\n proc[iproc].start()\n for iproc in range(nproc):\n tmp.append(queue.get())\n for iproc in range(nproc):\n proc[iproc].join()\n for iproc in range(nproc):\n tracers[tmp[iproc][2]::nproc,:,tIdx,:], mapping[tmp[iproc][2]::nproc,:,tIdx,:] = (tmp[iproc][0], tmp[iproc][1])\n for iproc in range(nproc):\n proc[iproc].terminate()\n \n tracers = np.copy(tracers.swapaxes(0, 3), order = 'C')\n if (destination != ''):\n f = open(datadir + destination, 'wb')\n f.write(np.array(trace_sub, dtype = 'float32'))\n # write tracers into file\n for tIdx in range(n_times):\n f.write(t[tIdx].astype('float32'))\n f.write(tracers[:,:,tIdx,:].astype('float32'))\n f.close()\n \n tracers = tracers.swapaxes(0, 3)\n tracers = tracers.swapaxes(0, 1)\n mapping = mapping.swapaxes(0, 1)\n\n return tracers, mapping, t","def main():\n # Load and parse json object from file with specific\n file_name = \"./benchmark.log\"\n doc = re.sub(\"[\\n|\\t]\", \"\", \"\".join(benchmark.read_text_file(file_name)))\n json_object = json.loads(\"\".join(doc))\n\n intervals = json_object[\"intervals\"]\n\n socket_keys = benchmark.get_socket_keys(intervals)\n\n result = benchmark.get_result_dictionary(intervals, socket_keys)\n\n print_to_csv(result, socket_keys)","def clean_trace(trace):\n\n df = pd.read_csv(trace, delimiter=' ', header=None)\n \n # Meaningful column names\n df.columns = ['Timestamp', 'Direction', 'dummy1', 'Circuit', \n 'dummy2', 'Stream', 'dummy3', 'Command',\n 'dummy4', 'Length']\n\n # Drop unnecessary columns\n df.drop(['dummy1', 'dummy2', 'dummy3', 'dummy4'], axis=1, inplace=True)\n\n # Dump trash commas and fix data types\n df['Circuit'] = df['Circuit'].apply(lambda x: x.rstrip(',')).astype('int')\n df['Stream'] = df['Stream'].apply(lambda x: x.rstrip(',')).astype('int')\n df['Command'] = df['Command'].apply(lambda x: x.rstrip(','))\n \n # Make an elapsed time in seconds column\n df['Elapsed Time'] = df['Timestamp'] - df['Timestamp'].iloc[0]\n return df","def parse(self, limit=None):\n if limit is not None:\n logger.info(\"Only parsing first %d rows of each file\", limit)\n logger.info(\"Parsing files...\")\n\n if self.testOnly:\n self.testMode = True\n\n # the following will provide us the hash-lookups\n self._process_dbxref()\n self._process_cvterm()\n self._process_genotypes(limit)\n self._process_pubs(limit)\n # do this before environments to get the external ids\n self._process_environment_cvterm()\n self._process_environments()\n self._process_organisms(limit) # must be done before features\n self._process_organism_dbxref(limit)\n self._process_features(limit)\n self._process_phenotype(limit)\n self._process_phenotype_cvterm()\n # gets external mappings for features (genes, variants, etc)\n self._process_feature_dbxref(limit)\n # do this after organisms to get the right taxonomy\n self._process_stocks(limit)\n # figures out types of some of the features\n self._get_derived_feature_types(limit)\n\n # These are the associations amongst the objects above\n self._process_stockprop(limit)\n self._process_pub_dbxref(limit)\n self._process_phendesc(limit)\n self._process_feature_genotype(limit)\n self._process_feature_pub(limit)\n self._process_stock_genotype(limit)\n self._process_phenstatement(limit) # these are G2P associations\n\n self._process_feature_relationship(limit)\n\n self._process_disease_models(limit)\n # TODO add version info from file somehow\n # (in parser rather than during fetching)\n\n logger.info(\"Finished parsing.\")\n logger.info(\"Loaded %d nodes\", len(self.graph))\n return","def writeStats(inDir, outFname):\n ofh = open(outFname, \"w\")\n ofh.write(\"meta\\tkallistoProcReads\\tkallistoAlnReads\\tkallistoEstFragLen\\n\")\n\n inFnames = glob.glob(join(inDir, \"log\", \"*.log\"))\n print(\"Parsing %d logfiles and writing to %s\" % (len(inFnames), outFname))\n for inFname in inFnames:\n cellId = basename(inFname).split(\".\")[0].split(\"_\")[0]\n # [quant] processed 1,836,518 reads, 636,766 reads pseudoaligned\n # [quant] estimated average fragment length: 251.99\n for line in open(inFname):\n if line.startswith(\"[quant] processed \"):\n words = line.split()\n readCount = words[2].replace(\",\",\"\")\n alignCount = words[4].replace(\",\",\"\")\n if line.startswith(\"[quant] estimated average fragment length:\"):\n fragLen = line.split()[5]\n row = [cellId, readCount, alignCount, fragLen]\n ofh.write(\"\\t\".join(row)+\"\\n\")\n ofh.close()","def emit_metrics(self):\n parse_time = time.perf_counter() - self._parsing_start_time\n Stats.gauge(\"dag_processing.total_parse_time\", parse_time)\n Stats.gauge(\"dagbag_size\", sum(stat.num_dags for stat in self._file_stats.values()))\n Stats.gauge(\n \"dag_processing.import_errors\", sum(stat.import_errors for stat in self._file_stats.values())\n )","def summarize_tsvs(\n self,\n tsv_dir,\n dd,\n prefix=\"\",\n outlier_threshold=10,\n omit_props=[\n \"project_id\",\n \"type\",\n \"id\",\n \"submitter_id\",\n \"case_submitter_id\",\n \"case_ids\",\n \"visit_id\",\n \"sample_id\",\n \"md5sum\",\n \"file_name\",\n \"object_id\",\n \"series_uid\",\n \"study_uid\",\n \"token_record_id\"\n ],\n omit_nodes=[\"metaschema\", \"root\", \"program\", \"project\", \"data_release\"],\n outdir=\".\",\n bin_limit=False,\n write_report=True,\n report_null=True,\n ):\n\n summary = {}\n\n report = pd.DataFrame(\n columns=[\n \"prop_id\",\n \"project_id\",\n \"node\",\n \"property\",\n \"type\",\n \"N\",\n \"nn\",\n \"null\",\n \"perc_null\",\n \"all_null\",\n \"min\",\n \"max\",\n \"median\",\n \"mean\",\n \"stdev\",\n \"outliers\",\n \"bin_number\",\n \"bins\",\n ]\n )\n report[\"all_null\"] = report[\"all_null\"].astype(bool)\n\n dir_pattern = \"{}*{}\".format(prefix, \"tsvs\")\n project_dirs = glob.glob(\"{}/{}\".format(tsv_dir, dir_pattern))\n\n nn_nodes, nn_props, null_nodes, null_props, all_prop_ids = [], [], [], [], []\n\n msg = \"Summarizing TSVs in '{}':\\n\".format(tsv_dir)\n print(\"\\n\\n{}\".format(msg))\n\n for project_dir in project_dirs: # project_dir=project_dirs[0]\n\n try:\n project_id = re.search(\n r\"^{}/?([A-Za-z0-9_-]+)_tsvs$\".format(tsv_dir), project_dir\n ).group(1)\n except:\n print(\n \"Couldn't extract the project_id from project_dir '{}'!\".format(\n project_dir\n )\n )\n\n fpattern = \"{}*{}\".format(prefix, \".tsv\")\n fnames = glob.glob(\"{}/{}\".format(project_dir, fpattern))\n\n # msg = \"\\t\\tFound the following {} TSVs: {}\".format(len(fnames),fnames)\n # sys.stdout.write(\"\\r\" + str(msg))\n\n # print(fnames) # trouble-shooting\n if len(fnames) == 0:\n continue\n\n for (\n fname\n ) in (\n fnames\n ): # Each node with data in the project is in one TSV file so len(fnames) is the number of nodes in the project with data.\n\n # print(\"\\n\\t\\t{}\".format(fname)) # trouble-shooting\n\n node_regex = (\n re.escape(project_id) + r\"_([a-zA-Z0-9_]+)\\.tsv$\"\n ) # node = re.search(r'^([a-zA-Z0-9_]+)-([a-zA-Z0-9]+)_([a-zA-Z0-9_]+)\\.tsv$',fname).group(3)\n\n try:\n node = re.search(node_regex, fname, re.IGNORECASE).group(1)\n\n except Exception as e:\n print(\n \"\\n\\nCouldn't set node with node_regex on '{}':\\n\\t{}\".format(\n fname, e\n )\n )\n node = fname\n\n df = pd.read_csv(fname, sep=\"\\t\", header=0, dtype=str)\n\n if df.empty:\n print(\"\\t\\t'{}' TSV is empty. No data to summarize.\\n\".format(node))\n\n else:\n nn_nodes.append(node)\n prop_regex = re.compile(\n r\"^[A-Za-z0-9_]*[^.]$\"\n ) # drop the links, e.g., cases.submitter_id or diagnoses.id (matches all properties with no \".\")\n props = list(\n filter(prop_regex.match, list(df))\n ) # properties in this TSV to summarize\n props = [\n prop for prop in props if prop not in omit_props\n ] # omit_props=['project_id','type','id','submitter_id','case_submitter_id','case_ids','visit_id','sample_id','md5sum','file_name','object_id']\n\n # msg = \"\\t\\tTotal of {} records in '{}' TSV with {} properties.\".format(len(df),node,len(props))\n # sys.stdout.write(\"\\r\"+str(msg))\n\n for prop in props: # prop=props[0]\n\n prop_name = \"{}.{}\".format(node, prop)\n prop_id = \"{}.{}\".format(project_id, prop_name)\n print(prop_name)\n\n # because of sheepdog bug, need to inclue \"None\" in \"null\" (:facepalm:) https://ctds-planx.atlassian.net/browse/PXP-5663\n #df.at[df[prop] == \"None\", prop] = np.nan\n\n null = df.loc[df[prop].isnull()]\n nn = df.loc[df[prop].notnull()]\n perc_null = len(null)/len(df)\n ptype = self.get_prop_type(node, prop, dd)\n\n # dict for the prop's row in report dataframe\n prop_stats = {\n \"prop_id\": prop_id,\n \"project_id\": project_id,\n \"node\": node,\n \"property\": prop,\n \"type\": ptype,\n \"N\": len(df),\n \"nn\": len(nn),\n \"null\": len(null),\n \"perc_null\": perc_null,\n \"all_null\": np.nan,\n \"min\": np.nan,\n \"max\": np.nan,\n \"median\": np.nan,\n \"mean\": np.nan,\n \"stdev\": np.nan,\n \"outliers\": np.nan,\n \"bin_number\": np.nan,\n \"bins\": np.nan,\n }\n\n if nn.empty:\n null_props.append(prop_name)\n prop_stats[\"all_null\"] = True\n\n else:\n nn_props.append(prop_name)\n all_prop_ids.append(prop_id)\n prop_stats[\"all_null\"] = False\n\n msg = \"\\t'{}'\".format(prop_id)\n sys.stdout.write(\"\\r\" + str(msg).ljust(200, \" \"))\n\n if ptype in [\"string\", \"enum\", \"array\", \"boolean\", \"date\"]:\n\n if ptype == \"array\":\n\n all_bins = list(nn[prop])\n bin_list = [\n bin_txt.split(\",\") for bin_txt in list(nn[prop])\n ]\n counts = Counter(\n [\n item\n for sublist in bin_list\n for item in sublist\n ]\n )\n\n elif ptype in [\"string\", \"enum\", \"boolean\", \"date\"]:\n\n counts = Counter(nn[prop])\n\n df1 = pd.DataFrame.from_dict(\n counts, orient=\"index\"\n ).reset_index()\n bins = [tuple(x) for x in df1.values]\n bins = sorted(\n sorted(bins, key=lambda x: (x[0])),\n key=lambda x: (x[1]),\n reverse=True,\n ) # sort first by name, then by value. This way, names with same value are in same order.\n\n prop_stats[\"bins\"] = bins\n prop_stats[\"bin_number\"] = len(bins)\n\n # Get stats for numbers\n elif ptype in [\"number\", \"integer\"]: # prop='concentration'\n\n # make a list of the data values as floats (converted from strings)\n nn_all = nn[prop]\n d_all = list(nn_all)\n\n nn_num = (\n nn[prop]\n .apply(pd.to_numeric, errors=\"coerce\")\n .dropna()\n )\n d = list(nn_num)\n\n nn_string = nn.loc[~nn[prop].isin(list(map(str, d)))]\n non_numbers = list(nn_string[prop])\n\n if (\n len(d) > 0\n ): # if there are numbers in the data, calculate numeric stats\n\n # calculate summary stats using the float list d\n mean = statistics.mean(d)\n median = statistics.median(d)\n minimum = min(d)\n maximum = max(d)\n\n if (\n len(d) == 1\n ): # if only one value, no stdev and no outliers\n std = \"NA\"\n outliers = []\n else:\n std = statistics.stdev(d)\n # Get outliers by mean +/- outlier_threshold * stdev\n cutoff = (\n std * outlier_threshold\n ) # three times the standard deviation is default\n lower, upper = (\n mean - cutoff,\n mean + cutoff,\n ) # cut-offs for outliers is 3 times the stdev below and above the mean\n outliers = sorted(\n list(\n set(\n [\n x\n for x in d\n if x < lower or x > upper\n ]\n )\n )\n )\n\n # if property type is 'integer', change min, max, median to int type\n if ptype == \"integer\":\n median = int(median) # median\n minimum = int(minimum) # min\n maximum = int(maximum) # max\n outliers = [\n int(i) for i in outliers\n ] # convert outliers from float to int\n\n prop_stats[\"stdev\"] = std\n prop_stats[\"mean\"] = mean\n prop_stats[\"median\"] = median\n prop_stats[\"min\"] = minimum\n prop_stats[\"max\"] = maximum\n prop_stats[\"outliers\"] = outliers\n\n # check if numeric property is mixed with strings, and if so, summarize the string data\n if len(d_all) > len(d):\n\n msg = \"\\t\\tFound {} string values among the {} records of prop '{}' with value(s): {}. Calculating stats only for the {} numeric values.\".format(\n len(non_numbers),\n len(nn),\n prop,\n list(set(non_numbers)),\n len(d),\n )\n print(\"\\n\\t{}\\n\".format(msg))\n\n prop_stats[\"type\"] = \"mixed {},string\".format(ptype)\n\n counts = Counter(nn_string[prop])\n df1 = pd.DataFrame.from_dict(\n counts, orient=\"index\"\n ).reset_index()\n bins = [tuple(x) for x in df1.values]\n bins = sorted(\n sorted(bins, key=lambda x: (x[0])),\n key=lambda x: (x[1]),\n reverse=True,\n )\n prop_stats[\"bins\"] = bins\n prop_stats[\"bin_number\"] = len(bins)\n\n else: # If its not in the list of ptypes, exit. Need to add array handling.\n print(\n \"\\t\\t\\n\\n\\n\\nUnhandled property type!\\n\\n '{}': {}\\n\\n\\n\\n\".format(\n prop_id, ptype\n )\n )\n exit()\n\n if bin_limit and isinstance(prop_stats[\"bins\"], list): # if bin_limit != False\n prop_stats[\"bins\"] = prop_stats[\"bins\"][: int(bin_limit)]\n\n #report = report.append(prop_stats, ignore_index=True)\n # print(\"\\n{}\\n\".format(report))\n # print(\"\\n{}\\n\".format(prop_stats))\n pdf = pd.DataFrame.from_records([prop_stats])\n pdf['all_null'] = pdf['all_null'].astype(bool)\n report = pd.concat([report,pdf])\n\n\n if not report_null: # if report_null == False\n report = report.loc[report[\"all_null\"] != True]\n\n # strip the col names so we can sort the report\n report.columns = report.columns.str.strip()\n report.sort_values(by=[\"all_null\", \"node\", \"property\"], inplace=True)\n\n summary[\"report\"] = report\n summary[\"all_prop_ids\"] = all_prop_ids\n\n # summarize all properties\n nn_props = sorted(list(set(nn_props)))\n summary[\"nn_props\"] = nn_props\n\n null_props = [prop for prop in null_props if prop not in nn_props]\n summary[\"null_props\"] = sorted(list(set(null_props)))\n\n # summarize all nodes\n nn_nodes = sorted(list(set(nn_nodes)))\n summary[\"nn_nodes\"] = nn_nodes\n\n dd_regex = re.compile(r\"[^_][A-Za-z0-9_]+\")\n dd_nodes = list(filter(dd_regex.match, list(dd)))\n dd_nodes = [node for node in dd_nodes if node not in omit_nodes]\n null_nodes = [node for node in dd_nodes if node not in nn_nodes]\n\n summary[\"null_nodes\"] = null_nodes\n\n if write_report: # write_report == True\n\n self.create_output_dir(outdir=outdir)\n\n if \"/\" in tsv_dir:\n names = tsv_dir.split(\"/\")\n names = [name for name in names if name != \"\"]\n name = names[-1]\n else:\n name = tsv_dir\n\n outname = \"data_summary_{}.tsv\".format(name)\n outname = \"{}/{}\".format(\n outdir, outname\n ) # ./data_summary_prod_tsvs_04272020.tsv\n\n report.to_csv(outname, sep=\"\\t\", index=False, encoding=\"utf-8\")\n sys.stdout.write(\"\\rReport written to file:\".ljust(200, \" \"))\n print(\"\\n\\t{}\".format(outname))\n\n return summary","def post_process_output_file():\n parsed_data = []\n unparseable_data = []\n\n with open('../output/part-00000', 'r') as input_file:\n for line in input_file:\n line = line.strip()\n try:\n csv_splits = line.split(',')\n csv_splits[0] = int(csv_splits[0])\n # parsed_data is a list of lists\n parsed_data.append(csv_splits)\n except ValueError:\n unparseable_data.append(line)\n parsed_data.sort()\n\n with open('../output/titanic_test_data.csv', 'w') as output_file:\n # start with lines that couldn't be parsed\n # hopefully this will only be the original header\n for line in unparseable_data:\n output_file.write(\"%s\\n\" % line)\n for line in parsed_data:\n output_file.write(\"%d,%s\\n\" % (line[0], line[1]))","def parse_file(self):\n with open(self.file_name, 'r', errors='ignore') as log_file:\n for line in log_file:\n self.process_line(line)","def write(self): \n # Open csv file\n with open(self.file_name, 'w', newline='') as file:\n self._writer = csv.writer(file)\n \n # Write header rows\n# self.write_sim_header_data(self.trace.sim.get_data())\n \n # Write trace table\n self._writer.writerow(['Record #', 'Rep', 'Time',\n 'Priority', 'Record Type', 'Name'])\n for trace_record in self.trace._record_list:\n self._writer.writerow(trace_record.get_row())\n file.close()","def lv_analysis():\r\n\r\n global params\r\n n = params['n']\r\n lvmin = params['lvmin']\r\n lvmax = params['lvmax']\r\n lvstep = params['lvstep']\r\n ns = params['ns']\r\n nt = params['nt']\r\n no = params['no']\r\n ne = params['ne']\r\n nf = params['nf']\r\n lv_dir = create_dir(TIMES_PATH + 'lv')\r\n filename = datetime.datetime.now().strftime(DATE_FORMAT) + '.csv'\r\n with open(lv_dir + filename, 'wb') as csvfile:\r\n fw = csv.writer(csvfile)\r\n fw.writerow(('lv', 'ns', 'nt', 'no', 'ne', 'nf',\r\n 'method1', 'method2', 'method3_1', 'method3_2'))\r\n lv = lvmin\r\n while lv <= lvmax:\r\n times = [0] * 4\r\n for i in range(n):\r\n times = map(sum, zip(times, get_times(lv, ns, nt, no, ne, nf)))\r\n show_progress('lv', lv, lvmin, lvmax, lvstep, i, n)\r\n times = map(lambda x : float(x) / n, times)\r\n fw.writerow((lv, ns, nt, no, ne, nf) + tuple(times))\r\n lv += lvstep\r\n csvfile.close()","def loop_nonThreaded():\n nonlocal index, total\n nonlocal d_tree\n nonlocal fn_inputReadCallback\n nonlocal fn_analysisCallback\n nonlocal fn_outputWriteCallback\n nonlocal dret_inputSet\n nonlocal dret_analyze\n nonlocal dret_outputSet\n nonlocal str_desc\n\n b_analyzeStatusHist: bool = False\n b_inputStatusHist: bool = False\n b_outputStatusHist: bool = False\n\n if int(self.verbosityLevel) and self.toConsole():\n iterator = tqdm( self.d_inputTree.items(),\n desc = str_desc)\n else:\n iterator = self.d_inputTree.items()\n\n for path, data in iterator:\n dret_inputSet = {}\n dret_analyze = {}\n dret_outputSet = {}\n # Read (is sometimes skipped) / Analyze / Write (also sometimes skipped)\n if fn_inputReadCallback:\n dret_inputSet = inputSet_read(path, data)\n try:\n b_inputStatusHist = b_inputStatusHist or dret_inputSet['status']\n except:\n pass\n if fn_analysisCallback:\n try:\n dret_analyze = analysis_do(path, d_tree[path], index)\n except:\n dret_analyze['status'] = False\n self.dp.qprint(\"Analysis failed\", comms = 'error')\n try:\n b_analyzeStatusHist = b_analyzeStatusHist or dret_analyze['status']\n except:\n pass\n if fn_outputWriteCallback:\n if 'status' in dret_analyze.keys():\n if dret_analyze['status']:\n dret_outputSet = outputSet_write(path, d_tree[path])\n try:\n b_outputStatusHist = b_outputStatusHist or dret_outputSet['status']\n except:\n pass\n index += 1\n dret_inputSet['status'] = b_inputStatusHist\n dret_analyze['status'] = b_analyzeStatusHist\n dret_outputSet['status'] = b_outputStatusHist\n tree_removeDeadBranches()","def write_csv(file_name, data):\n\n with open(file_name, \"w\") as fp:\n\n writer = RiscvInstructionTraceCsv(fp)\n writer.start_new_trace()\n\n for entry in data:\n writer.write_trace_entry(entry)","def parse(self):\r\n # open the file\r\n # try to find the first line with Time =\r\n # send the file to a recursive residualParser\r\n try:\r\n with open(self.filepath, 'rb') as f:\r\n for line in f:\r\n if line.startswith('Time ='):\r\n self.timestep = self.__getTime(line)\r\n self.__residuals[self.timestep] = {}\r\n self.__parseResiduals(f)\r\n except Exception as e:\r\n raise 'Failed to parse {}:\\n\\t{}'.format(self.filepath, e)","def process_log(log_file):\n result_list = []\n file_root = get_fname_root(log_file)\n\n with open(log_file) as l_file:\n reading_steps = False\n result_dict = {}\n for line in l_file:\n line = line.strip()\n if STEP_PAT.match(line):\n reading_steps = True\n result_dict[FILE_NAME] = file_root\n result_dict[TIMESTEP] = int(line.split()[2])\n elif reading_steps:\n if len(line) == 0:\n break\n s_line = line.split()\n if s_line[0] == TOTENG:\n for key_id, key in enumerate([TOTENG, KINENG, TEMP]):\n result_dict[key] = float(s_line[2 + key_id * 3])\n elif s_line[0] == POTENG:\n for key_id, key in enumerate([POTENG, E_BOND, E_ANGL]):\n result_dict[key] = float(s_line[2 + key_id * 3])\n elif s_line[0] == E_DIHED:\n for key_id, key in enumerate([E_DIHED, E_IMPRO, E_VDWL]):\n result_dict[key] = float(s_line[2 + key_id * 3])\n elif s_line[0] == E_COUL:\n for key_id, key in enumerate([E_COUL, E_LONG, PRESS]):\n result_dict[key] = float(s_line[2 + key_id * 3])\n result_list.append(dict(result_dict))\n else:\n # when stop matching, done reading file (either by normal or abnormal termination)\n break\n\n return result_list","def all(config_file):\n with open(config_file) as f:\n config = json.load(f)\n scenes = get_realsense_scenes(config['realsense_dir'])\n all_dfs = []\n for scene in scenes:\n scene_data = get_data_from_scene(scene)\n logger.info(\"Evaluating - %s\", scene['scene_name'])\n df = run_test_on_scene(scene_data, config)\n all_dfs.append(df)\n\n df = pd.concat(all_dfs, axis=0)\n df = df.reset_index()\n print(df)\n df.to_csv(config['save_csv'])","def write_log(self):\n with open(self.trav_stat_file, 'a') as stat_file:\n travel_writer = csv.writer(stat_file)\n # Every row starts with the start and destnation\n row = [self.start, self.dest]\n # This uses a static list so that the order is fixed\n for state in [\"waiting\", \"riding\", \"transferring\"]:\n state_total = sum(self.time_record[state])\n row.append(state_total)\n travel_writer.writerow(row)","def update_results(self):\n clis = []\n aps = []\n\n with open(self.curr_csv) as fileo:\n file_ = fileo.readlines()\n file_enum = enumerate(file_)\n num = 0\n for num, line in file_enum:\n line = line.replace('\\0', '')\n if not line:\n continue\n if line.startswith('BSSID'):\n continue\n if line.startswith('Station'):\n num += 1\n break\n aps.append(line)\n for line in file_[num:]:\n clis.append(line)\n\n def clean_rows(reader):\n \"\"\"\n Airodump-ng's csv info comes a bit unclean.\n Strip each line of its extra blank spaces\n \"\"\"\n return [[a.strip() for a in row] for row in reader if row]\n self._aps = clean_rows(csv.reader(StringIO('\\n'.join(aps))))\n self._clients = clean_rows(csv.reader(StringIO('\\n'.join(clis))))","def parseFile()-> None:\n logging.info(f\"Parsing file with Pandas {getTime()}\")\n with open(DATA_FILE) as f:\n data = pd.read_csv(f)\n db = connect(\"result.db\")\n\n data.to_sql(\"data\",db,if_exists=\"replace\")\n\n result = pd.DataFrame({\"Uniqe Countries\":[len(set(data[\"location\"]))]})\n\n with open(RESULT_FILE,\"w\") as f:\n f.write(result.to_csv(index=False))\n logging.info(f\"Finsied parsing {getTime()}\")","def do_a_series_of_propagations(self):\n index = 0\n header = 'col1'\n while index < self.rounds and self.flag:\n index = index + 1\n print(\"\\nLabel propagation round: \" + str(index)+\".\\n\")\n self.do_a_propagation()\n print(index)\n with open ('./data/lpa.txt','w') as f:\n for i in self.nodes:\n f.write(str(self.labels[i])+'\\t')\n f.write(str(i)+'\\t')\n f.write('\\n')\n \n print(\"\")\n print(\"Modularity is: \" + str(round(modularity( self.labels,self.graph,0.2), 40)) + \".\\n\")\n json_dumper(self.labels, self.args.assignment_output)","def Parse(filename, blockLengths):\n global DELAY1\n global DELAY2\n global BLOCK \n global TRIAL \n global PRACTICED \n global FIXATION_ONSET\n global ENCODING_ONSET \n global ENCODING_RT \n global EXECUTION_ONSET \n global EXECUTION_RT \n global PROBE_ONSET \n global PROBE_RT \n global PROBE_ACC \n\n fin = open(filename, 'rU')\n subject = filename.split('.')[0].split('-')[-1]\n lines = fin.readlines()\n tokens = [x.split('\\t') for x in lines]\n tokens = [[y.strip() for y in x] for x in tokens]\n colNames = tokens[0]\n rows = tokens[1:]\n\n DELAY1 = colNames.index(\"Delay1\")\n DELAY2 = colNames.index(\"Delay2\")\n BLOCK = colNames.index(\"BlockNum\")\n TRIAL = colNames.index(\"Trials\")\n PRACTICED = colNames.index(\"Practiced\")\n FIXATION_ONSET = colNames.index(\"Fixation1.OnsetTime\")\n ENCODING_ONSET = colNames.index(\"Encoding.OnsetTime\")\n ENCODING_RT = colNames.index(\"Encoding.RT\")\n EXECUTION_ONSET = colNames.index(\"Execution.OnsetTime\")\n EXECUTION_RT = colNames.index(\"Execution.RT\")\n PROBE_ONSET = colNames.index(\"Probe.OnsetTime\")\n PROBE_RT = colNames.index(\"Probe.RT\")\n PROBE_ACC = colNames.index(\"Probe.ACC\")\n\n trials = [Trial(r) for r in rows]\n trials = [t for t in trials if t.ok] # Excludes trials where values are missing\n FIRST_TRIALS = []\n previous = None\n blockLengths=[0]+blockLengths\n for t in trials:\n\n if t.block > len(blockLengths):\n raise Exception, \"Not enough block lengths supplied\"\n\n t.blockOffset = 2 * reduce(add, blockLengths[0:t.block])\n #print t.block, blockLengths[0:t.block]\n \n # print t.blockOffset\n # Identify the first trials\n if previous == None or t.block != previous.block:\n FIRST_TRIALS.append(t)\n previous = t \n \n #FIRST_TRIALS = [t for t in trials if (t.trial % 10) == 1]\n #print FIRST_TRIALS\n \n for f in FIRST_TRIALS:\n subset = [t for t in trials if t.block == f.block]\n for s in subset:\n s.blockBegin = f.fixationOnset - 4000\n\n #print [t.encodingOnset-t.blockBegin for t in trials]\n #print trials\n\n BLOCKS = set(t.block for t in trials)\n BLOCKS = list(BLOCKS)\n BLOCKS.sort()\n #print BLOCKS\n\n P = {'Yes' : 'Practiced', 'No' : 'Novel'}\n\n fout = open(\"s%s_sessions_dcm.m\" % subject, 'w')\n\n # For DCM analysis, we need a special model that contains\n # All the trials in a particular format, and that does\n # not distinguish between the different shoes.\n\n correct = [t for t in trials if t.acc == 1]\n errors = [t for t in trials if t.acc == 0]\n\n nc = 5\n\n if len(errors) > 0:\n for phase in ['Encoding', 'Execution', 'Probe']:\n RTs = [e.rts[phase]/1000.0 for e in errors if e.rts[phase]>0]\n if len(RTs) > 0:\n nc += 1\n \n\n i = 1 # counter\n\n fout.write(\"names=cell(1,%d);\\n\" % nc)\n fout.write(\"onsets=cell(1,%d);\\n\" % nc)\n fout.write(\"durations=cell(1,%d);\\n\" % nc)\n\n # Encoding and Execution, divided by Practice (Yes/No)\n # ------------------------------------------------------------\n \n for phase in ['Encoding', 'Execution']: \n for practice in [['Yes', 'No'], ['No']]:\n appropriate = [c for c in correct if c.practiced in practice]\n pName = \"\"\n if len(practice) == 1:\n pName = \"_Novel\"\n fout.write(\"names{%d}='%s%s';\\n\" % (i, phase, pName))\n onsets = \"%s\" % [a.ScanTime(a.onsets[phase]) for a in appropriate]\n durations = \"%s\" % [a.rts[phase]/1000.0 for a in appropriate]\n fout.write(\"onsets{%d}=%s;\\n\" % (i, onsets.replace(\";\", \"\")))\n fout.write(\"durations{%d}=%s;\\n\" % (i, durations.replace(\";\", \"\")))\n \n RTs = [a.rts[phase]/1000.0 for a in appropriate]\n meanRT = reduce(add, RTs)/len(RTs)\n\n i += 1\n #print \"<%d>, Practiced=%s, Phase=%s, RT=%.3f\" % (b, practice, phase, meanRT)\n\n # Probes, altogether (assumes no effect of practice)\n # ------------------------------------------------------------\n fout.write(\"names{%d}='Probe';\\n\" % i)\n onsets = \"%s\" % [c.ScanTime(c.onsets['Probe']) for c in correct]\n durations = \"%s\" % [c.rts['Probe']/1000.0 for c in correct]\n fout.write(\"onsets{%d}=%s;\\n\" % (i, onsets.replace(\";\", \"\")))\n fout.write(\"durations{%d}=%s;\\n\" % (i, durations.replace(\";\", \"\")))\n i += 1\n\n # Error trials\n # ------------------------------------------------------------\n # Note that, in the new design of the experiment, there might\n # be encoding errors only, or encoding/execution errors only,\n # because trials are aborted if one phase times out.\n if len(errors) > 0:\n for phase in ['Encoding', 'Execution', 'Probe']:\n O = [e.ScanTime(e.onsets[phase]) for e in errors if e.onsets[phase]>0 and e.rts[phase]>0]\n D = [e.rts[phase]/1000.0 for e in errors if e.onsets[phase]>0 and e.rts[phase]>0]\n if len(D) > 0:\n onsets = \"%s\" % O\n durations = \"%s\" % D\n fout.write(\"names{%d}='%s/Error';\\n\" % (i, phase))\n fout.write(\"onsets{%d}=%s;\\n\" % (i, onsets.replace(\";\", \"\")))\n fout.write(\"durations{%d}=%s;\\n\" % (i, durations.replace(\";\", \"\")))\n i += 1\n\n fout.write(\"save('dcm_session.mat', 'names', 'onsets', 'durations');\\n\" % b)\n fout.flush()\n fout.close()\n\n #print blockLengths\n rout = open(\"s%s_session_regressors.txt\" % subject, 'w')\n for i in range(len(blockLengths[1:])):\n for j in range(blockLengths[i+1]):\n for s in range(len(blockLengths[1:])-1): # Do not print a column for last block\n if s == i:\n rout.write(\"1 \")\n else:\n rout.write(\"0 \")\n rout.write(\"\\n\")\n rout.flush()\n rout.close()","def read_statistics(self):\n self.psdata=[]\n self.powerspectra=[]\n self.ds=[]\n self.dsigmasq=[]\n self.dsigma=[]\n self.bsdata=[]\n self.eqbispectra=[]\n self.fNLeq=[]\n\n for sub in range(self.Nsubs):\n self.psdata.append(np.load(self.datadir+self.filebase+\"_\"+str(sub)+\".npy\"))\n self.powerspectra.append(np.trim_zeros(self.psdata[-1][0][1:]))\n self.bsdata.append(np.load(self.datadir+self.fbbispec+\"_\"+str(sub)+\".npy\"))\n self.eqbispectra.append(self.bsdata[-1][0][1:len(self.powerspectra[-1])])\n\n self.ds.append(np.load(self.datadir+\"stat_\"+str(sub)+\".npy\")[0])\n self.dsigmasq.append(np.load(self.datadir+\"stat_\"+str(sub)+\".npy\")[1])\n self.dsigma = np.array([np.sqrt(dsq) for dsq in self.dsigmasq])\n\n self.klist=np.arange(1, len(self.powerspectra[-1]))*(2.*np.pi/self.Lsub)\n # subtract the mean ds\n self.ds = self.ds - np.mean(self.ds)\n self.fNLeq=np.mean(self.eqbispectra, axis=0)\n self.fNLeqsubs=np.mean(self.eqbispectra, axis=1)\n self.fNLeqds=[]\n for i in range(len(self.eqbispectra)):\n self.fNLeqds.append(np.array([self.ds[i]*self.eqbispectra[i][j] for j in range(45)]))","def main(config_path):\n logging.info(\"Loading raw data files. This may take a few minutes.\")\n config = yaml.load(config_path, yaml.SafeLoader)\n min_year = config[\"min_year\"]\n max_year = config[\"max_year\"]\n\n # The Eviction Lab data came in two files (2014-2016 and 2017-2018) with different formats, so\n # we need to read them in separately and merge them later.\n eviction_df = load_evictions_data(\n config[\"eviction_data_path\"],\n \"EXECUTED_DATE\",\n min_year,\n max_year,\n create_geoid = True\n )\n census_df = load_census_data(config[\"acs_data_path\"])\n\n # Generate the time series data and save output\n logging.info(\"Generating time series data (monthly counts of housing loss events).\")\n\n # Calculating eviction totals separately because number of evictions does not always equal number of rows in the df\n evictions_monthly = aggregate_evictions_using_rate_estimates(\n eviction_df,\n config[\"path_to_eviction_filing_rates\"],\n estimate_var = \"filings\",\n time_group = \"month\"\n )\n evictions_monthly = evictions_monthly[[\"eviction-filings\", \"month\"]].groupby(\"month\").sum().reset_index()\n\n\n # Creating timeseries df and merging on separate eviction counts\n timeseries_df = generate_time_series_df(eviction_df)\n timeseries_df = timeseries_df.merge(evictions_monthly, how=\"outer\")\n timeseries_df.drop_duplicates().to_csv(\n config[\"timeseries_output_csv_path\"], index=False\n )\n logging.info(\n \"Output timeseries CSV saved to %s.\" % config[\"timeseries_output_csv_path\"]\n )\n\n # Process evictions data--get totals/rates across the analysis period & totals/rates\n # by year\n eviction_df = aggregate_evictions_using_rate_estimates(\n eviction_df,\n config[\"path_to_eviction_filing_rates\"],\n estimate_var = \"filings\",\n time_group = \"year\"\n )\n eviction_years_df = create_year_cols_from_df(\n eviction_df,\n [\"evictions\", \"eviction-filings\", \"eviction-rate\"], # \"eviction-filing-rate\"\n {\"evictions\": \"total-evictions\"},\n \"year\",\n \"GEOID\",\n )\n\n eviction_totals = get_totals_across_years(eviction_df, \"GEOID\", \"evictions\").rename(\n columns={\"sum\": \"total-evictions\", \"mean\": \"avg-evictions\"}\n )\n eviction_filing_totals = get_totals_across_years(\n eviction_df, \"GEOID\", \"eviction-filings\",\n ).rename(columns={\"sum\": \"total-eviction-filings\", \"mean\": \"avg-eviction-filings\"})\n\n\n # Join evictions, mortgage, tax, and ACS data together into a single dataframe\n merged = (\n census_df\n .merge(eviction_totals, on=\"GEOID\", how=\"left\")\n .merge(eviction_df[[\"GEOID\"]].dropna().drop_duplicates(),on=\"GEOID\",how=\"left\",)\n .merge(eviction_years_df, on=\"GEOID\", how=\"left\")\n )\n\n merged[\"overall-city-eviction-rate\"] = ((np.sum(merged[\"avg-evictions\"][np.isfinite(merged[\"avg-evictions\"])]))/sum(merged[\"total-renter-occupied-households\"]))*100\n\n merged[\"avg-eviction-rate\"] = (\n merged[\"avg-evictions\"] / merged[\"total-renter-occupied-households\"]\n ) * 100\n\n merged[\"ratio-to-mean-eviction-rate\"] = (\n merged[\"avg-eviction-rate\"] / merged[\"overall-city-eviction-rate\"]\n )\n\n # Add geographic identifier columns\n merged = merged.rename(columns={\"GEOID\": \"census_tract_GEOID\"})\n merged[\"county_GEOID\"] = merged[\"census_tract_GEOID\"].apply(lambda x: x[:5])\n merged.loc[merged[\"county_GEOID\"] == \"36005\", \"county\"] = \"Bronx\"\n merged.loc[merged[\"county_GEOID\"] == \"36047\", \"county\"] = \"Brooklyn\"\n merged.loc[merged[\"county_GEOID\"] == \"36061\", \"county\"] = \"Manhattan\"\n merged.loc[merged[\"county_GEOID\"] == \"36081\", \"county\"] = \"Queens\"\n merged.loc[merged[\"county_GEOID\"] == \"36085\", \"county\"] = \"Staten Island\"\n merged[\"state\"] = \"New York\"\n\n\n # Write main output file to CSV\n merged.drop_duplicates().to_csv(config[\"output_csv_path\"], index=False)\n logging.info(\"Output CSV saved to %s.\" % config[\"output_csv_path\"])","def run(file_name, first_year, last_year):\r\n\twith open(file_name) as file:\r\n\t\treader = csv.DictReader(file)\r\n\r\n\t\t#Counts amount of reports per state.\r\n\t\t#counter = sc.ReportCounter()\r\n\r\n\t\t#Allows the csv to be iterable more than once.\r\n\t\trows = list(reader)\r\n\r\n\t\tlats, lons = [], []\r\n\t\tfor year in range(first_year, last_year+1):\r\n\t\t\tfor row in rows:\r\n\t\t\t\t#counter.update_count(row['state'])\r\n\t\t\t\tif row['year'] == str(year):\r\n\t\t\t\t\tlatitude, longitude = get_lat_and_long(row)\r\n\t\t\t\t\tlats.append(float(latitude))\r\n\t\t\t\t\tlons.append(float(longitude))\r\n\t\t\t\r\n\t\t\tplot(lats, lons, year)","def main():\n parser = argparse.ArgumentParser(description='Process input file and save to output file.')\n\n parser.add_argument('-i',\n '--input',\n help='Trip report file (txt file) to process.',\n action='store')\n\n parser.add_argument('-o',\n '--output',\n help='Output file (json).',\n action='store')\n\n if len(sys.argv) == 1:\n parser.print_help()\n sys.exit(1)\n\n args = parser.parse_args()\n\n if not args.input:\n print('Please specify the trip report input text file.')\n sys.exit(1)\n\n if args.output:\n output_file = args.output\n else:\n output_file = OUTPUT_DEFAULT\n print(f'No output file specified. Using the default: {OUTPUT_DEFAULT}')\n\n trip_list = [] # the list of trips(dictionaries) to output to the data file\n trip_started = False\n day_started = False\n\n with open(args.input, 'r') as fh:\n\n while True:\n\n line = fh.readline()\n\n if not line:\n break\n\n if line.isspace():\n continue\n\n if '________' in line:\n continue\n\n if line.startswith('TRIP'): # detect start of a trip (anywhere from 1-5 days long)\n # print('Start trip' + line)\n\n trip = Parser.trip_parser(line) # create a trip(dictionary)\n trip['days'] = [] # adds a day list (a list of sectors(dictionaries)) to the trip list\n\n trip_started = True # sets trip started to true\n continue\n\n # if new day has not started, create a new day\n if trip_started and not day_started and Parser.new_day(line):\n day = {'sign_on': line[43:48], 'day_sectors': []}\n day_started = True # sets day started to true\n\n if trip_started and day_started:\n if not Parser.end_day(line):\n # print('During day: ' + line)\n day['day_number'] = line[24:26].strip() # assign a day number to that day\n\n if Parser.in_sector(line): # check if a sector has started\n day['day_sectors'].append(Parser.sector_parser(line)) # append sector to day\n\n else:\n day['sign_off'] = line[53:58].strip() # get sign off time from line\n day['flight_duty_period'] = line[71:76].strip() # get flight duty period\n flight_duty_split = day['flight_duty_period'].split('h') # split flight duty period on 'h'\n day['flight_duty_period_hours'] = int(flight_duty_split[0]) # convert to hours\n day['flight_duty_period_minutes'] = int(flight_duty_split[1]) # convert to minutes\n\n day_started = False # sets day started to false\n\n if not day_started:\n if 'Sign_off' in line: # indicated the day is finished and its only a single day trip\n day['lay_over'] = '0h00' # hard coded 0h00 layover as this is return flight from home base\n day['lay_over_hours'] = 0 # hard coded 0 hours\n day['lay_over_minutes'] = 0 # hard coded 0 minutes\n\n # order the day using an OrderedDict, before adding it to the trip dict\n day_ordered = Parser.order_day(day)\n trip['days'].append(day_ordered)\n\n elif '--------------------------------' in line: # the day is over and now layover\n lay_over = line[88:93].strip() # get layover from line\n day['lay_over'] = lay_over # add to day dictionary\n day['lay_over_hours'] = Parser.layover_split(lay_over)[0] # split and convert to int\n day['lay_over_minutes'] = Parser.layover_split(lay_over)[1] # split and convert to int\n\n # order the day using an OrderedDict, before adding it to the trip dict\n day_ordered = Parser.order_day(day)\n trip['days'].append(day_ordered)\n\n if not line[28:36].isspace() and line[27:35] == 'Sign_off': # detect end of a trip\n trip_started = False # set trip started to False\n\n trip_list.append(trip) # append the trip(dictionary) to the trip list\n\n with open(output_file, 'w') as fh: # Convert everything (including datetime object) to string\n fh.write(json.dumps(trip_list, default=str, indent=4)) # write to json file for output\n\n Display.display_data(output_file) # display analytics data within the terminal\n\n return output_file","def _read_log(self):\n\n line_regex = compile(r\"\\[I\\]\\s*\\(\\d+ms\\)[^\\d]+(?P<counter>\\d+)\"\n r\"[^\\d]+(?P<timestamp>\\d+(\\.\\d+)?)[^\\d]+\"\n r\"(?P<acceleration>\\d+);\")\n values = []\n with open(self.filepath) as file:\n for line in file:\n match = line_regex.match(line)\n if match:\n values.append({\n 'counter':\n int(match['counter']),\n 'timestamp':\n int(float(match['timestamp']) * 1000),\n 'acceleration':\n int(match['acceleration'])\n })\n\n self.values = values"],"string":"[\n \"def spectrum_parser():\\n from tools import file_importer, file_outporter\\n from random import random\\n # from math import log10\\n \\n print(\\\"this is spectrum parser\\\")\\n \\n relPath = \\\"bob/processed/OST-24-05-2017_combined.csv\\\"\\n outPath = \\\"bob/processed/OST-24-05-2017_combined_no0_spectrum.csv\\\"\\n inpF = file_importer(relPath)\\n outF = file_outporter(outPath) \\n headerFlag = True\\n rowCount = 0\\n for inpLine in inpF:\\n if headerFlag: \\n headerFlag = False\\n spColCount = 0\\n inpList = inpLine.split(\\\"\\\\t\\\")\\n for headerI in inpList:\\n if \\\"Peptides ST-1|Peptides ST-2|Peptides ST-3\\\" == headerI:\\n break\\n else: spColCount += 1\\n outF.write(\\\"ID,Protein ID, Gene name,\\\") # write header into output file\\n for headI in inpList[spColCount].split(\\\"|\\\"):\\n outF.write(headI + \\\",\\\")\\n for headI in inpList[spColCount + 1].split(\\\"|\\\")[:-1]:\\n outF.write(headI + \\\",\\\")\\n outF.write(inpList[spColCount + 1].split(\\\"|\\\")[-1] + \\\"\\\\n\\\")\\n rowCount += 1\\n continue\\n \\n outF.write(str(rowCount) + \\\",\\\")\\n \\n inpLine = inpLine.strip()\\n inpItems = inpLine.split(\\\"\\\\t\\\")\\n inpName = max(inpItems[0].split(\\\"|\\\"), key=len) # get unique protein ID\\n inpGeneName = max(inpItems[6].split(\\\"|\\\"), key=len) # and gene name\\n outF.write(inpName + \\\",\\\" + inpGeneName + \\\",\\\")\\n \\n inpSP = inpItems[spColCount].split(\\\"|\\\") + inpItems[spColCount + 1].split(\\\"|\\\") # get lfq intensity scores\\n # print inpSP\\n for lfqI in inpSP[:-1]: # write lfq values\\n if lfqI == \\\"_\\\" or lfqI == \\\"0\\\":\\n outF.write(str(random()) + \\\",\\\") ################## try with log10 values this time\\n else:\\n try:\\n outF.write(str(lfqI) + \\\",\\\")\\n except ValueError:\\n print(inpItems)\\n raise\\n \\n if inpSP[-1] == \\\"_\\\" or inpSP[-1] == \\\"0\\\": outF.write(str(random()) + \\\"\\\\n\\\")\\n else: outF.write(inpSP[-1] + \\\"\\\\n\\\")\\n \\n \\n \\n rowCount += 1\",\n \"def readAndRewrite(self):\\n try:\\n with open(self.dataFile, 'r') as source:\\n self.initDictionnary()\\n lineCount = 0\\n filteredData = [] # array of filtered flights\\n for line in source:\\n lineCount += 1\\n line = line.strip()\\n if line != \\\"\\\" and line[0] != \\\"#\\\":\\n f = Flight(line, self.vocabulary)\\n if self.filter:\\n f.rewrite(self.summaryDict)\\n f.filter(filteredData, self.listOfTerms, self.threshold)\\n print(\\\"End : Displaying general summary\\\")\\n self.displaySummary(self.summaryDict, lineCount)\\n print(\\\"-------------- End of general summary ---------------\\\")\\n if len(filteredData) != 0:\\n print(\\\"Beginning summary on filtered data (\\\" + str(len(filteredData)) + \\\" entries)\\\")\\n for data in filteredData:\\n data.rewrite(self.summaryFilteredDict)\\n print(\\\"End of summary for filtered data\\\")\\n self.displaySummary(self.summaryFilteredDict, len(filteredData))\\n print(\\\"Finding correlations\\\")\\n self.findLinkedTerms()\\n print(\\\"Printing correlations with \\\" + str(self.listOfTerms) + \\\" and threshold : \\\" + str(self.threshold))\\n #for key in self.correlationDict.keys():\\n #print(str(key) + \\\" : \\\" + str(self.correlationDict[key]))\\n self.findAtypicalTerms()\\n print(\\\"Printing atypical terms with \\\" + str(self.listOfTerms) + \\\" and threshold : \\\" + str(self.threshold))\\n #for term in self.atypicalTermsDict.keys():\\n #print(str(term) + \\\" : \\\" + str(self.atypicalTermsDict[term]))\\n display = Display(self.vocabulary)\\n display.displayPieChartSummary(self.summaryDict, \\\"General Summary for 2008 flights in the USA\\\")\\n display.displayPieChartSummary(self.summaryFilteredDict, \\\"General Summary for 2008 flights with \\\"+str(self.listOfTerms)+\\\" and threshold : \\\" + str(self.threshold))\\n display.displayBubbleChart(self.correlationDict,\\\"Linked terms in 2008 flights with \\\" + str(self.listOfTerms) + \\\" and threshold = \\\" + str(self.threshold))\\n display.displayBubbleChart(self.atypicalTermsDict,\\\"Atypical terms in 2008 flights with \\\" + str(self.listOfTerms) + \\\" and threshold = \\\" + str(self.threshold))\\n else:\\n print(\\\"Filter returned no entry\\\")\\n except:\\n raise Exception(\\\"Error while loading the dataFile %s\\\" % self.dataFile)\",\n \"def lfq_parser_2x():\\n from tools import file_importer, file_outporter\\n # from random import random\\n from math import log10\\n \\n print(\\\"this is lfq parser_2x\\\")\\n \\n relPath = \\\"bob/processed/OST-24-05-2017_combined.csv\\\"\\n outPath = \\\"bob/processed/OST-24-05-2017_combined_no0_2.csv\\\"\\n inpF = file_importer(relPath)\\n outF = file_outporter(outPath) \\n headerFlag = True\\n rowCount = 0\\n for inpLine in inpF:\\n if headerFlag: \\n headerFlag = False\\n lfqColCount = 0\\n inpList = inpLine.split(\\\"\\\\t\\\")\\n for headerI in inpList:\\n if \\\"LFQ intensity\\\" in headerI:\\n break\\n else: lfqColCount += 1\\n outF.write(\\\"ID,Protein ID, Gene name,\\\") # write header into output file\\n for headI in inpList[lfqColCount].split(\\\"|\\\"):\\n outF.write(headI + \\\",\\\")\\n for headI in inpList[lfqColCount + 1].split(\\\"|\\\")[:-1]:\\n outF.write(headI + \\\",\\\")\\n outF.write(inpList[lfqColCount + 1].split(\\\"|\\\")[-1] + \\\"\\\\n\\\")\\n rowCount += 1\\n continue\\n \\n inpLine = inpLine.strip()\\n inpItems = inpLine.split(\\\"\\\\t\\\") \\n inpLFQ = inpItems[lfqColCount].split(\\\"|\\\") + inpItems[lfqColCount + 1].split(\\\"|\\\") # get lfq intensity scores\\n \\n procLFQ = []\\n for lfqi in inpLFQ:\\n if lfqi == \\\"_\\\": procLFQ.append(0)\\n else: procLFQ.append(int(lfqi))\\n if sum(procLFQ[:3])<=sum(procLFQ[3:]): continue # get rid of contaminants in control sample\\n \\n sumOne = inpLFQ[1] + inpLFQ[2]\\n sumTwo = inpLFQ[1] + inpLFQ[3]\\n sumThree = inpLFQ[2] + inpLFQ[3]\\n \\n if sumOne == \\\"__\\\" or sumTwo == \\\"__\\\" or sumThree == \\\"__\\\": continue # test if protein is being detected in at least 2 OST samples\\n \\n outF.write(str(rowCount) + \\\",\\\")\\n \\n\\n inpName = max(inpItems[0].split(\\\"|\\\"), key=len) # get unique protein ID\\n inpGeneName = max(inpItems[6].split(\\\"|\\\"), key=len) # and gene name\\n outF.write(inpName + \\\",\\\" + inpGeneName + \\\",\\\")\\n \\n inpLFQ = inpItems[lfqColCount].split(\\\"|\\\") + inpItems[lfqColCount + 1].split(\\\"|\\\") \\n # print inpLFQ\\n for lfqI in inpLFQ[:-1]: # write lfq values\\n if lfqI == \\\"_\\\" or lfqI == \\\"0\\\":\\n outF.write(str(0) + \\\",\\\") ################## try with log2 values this time\\n else:\\n try:\\n outF.write(str(round(log10(int(lfqI)))) + \\\",\\\")\\n except ValueError:\\n print(inpItems)\\n raise\\n \\n if inpLFQ[-1] == \\\"_\\\" or inpLFQ[-1] == \\\"0\\\": outF.write(str(0) + \\\"\\\\n\\\")\\n else: outF.write(str(round(log10(int(inpLFQ[-1])))) + \\\"\\\\n\\\")\\n \\n \\n rowCount += 1\\n\\n print(\\\"lfq parser 2x finished successfully\\\")\",\n \"def processMachineLog(file_name):\\n\\n # labelling of data lists\\n date = []\\n timeDay = []\\n iteration = []\\n iterationTime = [] # time it takes to complete a single cycle\\n timeElapsed = [] # time elapsed since start of test for the day\\n \\n \\\"\\\"\\\" sample of important lines from log\\n ##### Begin Iteration # 1 at Wed Jan 27 16:32:27 EST 2016\\n ##### Completed Iteration # 1 time: 13.643001secs Total time: 13.648001secs at Wed Jan 27 16:32:41 EST 2016\\n \\\"\\\"\\\"\\n\\n # opens csv file and sorts the data into the lists\\n # with open(file_name, 'rb') as csvfile:\\n with open(file_name, 'rb') as logFile:\\n data = logFile.readlines()\\n for line in data:\\n if line.startswith(\\\"##### Completed\\\"):\\n iteration.append(line.split(\\\" \\\")[4])\\n iterationTime.append(line.split(\\\" \\\")[7][:-4]) # remove \\\"secs\\\" from the value\\n # Get the Day of week, month, and date to put into date list\\n dayMoDate = line.split(\\\" \\\")[14] + \\\" \\\" + line.split(\\\" \\\")[15] + \\\" \\\" + line.split(\\\" \\\")[16] + \\\" \\\" + line.split(\\\" \\\")[19].rstrip()\\n date.append(dayMoDate)\\n # get the time in AM/PM format (because Jess can't read 24HR format to save her life)\\n convertTime = time.strftime(\\\"%I:%M:%S %p\\\", (time.strptime(line.split(\\\" \\\")[17] , \\\"%H:%M:%S\\\")))\\n timeDay.append(convertTime)\\n # get the total time (H:M:S format) that has elapsed since the beginning of the test\\n timeSecs = float(line.split(\\\" \\\")[11][:-4]) # remove \\\"secs\\\" from the value\\n timeElapsed.append(datetime.timedelta(seconds=timeSecs))\\n \\n # form the dataframe with all the lists as columns\\n df = pd.DataFrame({'Date': date, 'Time': timeDay, 'Cycle': iteration, 'Cycle Duration': iterationTime, 'Time Elapsed': timeElapsed})\\n return df\",\n \"def parse_trace(self):\\n current = '' # current basic block being parsed\\n previous = '0' # previous basic block beding parsed\\n edge_count = 0\\n uniq_count = 0\\n with open(self._fifo_name, 'r') as fifo:\\n for line in fifo:\\n if line[6] == '4':\\n continue\\n # process traceed tbs\\n current = line.split(':')[0]\\n\\n parse_edge = (previous, current)\\n edge_count += 1\\n if not parse_edge in TRACE_EDGES:\\n TRACE_EDGES.add(parse_edge)\\n uniq_count += 1\\n previous = current\",\n \"def analysis(N):\\n\\n http_log_paths = get_http_logs()\\n\\n httplogs = []\\n\\n for path in http_log_paths:\\n file = path+'/http.log'\\n if os.path.isfile(file):\\n httplogs.append(file)\\n else:\\n pass #print(path)\\n\\n fields = []\\n\\n for log in httplogs:\\n with open(log) as f:\\n lines = f.readlines()\\n rows = len(lines)\\n filesize = sum([len(line) for line in lines])\\n\\n tss = [] # time series\\n methods = []\\n uris = []\\n uas = []\\n request_body_lens = []\\n response_body_lens = []\\n status_codes = []\\n filenames = []\\n\\n tmp = []\\n\\n for line in lines[8:len(lines)-1]:\\n fs = line.strip().split('\\\\t')\\n\\n \\\"\\\"\\\"\\n ts = fileds[0]\\n uid = fileds[1]\\n orig_h = fileds[2]\\n orig_p = fileds[3]\\n resp_h = fileds[4]\\n resp_p = fileds[5]\\n trans_depth = fileds[6]\\n method = fileds[7]\\n host = fileds[8]\\n uri = fileds[9]\\n referrer = fileds[10]\\n user_agent = fileds[11]\\n request_body_len = fileds[12]\\n response_body_len = fileds[13]\\n status_code = fileds[14]\\n status_msg = fileds[15]\\n info_code = fileds[16]\\n info_msg = fileds[17]\\n filename = fileds[18]\\n tags = fileds[19]\\n username = fileds[20]\\n password = fileds[21]\\n proxied = fileds[22]\\n orig_fuids = fileds[23]\\n orig_mime_types = fileds[24]\\n resp_fuids = fileds[25]\\n resp_mime_types = fileds[26]\\n\\n tss.append(ts)\\n methods.append(method)\\n uris.append(uri)\\n uas.append(user_agent)\\n request_body_lens.append(request_body_len)\\n response_body_lens.append(response_body_len)\\n status_codes.append(status_code)\\n filenames.append(filename)\\n \\\"\\\"\\\"\\n\\n tmp.append(fs[N])\\n\\n #print(log, rows, ','.join(methods))\\n\\n # time intervals\\n #tss_sorted = sorted(map(float,tmp))\\n #tss_sorted = map(float, tmp)\\n #intervals = map(int,[tss_sorted[i+1]-tss_sorted[i] for i in range(len(tss_sorted)-1)])\\n #print('%s %s' % (log, ' '.join(map(str,intervals))))\\n #file = urlparse(fs[N]).path.split('/')[-1].split('.')\\n #if len(file)>1:\\n # tmp.append(file[-1])\\n #tmp.append(urlparse(fs[N]).path.split('/')[-1])\\n #tmp.append(urlparse(fs[N]).path)\\n\\n #fields.append(set(tmp))\\n #fields.append(intervals)\\n fields.append(tmp)\\n\\n\\n dic = {}\\n for i in fields:\\n for j in i:\\n if j in dic:\\n dic[j] += 1\\n else:\\n dic[j] = 1\\n ls = sorted(dic.items(), lambda x,y: cmp(x[1], y[1]), reverse = True)\\n for i in range(len(ls)):\\n print('%s\\\\t%s' %(ls[i][0], ls[i][1]))\\n #print('%s' % join(ls[i][1]))\\n\\n\\n \\\"\\\"\\\"\\n col = []\\n for i in fields:\\n for j in i:\\n col.append(j)\\n print('%s' % ' '.join(map(str,col)))\\n \\\"\\\"\\\"\\n\\n\\n \\\"\\\"\\\"\\n dic = {}\\n for i in fields:\\n for j in i:\\n sub = j.split('.')\\n if sub[0] in dic:\\n dic[sub[0]] += 1\\n else:\\n dic[sub[0]] = 1\\n\\n\\n if len(sub) > 1:\\n if sub[-2]+'.'+sub[-1] in dic:\\n dic[sub[-2]+'.'+sub[-1]] += 1\\n else:\\n dic[sub[-2]+'.'+sub[-1]] = 1\\n\\n\\n ls = sorted(dic.items(), lambda x, y: cmp(x[1], y[1]), reverse=True)\\n for i in range(len(ls)):\\n print('%s\\\\t%s' % (ls[i][0], ls[i][1]))\\n # print('%s' % join(ls[i][1]))\\n\\n \\\"\\\"\\\"\",\n \"def _log_file_processing_stats(self, known_file_paths):\\n # File Path: Path to the file containing the DAG definition\\n # PID: PID associated with the process that's processing the file. May\\n # be empty.\\n # Runtime: If the process is currently running, how long it's been\\n # running for in seconds.\\n # Last Runtime: If the process ran before, how long did it take to\\n # finish in seconds\\n # Last Run: When the file finished processing in the previous run.\\n headers = [\\\"File Path\\\", \\\"PID\\\", \\\"Runtime\\\", \\\"# DAGs\\\", \\\"# Errors\\\", \\\"Last Runtime\\\", \\\"Last Run\\\"]\\n\\n rows = []\\n now = timezone.utcnow()\\n for file_path in known_file_paths:\\n last_runtime = self.get_last_runtime(file_path)\\n num_dags = self.get_last_dag_count(file_path)\\n num_errors = self.get_last_error_count(file_path)\\n file_name = os.path.basename(file_path)\\n file_name = os.path.splitext(file_name)[0].replace(os.sep, \\\".\\\")\\n\\n processor_pid = self.get_pid(file_path)\\n processor_start_time = self.get_start_time(file_path)\\n runtime = (now - processor_start_time) if processor_start_time else None\\n last_run = self.get_last_finish_time(file_path)\\n if last_run:\\n seconds_ago = (now - last_run).total_seconds()\\n Stats.gauge(f\\\"dag_processing.last_run.seconds_ago.{file_name}\\\", seconds_ago)\\n\\n rows.append((file_path, processor_pid, runtime, num_dags, num_errors, last_runtime, last_run))\\n\\n # Sort by longest last runtime. (Can't sort None values in python3)\\n rows.sort(key=lambda x: x[3] or 0.0)\\n\\n formatted_rows = []\\n for file_path, pid, runtime, num_dags, num_errors, last_runtime, last_run in rows:\\n formatted_rows.append(\\n (\\n file_path,\\n pid,\\n f\\\"{runtime.total_seconds():.2f}s\\\" if runtime else None,\\n num_dags,\\n num_errors,\\n f\\\"{last_runtime:.2f}s\\\" if last_runtime else None,\\n last_run.strftime(\\\"%Y-%m-%dT%H:%M:%S\\\") if last_run else None,\\n )\\n )\\n log_str = (\\n \\\"\\\\n\\\"\\n + \\\"=\\\" * 80\\n + \\\"\\\\n\\\"\\n + \\\"DAG File Processing Stats\\\\n\\\\n\\\"\\n + tabulate(formatted_rows, headers=headers)\\n + \\\"\\\\n\\\"\\n + \\\"=\\\" * 80\\n )\\n\\n self.log.info(log_str)\",\n \"def stat_parser():\\n from tools import file_importer, file_outporter\\n from math import log\\n \\n print(\\\"this is stat parser\\\")\\n \\n relPath = \\\"bob/processed/24h_bobdata_ed2.csv\\\"\\n outPathUp = \\\"bob/processed/24h_bobprots_up_full.csv\\\"\\n outPathDown = \\\"bob/processed/24h_bobprots_down_full.csv\\\"\\n inpF = file_importer(relPath)\\n outFUp = file_outporter(outPathUp)\\n outFDown = file_outporter(outPathDown)\\n \\n \\n skipFlag = True\\n \\n for inpLine in inpF:\\n if skipFlag:\\n skipFlag = False\\n outFDown.write(\\\"ID,Uniprot ID,Gene name,unique peptides (unique+razor),KO1,KO2,KO3,WT1,WT2,WT3,enrichment,P value\\\\n\\\")\\n outFUp.write(\\\"ID,Uniprot ID,Gene name,unique peptides (unique+razor),KO1,KO2,KO3,WT1,WT2,WT3,enrichment,P value\\\\n\\\")\\n continue\\n inpLine = inpLine.split(\\\"\\\\\\\" \\\\\\\"\\\")\\n curLine = []\\n for inpI in inpLine:\\n curLine.append(inpI.strip(\\\"\\\\\\\"\\\\n\\\"))\\n try: \\n curLine[-1] = float(curLine[-1])\\n except ValueError:\\n curLine[-1] = 1 \\n if curLine[-1] < 0.05 and int(curLine[3]) > 1: # check if protein has at least 2 unique peptides and has a significant p value\\n curLine[4:10] = [int(x) for x in curLine[4:10]]\\n enrScore = log((sum(curLine[4:7]) / 3.0)/(sum(curLine[7:10]) / 3.0),2) # calculate log2 enrichment score\\n # print int(sum(curLine[4:7]) / 3.0), int(sum(curLine[7:10]) / 3.0)\\n if sum(curLine[4:7]) / 3.0 > sum(curLine[7:10]) / 3.0: # if the mean of the KO intensities is higher than the wt \\n for outI in curLine:\\n outFDown.write(str(outI).strip(\\\" \\\"))\\n if outI is not curLine[-1]:\\n outFDown.write(\\\",\\\")\\n if outI is curLine[-2]:\\n outFDown.write(str(enrScore)+ \\\",\\\")\\n else:\\n outFDown.write(\\\"\\\\n\\\")\\n # outFDown.write(curLine[1] + \\\",\\\" + curLine[2] + \\\"\\\\n\\\")\\n else:\\n # outFUp.write(curLine[1] + \\\",\\\" + curLine[2] + \\\"\\\\n\\\")\\n for outI in curLine:\\n outFUp.write(str(outI).strip(\\\" \\\"))\\n if outI is not curLine[-1]:\\n outFUp.write(\\\",\\\")\\n if outI is curLine[-2]:\\n outFUp.write(str(enrScore)+ \\\",\\\")\\n else:\\n outFUp.write(\\\"\\\\n\\\")\\n \\n inpF.close()\\n outFUp.close()\\n outFDown.close()\\n print(\\\"stat_parser completed\\\")\",\n \"def _read_traces(self, unpack_headers=False, headonly=False,\\n yield_each_trace=False):\\n self.traces = []\\n # Determine the filesize once.\\n if isinstance(self.file, io.BytesIO):\\n pos = self.file.tell()\\n self.file.seek(0, 2) # go t end of file\\n filesize = self.file.tell()\\n self.file.seek(pos, 0)\\n else:\\n filesize = os.fstat(self.file.fileno())[6]\\n # Big loop to read all data traces.\\n i = -1\\n while True:\\n # Read and as soon as the trace header is too small abort.\\n try:\\n trace = SEGYTrace(self.file, self.data_encoding, self.endian,\\n unpack_headers=unpack_headers,\\n filesize=filesize, headonly=headonly)\\n i += 1\\n if yield_each_trace:\\n yield trace\\n else:\\n if self.hdf_writer == 0:\\n self.traces.append(trace)\\n else:\\n if headonly and not self.hdf_writer.need_writing:\\n self.hdf_writer.count_of_traces += 1\\n elif self.hdf_writer.need_writing:\\n self.hdf_writer.add_trace(trace, i)\\n else:\\n self.traces.append(trace)\\n\\n except SEGYTraceHeaderTooSmallError:\\n break\",\n \"def get_traces(self):\\n\\n self.rank = 0\\n traces = []\\n sub_traces = []\\n current = []\\n with open(self.file_path, 'r') as f:\\n for line in f:\\n current.append(line.strip('\\\\n').replace('<', '\\\\<').replace('>', '\\\\>'))\\n sub_traces.append(current)\\n traces.append(sub_traces)\\n return traces\",\n \"def read_results(self, filepath):\\n \\n if isinstance(filepath, str):\\n finput = open(filepath)\\n elif isinstance(filepath, file):\\n finput = filepath\\n else:\\n raise Exception, \\\"filepath should be a path or a file descriptor\\\"\\n \\n i=0\\n found_xsec_line = False\\n for line in finput: \\n # Exit as soon as we hit the xml part. Not elegant, but the part\\n # below should eventually be xml anyway.\\n if '<' in line:\\n break\\n i+=1\\n if i == 1:\\n def secure_float(d):\\n try:\\n return float(d)\\n except ValueError:\\n m=re.search(r'''([+-]?[\\\\d.]*)([+-]\\\\d*)''', d)\\n if m:\\n return float(m.group(1))*10**(float(m.group(2)))\\n return \\n\\n data = [secure_float(d) for d in line.split()]\\n self.axsec, self.xerru, self.xerrc, self.nevents, self.nw,\\\\\\n self.maxit, self.nunwgt, self.luminosity, self.wgt, \\\\\\n self.xsec = data[:10]\\n if len(data) > 10:\\n self.maxwgt = data[10]\\n if len(data) >12:\\n self.th_maxwgt, self.th_nunwgt = data[11:13]\\n if self.mfactor > 1:\\n self.luminosity /= self.mfactor\\n continue\\n try:\\n l, sec, err, eff, maxwgt, asec = line.split()\\n found_xsec_line = True\\n except:\\n break\\n self.ysec_iter.append(secure_float(sec))\\n self.yerr_iter.append(secure_float(err))\\n self.yasec_iter.append(secure_float(asec))\\n self.eff_iter.append(secure_float(eff))\\n self.maxwgt_iter.append(secure_float(maxwgt))\\n\\n finput.seek(0)\\n xml = []\\n for line in finput:\\n if re.match('^.*<.*>',line):\\n xml.append(line)\\n break\\n for line in finput:\\n xml.append(line)\\n\\n if xml:\\n self.parse_xml_results('\\\\n'.join(xml)) \\n \\n # this is for amcatnlo: the number of events has to be read from another file\\n if self.nevents == 0 and self.nunwgt == 0 and isinstance(filepath, str) and \\\\\\n os.path.exists(pjoin(os.path.split(filepath)[0], 'nevts')): \\n nevts = int((open(pjoin(os.path.split(filepath)[0], 'nevts')).read()).split()[0])\\n self.nevents = nevts\\n self.nunwgt = nevts\",\n \"def process(self, terms):\\n for entry in self.files:\\n try:\\n logger.info('file - {0}'.format(entry.path))\\n\\n # notional output file path\\n path_sentences = self.path.joinpath('{0}.csv'.format(entry.path.stem))\\n path_summary = self.path.joinpath('{0}-summary.csv'.format(entry.path.stem))\\n logger.info('will save to - {0}'.format(path_sentences.resolve()))\\n\\n reports = self.inspect_doc(entry, terms)\\n\\n # receiving a list of dicts\\n # therefore pandas can package into a useful outcome\\n if len(reports) > 0:\\n frame_sentences = pd.DataFrame(reports)\\n\\n frame_sentences = frame_sentences[['page', 'term', 'sentence']]\\n logger.info('saving sentence file to - {0}'.format(path_sentences.resolve()))\\n frame_sentences.to_csv(str(path_sentences.resolve()))\\n \\n frame_summary = frame_sentences.pivot_table(\\n index='page',\\n columns='term',\\n aggfunc='size',\\n fill_value=0\\n )\\n logger.info('saving summary file to - {0}'.format(path_sentences.resolve()))\\n frame_summary.to_csv(str(path_summary.resolve()))\\n\\n\\n except Exception as e:\\n logger.error(e)\",\n \"def lfq_parser():\\n # from tools import file_importer, file_outporter\\n from random import randint\\n import os.path\\n # from math import log10\\n \\n print(\\\"this is lfq parser\\\")\\n \\n \\\"\\\"\\\"\\n relPath = \\\"bob/processed/OST-24-05-2017_combined.csv\\\"\\n outPath = \\\"bob/processed/OST-24-05-2017_combined_no0_1000.csv\\\"\\n inpF = file_importer(relPath)\\n outF = file_outporter(outPath) \\n \\\"\\\"\\\"\\n inpF = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \\\"data\\\", \\\"cav1ko\\\", \\\"processed\\\", \\\"cav1ko-1.csv\\\"),\\\"r\\\")\\n outF = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \\\"data\\\", \\\"cav1ko\\\", \\\"processed\\\", \\\"cav1ko-1_no0.csv\\\"),\\\"w\\\")\\n \\n headerFlag = True\\n rowCount = 0\\n for inpLine in inpF:\\n if headerFlag: \\n headerFlag = False\\n lfqColCount = 0\\n inpList = inpLine.split(\\\"\\\\t\\\")\\n for headerI in inpList:\\n if \\\"LFQ intensity\\\" in headerI:\\n break\\n else: lfqColCount += 1\\n outF.write(\\\"ID,Protein ID, Gene name,\\\") # write header into output file\\n if len(inpList[lfqColCount].split(\\\"|\\\")) > 1:\\n for headI in inpList[lfqColCount].split(\\\"|\\\"):\\n outF.write(headI + \\\",\\\")\\n for headI in inpList[lfqColCount + 1].split(\\\"|\\\")[:-1]:\\n outF.write(headI + \\\",\\\")\\n outF.write(inpList[lfqColCount + 1].split(\\\"|\\\")[-1] + \\\"\\\\n\\\")\\n else:\\n outF.write(inpList[lfqColCount] + \\\",\\\")\\n outF.write(inpList[lfqColCount + 1] + \\\",\\\")\\n outF.write(inpList[lfqColCount + 2] + \\\"\\\\n\\\")\\n rowCount += 1\\n continue\\n \\n outF.write(str(rowCount) + \\\",\\\")\\n \\n inpLine = inpLine.strip()\\n inpItems = inpLine.split(\\\"\\\\t\\\")\\n inpName = max(inpItems[0].split(\\\"|\\\"), key=len) # get unique protein ID\\n inpGeneName = max(inpItems[6].split(\\\"|\\\"), key=len) # and gene name\\n outF.write(inpName + \\\",\\\" + inpGeneName + \\\",\\\")\\n \\n inpLFQ = inpItems[lfqColCount].split(\\\"|\\\") + inpItems[lfqColCount + 1].split(\\\"|\\\") + inpItems[lfqColCount + 2].split(\\\"|\\\")# get lfq intensity scores\\n # print inpLFQ\\n for lfqI in inpLFQ[:-1]: # write lfq values\\n if lfqI == \\\"_\\\" or lfqI == \\\"0\\\":\\n outF.write(str(randint(1,1000)) + \\\",\\\") ################## try with log10 values this time\\n else:\\n try:\\n outF.write(str(int(lfqI)) + \\\",\\\")\\n except ValueError:\\n print(inpItems)\\n raise\\n \\n if inpLFQ[-1] == \\\"_\\\" or inpLFQ[-1] == \\\"0\\\": outF.write(str(randint(1,1000)) + \\\"\\\\n\\\")\\n else: outF.write(str(inpLFQ[-1]) + \\\"\\\\n\\\")\\n \\n \\n \\n rowCount += 1\\n\\n \\n \\n \\\"\\\"\\\"\\n \\n for inpI in inpItems[0:4]: # copy over gene name and such to new file\\n outF.write(inpI)\\n outF.write(\\\",\\\")\\n \\n commaCount = 0\\n for inpJ in inpItems[4:]: # copy over lfq values while replacing 0-s with random values\\n commaCount += 1\\n if int(inpJ) == 0:\\n randNum = randint(1,100)\\n outF.write(str(randNum))\\n else:\\n outF.write(inpJ)\\n if commaCount < 6:\\n outF.write(\\\",\\\")\\n outF.write(\\\"\\\\n\\\")\\n inpF.close()\\n outF.close()\\n \\n \\\"\\\"\\\"\\n \\n print(\\\"lfq parser finished successfully\\\")\",\n \"def main():\\n\\n file_name_base = \\\"./lab-record/result/fairness/\\\"\\n scenarios = ['lan', 'wan1', 'wan2']\\n scenario = scenarios[2]\\n\\n algorithms = [\\\"bbr\\\", \\\"scalable\\\", \\\"bic\\\", \\\"highspeed\\\", \\\"htcp\\\", \\\"hybla\\\",\\n \\\"illinois\\\", \\\"vegas\\\", \\\"yeah\\\"]\\n names = [\\\"BBR\\\", \\\"Scalable\\\", \\\"BIC\\\", \\\"High Speed\\\",\\n \\\"H-TCP\\\", \\\"Hybla\\\", \\\"Illinois\\\", \\\"Vegas\\\", \\\"YeAH\\\"]\\n\\n test_types = [\\\"vs_reno\\\", \\\"vs_cubic\\\", \\\"vs_itself\\\"]\\n\\n fsize = 36\\n \\n index_reno = []\\n index_cubic = []\\n index_itself = []\\n\\n data = []\\n \\n print 'Loadint statistics for ' + file_name_base + '/' + scenario\\n\\n for algorithm in algorithms:\\n for test in test_types:\\n path_base = file_name_base + \\\"/\\\" + scenario + \\\"/\\\" + test + \\\"/\\\" + \\\\\\n algorithm + \\\"/\\\"\\n if test == \\\"vs_itself\\\":\\n exp_name = names[algorithms.index(algorithm)] + \\\"_1\\\"\\n con_name = names[algorithms.index(algorithm)] + \\\"_2\\\"\\n print path_base + exp_name\\n print path_base + con_name\\n exp_filename = \\\"/\\\" + algorithm + \\\"_1.log\\\"\\n con_filename = \\\"/\\\" + algorithm + \\\"_2.log\\\"\\n process(path_base, exp_filename, con_filename, index_itself)\\n if test == \\\"vs_reno\\\":\\n exp_name = names[algorithms.index(algorithm)]\\n con_name = \\\"Reno\\\"\\n print path_base + exp_name\\n print path_base + con_name\\n exp_filename = \\\"/\\\" + algorithm + \\\".log\\\"\\n con_filename = \\\"/reno.log\\\"\\n process(path_base, exp_filename, con_filename, index_reno)\\n if test == \\\"vs_cubic\\\":\\n con_name = \\\"CUBIC\\\"\\n exp_name = names[algorithms.index(algorithm)]\\n print path_base + exp_name\\n print path_base + con_name\\n exp_filename = \\\"/\\\" + algorithm + \\\".log\\\"\\n con_filename = \\\"/cubic.log\\\"\\n process(path_base, exp_filename, con_filename, index_cubic)\\n\\n size = 9\\n x = numpy.arange(size)\\n\\n total_width, n = 1.2, 2.5\\n width = 1.0 / n\\n x = x - (total_width - width) / 2\\n\\n for i in range(0, len(x)):\\n x[i] += 0.5 * i\\n\\n # Exp\\n fig = plt.figure()\\n\\n # Con\\n con_reno = plt.bar(x + 0 * width - 1.2,\\n index_reno,\\n width=width,\\n label='Against Reno',\\n alpha=0.5,\\n color=\\\"darkorange\\\")\\n\\n con_cubic = plt.bar(x + 1 * width - 1.2,\\n index_cubic,\\n width=width,\\n label='Against CUBIC',\\n alpha=0.5,\\n color=\\\"lawngreen\\\")\\n\\n con_itself = plt.bar(x + 2 * width - 1.2,\\n index_itself,\\n width=width,\\n label='Against Another Same CCA',\\n alpha=0.5,\\n color=\\\"dodgerblue\\\")\\n\\n # Index\\n plt.xticks(x + 1.5 * width - 1.2, [\\\"BBR\\\", \\\"Scalable\\\", \\\"BIC\\\", \\\"High Speed\\\",\\n \\\"H-TCP\\\", \\\"Hybla\\\", \\\"Illinois\\\", \\\"Vegas\\\",\\n \\\"YeAH\\\"],\\n fontsize=fsize,\\n rotation=\\\"45\\\")\\n plt.ylabel(\\\"Jain`s Fairness Index\\\", fontsize=fsize)\\n plt.yticks(fontsize=fsize)\\n plt.ylim(0.5, 1.1)\\n\\n ax = plt.subplot(111)\\n ax.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3,\\n ncol=3, mode=\\\"expand\\\", borderaxespad=0., fontsize=fsize)\\n\\n plt.subplots_adjust(left=0.07, right=0.98, top=0.9, bottom=0.2)\\n\\n plt.show()\",\n \"def Processrawtrace(self):\\n \\n tracedict = {}\\n \\n for l in open(self.paramsfile):\\n tracedict[l.split(',')[0]] = (l.split(',')[1])\\n \\n tracedict['f1'] = int(tracedict['f1'])\\n tracedict['f2'] = self.f2\\n tracedict['fps'] = int(tracedict['fps'])\\n tracedict['f_end'] = int(tracedict['f_end'])\\n tracedict['flypic'] = dftf.getflypic('roi') \\n tracedict['rawtrace'] = dftf.loadresultsfile(self.fname, 'Mean1')\\n tracedict['msubtrace'] = msub(tracedict['rawtrace'][0:tracedict['f2']])\\n \\n return tracedict\",\n \"def main(files, target_depth, tol_diff, depth_fld, temperature_fld,\\n salinity_fld):\\n ymd_fmt = \\\"{0}-{1}-{2}\\\"\\n # Note change of line terminator to make it compatible with AWK\\n writer = csv.writer(sys.stdout, lineterminator='\\\\n')\\n writer.writerow([\\\"time\\\", \\\"bottle_number\\\", \\\"depth\\\",\\n \\\"temperature\\\", \\\"salinity\\\"])\\n for bottle_f in files:\\n with bottle_f:\\n for lineno, line in enumerate(bottle_f, start=1):\\n if re.search('^(\\\\*|#)', line):\\n continue\\n if re.search('^ *bottle', line.lower()):\\n databeg = lineno + 2\\n continue\\n if (lineno - databeg) % 2 == 0:\\n parsedl = line.split()\\n mm = _french_month(parsedl[1])\\n if mm:\\n fmt = '%Y-%m-%d %H:%M:%S'\\n yyyymmdd = ymd_fmt.format(parsedl[3], mm, parsedl[2])\\n else:\\n fmt = '%Y-%b-%d %H:%M:%S'\\n yyyymmdd = ymd_fmt.format(parsedl[3], parsedl[1],\\n parsedl[2])\\n bottle_no = parsedl[0]\\n depth = parsedl[depth_fld - 1]\\n temperature = parsedl[temperature_fld - 1]\\n salinity = parsedl[salinity_fld - 1]\\n else:\\n if lineno <= databeg:\\n continue\\n hhmmss = line.split()[0]\\n ymd = datetime.strptime(\\\"{0} {1}\\\".format(yyyymmdd,\\n hhmmss), fmt)\\n depth_dev = abs(float(depth) - target_depth)\\n if (depth_dev < tol_diff):\\n line_out = (ymd.strftime('%Y-%m-%d %H:%M:%S'),\\n bottle_no, depth, temperature,\\n salinity)\\n writer.writerow(line_out)\",\n \"def inner():\\n for line in file_obj:\\n logdata = tilak_haproxylog.parse_line(line)\\n if logdata is not None:\\n logdata[\\\"hits\\\"] = 1\\n for value_key in value_keynames:\\n if value_key not in logdata:\\n logdata[value_key] = 0\\n status_code = int(logdata[\\\"status_code\\\"])\\n if 100 <= status_code <= 199:\\n logdata[\\\"rsp_1xx\\\"] = 1\\n elif 200 <= status_code <= 299:\\n logdata[\\\"rsp_2xx\\\"] = 1\\n elif 300 <= status_code <= 399:\\n logdata[\\\"rsp_3xx\\\"] = 1\\n elif 400 <= status_code <= 499:\\n logdata[\\\"rsp_4xx\\\"] = 1\\n elif 500 <= status_code <= 599:\\n logdata[\\\"rsp_5xx\\\"] = 1\\n else:\\n logdata[\\\"rsp_other\\\"] = 1\\n ret_data = dict(zip(index_keynames, (logdata[index_key] for index_key in index_keynames)))\\n ret_data.update(dict(zip(value_keynames, (logdata[value_key] for value_key in value_keynames))))\\n yield (logdata[\\\"ts\\\"], ret_data)\",\n \"def produce_next_term_data(self):\\n outputs = self.output()\\n for termnum in self.term_range: # includes (end term + 1)\\n test = self.test[self.test.termnum == termnum]\\n\\n # remove cold start recordsif requested\\n test = self.handle_cold_start(test)\\n\\n term_outputs = outputs[termnum]\\n trainf, testf = term_outputs['train'], term_outputs['test']\\n with trainf.open('w') as ftrain, testf.open('w') as ftest:\\n self.write_libfm_data(ftrain, ftest, self.train, test)\\n\\n self.transfer_term(termnum) # modify train/test sets in place\\n # intentionally skip writing the last time this is run\\n\\n # TODO: this code converts the same records to libFM format multiple\\n # times. Each subsequent train set contains records in the last train\\n # set. These could be cached to avoid all of the string format\\n # conversion overhead.\",\n \"def record_trace(self):\\n\\n tfname = str(int(time.time())) + \\\".obd2_reader.trace\\\"\\n self.tf_out = open(tfname, 'a')\\n self.RecordTrace = 1\\n print \\\"Recoding trace to:\\\", tfname\",\n \"def analysis(file):\\n\\n fields = []\\n\\n with open(file) as f:\\n lines = f.readlines()\\n rows = len(lines)\\n filesize = sum([len(line) for line in lines])\\n\\n tmp = []\\n\\n for line in lines[8:len(lines)-1]:\\n fs = line.strip().split('\\\\t')\\n\\n \\\"\\\"\\\"\\n fields:\\n ts\\n uid\\n id.orig_h\\n id.orig_p\\n id.resp_h\\n id.resp_p\\n proto\\n trans_id\\n query\\n qclass\\n qclass_name\\n qtype\\n qtype_name\\n rcode\\n rcode_name\\n AA\\n TC\\n RD\\n RA\\n Z\\n answersTTLs\\n rejected\\n \\\"\\\"\\\"\\n\\n tmp.append(fs[N])\\n\\n #print(log, rows, ','.join(methods))\\n\\n # time intervals\\n #tss_sorted = sorted(map(float,tmp))\\n #tss_sorted = map(float, tmp)\\n #intervals = map(int,[tss_sorted[i+1]-tss_sorted[i] for i in range(len(tss_sorted)-1)])\\n #print('%s %s' % (log, ' '.join(map(str,intervals))))\\n #file = urlparse(fs[N]).path.split('/')[-1].split('.')\\n #if len(file)>1:\\n # tmp.append(file[-1])\\n #tmp.append(urlparse(fs[N]).path.split('/')[-1])\\n #tmp.append(urlparse(fs[N]).path)\\n\\n #fields.append(set(tmp))\\n #fields.append(intervals)\\n fields.append(tmp)\\n\\n\\n dic = {}\\n for i in fields:\\n for j in i:\\n if j in dic:\\n dic[j] += 1\\n else:\\n dic[j] = 1\\n ls = sorted(dic.items(), lambda x,y: cmp(x[1], y[1]), reverse = True)\\n for i in range(len(ls)):\\n print('%s\\\\t%s' %(ls[i][0], ls[i][1]))\\n #print('%s' % join(ls[i][1]))\",\n \"def run(self):\\n lineage_csv_gz = self.input_files_local[0][0]\\n output_db = self.output_files_local()[0]\\n log.write(f\\\"input: {lineage_csv_gz} output: {output_db}\\\")\\n\\n with IdSeqDictForUpdate(output_db, IdSeqDictValue.VALUE_TYPE_ARRAY) as lineage_dict:\\n batch_list = {}\\n with gzip.open(lineage_csv_gz, \\\"rt\\\") as gzf:\\n for line in gzf:\\n fields = line.rstrip().split(\\\",\\\")\\n taxid = fields[0]\\n species, genus, family = fields[-1:-4:-1]\\n batch_list[taxid] = [species, genus, family]\\n if len(batch_list) >= BATCH_INSERT_SIZE:\\n lineage_dict.batch_inserts(batch_list.items())\\n batch_list = {}\\n lineage_dict.batch_inserts(batch_list.items())\",\n \"def read_trace(self, trace):\\n csv_reader = csv.DictReader(self.csv_fd)\\n for row in csv_reader:\\n new_trace = RiscvInstructiontTraceEntry()\\n new_trace.rd = row['rd']\\n new_trace.rd_val = row['rd_val']\\n new_trace.addr = row['addr']\\n new_trace.binary = row['binary']\\n new_trace.instr_str = row['str']\\n trace.append(new_trace)\",\n \"def parse_file(self):\\n file_time = ''\\n num_dir = 0\\n num_freq = 0\\n freq_w_band = 0.0\\n freq_0 = 0.0\\n start_dir = 0.0\\n\\n dspec_matrix = []\\n\\n # Extract the file time from the file name\\n input_file_name = self._stream_handle.name\\n\\n match = FILE_NAME_MATCHER.match(input_file_name)\\n\\n if match:\\n file_time = match.group(1)\\n else:\\n error_message = 'Unable to extract file time from DSpec input file name: %s '\\\\\\n % input_file_name\\n log.warn(error_message)\\n self._exception_callback(RecoverableSampleException(error_message))\\n\\n # read the first line in the file\\n line = self._stream_handle.readline()\\n\\n # loop over all lines in the data file\\n while line:\\n\\n if EMPTY_LINE_MATCHER.match(line):\\n # ignore blank lines, do nothing\\n pass\\n\\n elif HEADER_MATCHER.match(line):\\n\\n # we need header records to extract useful information\\n for matcher in HEADER_MATCHER_LIST:\\n header_match = matcher.match(line)\\n\\n if header_match is not None:\\n\\n # Look for specific header lines and extract header fields\\n if matcher is DIR_FREQ_MATCHER:\\n num_dir = int(header_match.group(1))\\n num_freq = int(header_match.group(2))\\n\\n elif matcher is FREQ_BAND_MATCHER:\\n freq_w_band = header_match.group(1)\\n freq_0 = header_match.group(2)\\n\\n elif matcher is START_DIR_MATCHER:\\n start_dir = header_match.group(1)\\n\\n else:\\n #ignore\\n pass\\n\\n elif DSPEC_DATA_MATCHER.match(line):\\n\\n # Extract a row of the Directional Surface Spectrum matrix\\n sensor_match = DSPEC_DATA_MATCHER.match(line)\\n data = sensor_match.group(1)\\n values = [int(x) for x in data.split()]\\n\\n num_values = len(values)\\n\\n # If the number of values in a line of data doesn't match num_dir,\\n # Drop the record, throw a recoverable exception and continue parsing\\n if num_values != num_dir:\\n error_message = 'Unexpected Number of directions in line: expected %s, got %s'\\\\\\n % (num_dir, num_values)\\n log.warn(error_message)\\n self._exception_callback(RecoverableSampleException(error_message))\\n else:\\n # Add the row to the dspec matrix\\n dspec_matrix.append(values)\\n\\n else:\\n # Generate a warning for unknown data\\n error_message = 'Unexpected data found in line %s' % line\\n log.warn(error_message)\\n self._exception_callback(RecoverableSampleException(error_message))\\n\\n # read the next line in the file\\n line = self._stream_handle.readline()\\n\\n # Check to see if the specified number of frequencies were retrieved from the data\\n dspec_matrix_length = len(dspec_matrix)\\n if dspec_matrix_length != num_freq:\\n error_message = 'Unexpected Number of frequencies in DSpec Matrix: expected %s, got %s'\\\\\\n % (num_freq, dspec_matrix_length)\\n log.warn(error_message)\\n self._exception_callback(RecoverableSampleException(error_message))\\n\\n # Construct the parsed data list to hand over to the Data Particle class for particle creation\\n parsed_data = [\\n file_time, # ('file_time', 0, str),\\n num_dir, # ('num_dir', 1, int),\\n num_freq, # ('num_freq', 2, int),\\n freq_w_band, # ('freq_w_band', 3, float),\\n freq_0, # ('freq_0', 4, float),\\n start_dir, # ('start_dir', 5, float),\\n dspec_matrix # ('directional_surface_spectrum', 6, list)]\\n ]\\n\\n # Extract a particle and append it to the record buffer\\n particle = self._extract_sample(AdcptMDspecInstrumentDataParticle, None, parsed_data)\\n self._record_buffer.append(particle)\",\n \"def process_spike_sim_log(spike_log, csv):\\n logging.info(\\\"Processing spike log : %s\\\" % spike_log)\\n instr_cnt = 0\\n spike_instr = \\\"\\\"\\n\\n RD_RE = re.compile(r\\\"(?P<pri>\\\\d) 0x(?P<addr>[a-f0-9]+?) \\\" \\\\\\n \\\"\\\\((?P<bin>.*?)\\\\) x\\\\s*(?P<reg>\\\\d*?) 0x(?P<val>[a-f0-9]+)\\\")\\n CORE_RE = re.compile(r\\\"core.*0x(?P<addr>[a-f0-9]+?) \\\\(0x(?P<bin>.*?)\\\\) (?P<instr>.*?)$\\\")\\n INSTR_RE = re.compile(r\\\"(?P<instr>[a-z\\\\.]+?)(\\\\s+?)(?P<operand>.*)\\\")\\n GPR_RE = re.compile(r\\\"^[a-z][0-9a-z]$\\\")\\n CSR_RE = re.compile(r\\\"csr\\\")\\n ILLE_RE = re.compile(r\\\"trap_illegal_instruction\\\")\\n\\n # Remove all the init spike boot instructions\\n cmd = (\\\"sed -i '/core.*0x0000000000001010/,$!d' %s\\\" % spike_log)\\n os.system(cmd)\\n # Remove all instructions after ecall (end of program excecution)\\n cmd = (\\\"sed -i '/ecall/q' %s\\\" % spike_log)\\n os.system(cmd)\\n\\n gpr = {}\\n gpr[\\\"zero\\\"] = 0\\n\\n with open(spike_log, \\\"r\\\") as f, open(csv, \\\"w\\\") as csv_fd:\\n trace_csv = RiscvInstructiontTraceCsv(csv_fd)\\n trace_csv.start_new_trace()\\n for line in f:\\n # Extract instruction infromation\\n m = CORE_RE.search(line)\\n if m:\\n spike_instr = m.group(\\\"instr\\\")\\n rv_instr_trace = RiscvInstructiontTraceEntry()\\n rv_instr_trace.instr_str = spike_instr\\n rv_instr_trace.addr = m.group(\\\"addr\\\")\\n rv_instr_trace.binary = m.group(\\\"bin\\\")\\n if spike_instr == \\\"wfi\\\":\\n trace_csv.write_trace_entry(rv_instr_trace)\\n continue\\n nextline = f.readline()\\n if nextline != \\\"\\\":\\n if ILLE_RE.search(nextline):\\n continue\\n m = RD_RE.search(nextline)\\n if m:\\n # Extract RD information\\n instr_cnt += 1\\n rv_instr_trace.rd = gpr_to_abi(\\\"x%0s\\\" % m.group(\\\"reg\\\"))\\n rv_instr_trace.rd_val = m.group(\\\"val\\\")\\n rv_instr_trace.privileged_mode = m.group(\\\"pri\\\")\\n gpr[rv_instr_trace.rd] = rv_instr_trace.rd_val\\n s = INSTR_RE.search(spike_instr)\\n if s:\\n rv_instr_trace.instr = s.group(\\\"instr\\\")\\n operand_str = s.group(\\\"operand\\\").replace(\\\" \\\", \\\"\\\")\\n if operand_str != \\\"\\\" :\\n operands = operand_str.split(\\\",\\\")\\n if CSR_RE.search(s.group(\\\"instr\\\")):\\n # CSR instruction\\n operand = operands[-1]\\n if GPR_RE.search(operand) or operand == \\\"zero\\\":\\n rv_instr_trace.rs1 = operand\\n rv_instr_trace.rs1_val = gpr[operand]\\n else:\\n rv_instr_trace.imm = operand\\n else:\\n # Non CSR instruction\\n for i in range(1, len(operands)):\\n operand = operands[i]\\n if GPR_RE.search(operand) or operand == \\\"zero\\\":\\n if i == 1:\\n rv_instr_trace.rs1 = operand\\n rv_instr_trace.rs1_val = gpr[operand]\\n else:\\n rv_instr_trace.rs2 = operands[i]\\n rv_instr_trace.rs2_val = gpr[operand]\\n else:\\n rv_instr_trace.imm = operand\\n trace_csv.write_trace_entry(rv_instr_trace)\\n logging.info(\\\"Processed instruction count : %d\\\" % instr_cnt)\",\n \"def flush_parse_initialize(self):\\n self.current_cluster = 0\\n self.current_frequency_of_clusters = []\\n self.timestamp = []\\n self.currentstates_of_clusters = []\\n self.state_time_map = {}\\n self.cpuid_time_map = {}\\n self.cpu_freq_time_spent = {}\\n self.cpuids_of_clusters = []\\n self.parse() # Parse trace.txt generated from trace-cmd instrumentation\\n # Initialize the states of each core of clusters and frequency of\\n # each clusters with its minimum freq\\n # cpu_id is assigned for each of clusters.\\n # For IKS devices cpuid remains same in other clusters\\n # and for other it will increment by 1\\n count = 0\\n for cluster, cores_number in enumerate(self.numberofcores_in_cluster):\\n self.currentstates_of_clusters.append([-1 for dummy in range(cores_number)])\\n self.current_frequency_of_clusters.append(self.minimum_frequency_cluster[cluster])\\n if self.device.scheduler == 'iks':\\n self.cpuids_of_clusters.append([j for j in range(cores_number)])\\n else:\\n self.cpuids_of_clusters.append(range(count, count + cores_number))\\n count += cores_number\\n\\n # Initialize the time spent in each state/frequency for each core.\\n for i in range(self.device.number_of_cores * self.multiply_factor):\\n self.cpu_freq_time_spent[\\\"cpu{}\\\".format(i)] = {}\\n for j in self.unique_freq():\\n self.cpu_freq_time_spent[\\\"cpu{}\\\".format(i)][j] = 0\\n # To determine offline -1 state is added\\n offline_value = -1\\n self.cpu_freq_time_spent[\\\"cpu{}\\\".format(i)][offline_value] = 0\\n if 0 not in self.unique_freq():\\n self.cpu_freq_time_spent[\\\"cpu{}\\\".format(i)][0] = 0\",\n \"def run(self):\\n\\t\\tdf_iter = self.file_to_df(50000)\\n\\t\\tdf_airport = self.airport_file_to_df()\\n\\t\\tfor df in df_iter: # type: pd.DataFrame\\n\\t\\t\\tdf.drop_duplicates(inplace=True)\\n\\t\\t\\tdf = self.transform(df, df_airport)\\n\\n\\t\\t\\tdf_result = self.get_only_new_records(\\n\\t\\t\\t\\tdf=df,\\n\\t\\t\\t\\tdf_columns=self.join_columns,\\n\\t\\t\\t\\ttable_columns=self.join_columns\\n\\t\\t\\t)\\n\\n\\t\\t\\tif len(df_result) > 0:\\n\\t\\t\\t\\t# df_result.drop(self.table_columns, axis=1)\\n\\n\\t\\t\\t\\tself.save(\\n\\t\\t\\t\\t\\tdf=df_result,\\n\\t\\t\\t\\t\\ttable_name=\\\"travel_dimension\\\",\\n\\t\\t\\t\\t\\tdf_columns=self.table_columns,\\n\\t\\t\\t\\t\\ttable_colums=self.table_columns\\n\\t\\t\\t\\t)\",\n \"def writeRawFCD():\\n global vehId, vehIdDict\\n vehIdDict = {}\\n vehId = 0\\n day = 0\\n\\n def getVehId(orgId):\\n \\\"\\\"\\\"creates new vehicle id's which consists only numerics\\\"\\\"\\\"\\n global vehId, vehIdDict\\n value = vehIdDict.get(orgId, vehId)\\n if value is vehId:\\n vehIdDict[orgId] = vehId\\n vehId = (vehId + 1) % 65500\\n return value\\n\\n outputFile = open(path.FQrawFCD, 'w')\\n\\n for period, quota, vtypeDictR, taxiSum in generatePeriodQuotaSets():\\n day += 86400\\n # reset dict so that every taxi (even if the vehicle is chosen several\\n # times) gets its own id\\n vehIdDict = {}\\n # dataset=0\\n sortedKeys = vtypeDictR.keys()\\n sortedKeys.sort()\\n for timestep in sortedKeys:\\n taxiList = vtypeDictR[timestep]\\n for tup in taxiList: # all elements in this timestep\\n # calc timestep ->for every period /quota set a new day\\n time = timestep + day\\n time = calcTime.getDateFromDepart(time)\\n # dataset+=1\\n # print ouptut\\n # veh_id date (time to simDate+time) x (remove and\\n # set comma new)\\n outputFile.write(str(getVehId(tup[0])) + '\\\\t' + time + '\\\\t' + tup[3][0:2] + '.' + tup[3][2:7] + tup[3][8:] +\\n # y (remove and set comma new)\\n # status speed form m/s in km/h\\n '\\\\t' + tup[4][0:2] + '.' + tup[4][2:7] + tup[4][8:] + '\\\\t' + \\\"90\\\" + '\\\\t' + str(int(round(tup[2] * 3.6))) + '\\\\n')\\n # print dataset, time\\n print(vehId)\\n outputFile.close()\",\n \"def readOptimizationResultsFile(self):\\n requiredLineNo = 0\\n self.createParamters()\\n \\n self.optimizationResultsFile = open(self.fileName, 'r')\\n \\n for lineIndex, line in enumerate(self.optimizationResultsFile):\\n if lineIndex == 0:\\n startingPhase1, startingPhase2 = line.split()\\n self.startingPhase1, self.startingPhase2 = int(startingPhase1), int(startingPhase2)\\n\\n elif lineIndex == 1:\\n init1, init2, elapsedGreen1, elapsedGreen2 = line.split()\\n self.init1, self.init2 = float(init1), float(init2)\\n\\n elif lineIndex == 2:\\n self.processPhaseDuration(line, self.leftCriticalPointsRing1, self.leftCriticalPointsRing2)\\n self.processPhaseSequence()\\n\\n elif lineIndex == 3:\\n self.processPhaseDuration(line, self.leftCriticalPointsRing1, self.leftCriticalPointsRing2)\\n self.processPhaseSequence()\\n\\n elif lineIndex == 4:\\n self.processPhaseDuration(line, self.leftCriticalPointsRing1, self.leftCriticalPointsRing2)\\n self.processPhaseSequence()\\n\\n elif lineIndex == 5:\\n self.processPhaseDuration(line, self.rightCriticalPointsRing1, self.rightCriticalPointsRing2)\\n\\n elif lineIndex == 6:\\n self.processPhaseDuration(line, self.rightCriticalPointsRing1, self.rightCriticalPointsRing2)\\n\\n elif lineIndex == 7:\\n self.processPhaseDuration(line, self.rightCriticalPointsRing1, self.rightCriticalPointsRing2)\\n\\n elif lineIndex == 14:\\n noOfRequest = int(line)\\n requiredLineNo = 15 + noOfRequest\\n # break\\n \\n elif lineIndex >=15 and lineIndex < requiredLineNo:\\n self.getPriorityRequests(line)\\n \\n elif lineIndex >=15 and lineIndex >= requiredLineNo:\\n break\\n # self.optimizationResultsFile = open(self.fileName, 'r')\\n # for i, line in enumerate(self.optimizationResultsFile):\\n # if i in range(15, requiredLineNo):\\n\\n self.optimizationResultsFile.close()\\n # self.getPriorityRequests(requiredLineNo)\\n \\n self.getCummulativeValues()\\n self.generateTimePhaseDiagram()\",\n \"def run():\\n\\n import matplotlib.pyplot as plt\\n\\n anomalies_t = []\\n anomalies_v = []\\n anomalies_c = []\\n\\n all_t = []\\n all_v = []\\n\\n rows = []\\n for i, row in dataSet.iterrows():\\n\\n inputData = row.to_dict()\\n\\n detectorValues = handleRecord(inputData)\\n\\n if (detectorValues[0] > 0.65):\\n anomalies_t.append(inputData[\\\"timestamp\\\"])\\n anomalies_v.append(inputData[\\\"value\\\"])\\n anomalies_c.append(detectorValues[0])\\n\\n all_t.append(inputData[\\\"timestamp\\\"])\\n all_v.append(inputData[\\\"value\\\"])\\n\\n outputRow = list(row) + list(detectorValues)\\n\\n rows.append(outputRow)\\n\\n # Progress report\\n if (i % 1000) == 0:\\n print \\\".\\\",\\n sys.stdout.flush()\\n\\n fig, ax = plt.subplots()\\n\\n ax.plot(all_t, all_v)\\n ax.plot(anomalies_t, anomalies_v, 'ro')\\n\\n plt.show()\\n\\n ans = pandas.DataFrame(rows)\\n return ans\",\n \"def _read_trajectory_files(self):\\n dflist = []\\n self.Ntimes = {}\\n for downD in self.case.downstreamD:\\n outputs = self.case.get_outputs(self.method,downD)\\n print(outputs['trajectory_file'])\\n df = pd.read_csv(outputs['trajectory_file'],\\n header=None,\\n usecols=[0,1,2])\\n df.columns = ['t','y','z']\\n df['x'] = downD * self.case.turbine.D\\n df['z'] -= self.case.turbine.zhub\\n df = df.set_index(['t','x'])[['y','z']]\\n self.Ntimes[downD] = len(df.index.levels[0])\\n dflist.append(df)\\n self.df = pd.concat(dflist).sort_index()\",\n \"def run_analysis(self):\\n ### skip some snapshots for testing purposes\\n nskip = 199\\n read_char.skip_snapshots(self.hfile, self.ifile, nskip)\\n ### read in the first two steps (required for velocity related computations\\n xs_old, ys_old, lx_old, ly_old, tstep_old, natoms_old = read_char.read_snapshot(self.hfile, self.ifile)\\n x_old = xs_old*lx_old\\n y_old = ys_old*ly_old\\n xs,ys,lx,ly,tstep,natoms = read_char.read_snapshot(self.hfile, self.ifile)\\n x = xs*lx\\n y = ys*ly\\n ### loop over all steps of the input file\\n for step in range(nskip+1,self.nsteps-1):\\n print step\\n ### read in coordinates (as required)\\n xs_new,ys_new,lx_new,ly_new,tstep_new,natoms_new = read_char.read_snapshot(self.hfile, self.ifile)\\n x_new = xs_new*lx_new\\n y_new = ys_new*ly_new\\n ### compute further current per/atom quantities\\n phi = misc_tools.compute_orientation(x,y,lx,ly,self.npol)\\n vx,vy = misc_tools.compute_velocity(x_old,y_old, x_new, y_new, lx, ly, tstep_old, tstep_new, natoms)\\n ### start desired analysis methods\\n # density\\n if self.density_flag:\\n self.density.compute(step,x,y,lx,ly,natoms, plot = 'False')\\n # number fluctuations\\n if self.nf_flag:\\n self.numberfluctuation.compute(step,xs,ys, plot = 'False')\\n # voronoi density\\n if self.voronoi_flag:\\n self.voronoidensity.compute(step,x,y,lx,ly,natoms, plot = 'False')\\n # velocity / worticity\\n if self.velocity_flag:\\n self.velocityworticity.compute(step,x,y,vx,vy,natoms,lx,ly, plot = 'False')\\n # orientation / velocity\\n if self.orientvel_flag:\\n self.orientvel.compute(step,x,y,vx,vy,phi,natoms, plot = 'False')\\n # defect points\\n if self.pointdefects_flag:\\n self.pointdefects.compute(step,x,y,phi,lx,ly,natoms)\\n ### move coordinate arrays\\n xs_old = np.copy(xs)\\n ys_old = np.copy(ys)\\n x_old = np.copy(x)\\n y_old = np.copy(y)\\n tstep_old = tstep\\n xs = np.copy(xs_new)\\n ys = np.copy(ys_new)\\n x = np.copy(x_new)\\n y = np.copy(y_new)\\n tstep = tstep_new\\n return\",\n \"def run(self, d):\\n\\n feeds,feedidx,_ = self.getFeeds(d,'all')\\n\\n tod_shape = d[f'{self.level2}/averaged_tod'].shape\\n \\n scanedges = d[f'{self.level2}/Statistics/scan_edges'][...]\\n nfeeds = 20\\n nchannels = 8\\n \\n self.all_tod = np.zeros((20, nchannels, tod_shape[-1])) \\n self.all_weights = np.zeros((20, nchannels, tod_shape[-1])) \\n self.all_frequency = np.zeros((nchannels)) \\n self.all_auto = np.zeros((20,nchannels)) \\n self.all_mask = np.zeros((20,tod_shape[-1]))\\n self.all_cal_factors = np.zeros((20,4,64))\\n # Read in data from each feed\\n for ifeed,feed in enumerate(tqdm(feeds,desc='Looping over feeds')):\\n if feeds[ifeed] == 20:\\n continue\\n feed_tod,feed_weights,mask = self.clean_tod(d,ifeed,feed)\\n\\n if self.astro_cal:\\n feed_tod,feed_weights,cal_factors = self.calibrate_tod(d,feed_tod,feed_weights,ifeed,feed)\\n else:\\n cal_factors = 1\\n\\n self.all_tod[feed-1],self.all_weights[feed-1], self.all_auto[feed-1], self.all_frequency = self.average_tod(d,feed_tod,feed_weights,mask) \\n self.all_mask[feed-1] = mask\\n self.all_cal_factors[feed-1] = cal_factors\",\n \"def post_process(self, filename):\\n title = self.title\\n\\n outfile = open(filename, 'r')\\n data = outfile.readlines()\\n\\n name = data[0].strip()\\n mode = data[1].strip()\\n ops = data[2].strip().split(',')\\n nl = 'True' in ops[0]\\n ln = 'True' in ops[1]\\n drv = 'True' in ops[2]\\n\\n data = data[3:]\\n npt = len(data)\\n\\n t1u = np.empty((npt, ))\\n t3u = np.empty((npt, ))\\n t5u = np.empty((npt, ))\\n flag = np.empty((npt, ), dtype=np.bool)\\n x_dv = np.empty((npt, ))\\n x_state = np.empty((npt, ))\\n x_proc = np.empty((npt, ))\\n\\n for j, line in enumerate(data):\\n x_dv[j], x_state[j], x_proc[j], flag[j], t1u[j], t3u[j], t5u[j] = line.strip().split(',')\\n\\n if np.any(flag):\\n use_flag = True\\n else:\\n use_flag = False\\n\\n # Times are all normalized.\\n t1 = t1u/t1u[0]\\n t3 = t3u/t3u[0]\\n t5 = t5u/t5u[0]\\n\\n if mode == 'state':\\n x = x_state\\n xlab = \\\"Number of states.\\\"\\n elif mode == 'desvar':\\n xlab = \\\"Number of design vars.\\\"\\n x = x_dv\\n elif mode == 'proc':\\n x = x_proc\\n xlab = \\\"Number of processors.\\\"\\n\\n if use_flag:\\n\\n flagtxt = self.flagtxt\\n\\n # Split them up. We know the pattern.\\n t1F = t1[0::2]\\n t1T = t1[1::2]\\n t3F = t3[0::2]\\n t3T = t3[1::2]\\n t5F = t5[0::2]\\n t5T = t5[1::2]\\n\\n xT = x[0::2]\\n xF = x[1::2]\\n\\n # Generate plots\\n\\n if nl:\\n plt.figure(1)\\n plt.loglog(xF, t1F, 'bo-')\\n plt.loglog(xT, t1T, 'ro-')\\n\\n plt.xlabel(xlab)\\n plt.ylabel('Nonlinear Solve: Normalized Time')\\n plt.title(title)\\n plt.grid(True)\\n if self.equal_axis:\\n plt.axis('equal')\\n plt.legend(['Default', flagtxt], loc=0)\\n plt.savefig(\\\"%s_%s_%s.png\\\" % (name, mode, 'nl'))\\n\\n if ln:\\n plt.figure(2)\\n plt.loglog(xF, t3F, 'o-')\\n plt.loglog(xT, t3T, 'ro-')\\n\\n plt.xlabel(xlab)\\n plt.ylabel('Compute Totals: Normalized Time')\\n plt.title(title)\\n plt.grid(True)\\n if self.equal_axis:\\n plt.axis('equal')\\n plt.legend(['Default', flagtxt], loc=0)\\n plt.savefig(\\\"%s_%s_%s.png\\\" % (name, mode, 'ln'))\\n\\n if drv:\\n plt.figure(3)\\n plt.loglog(xF, t5F, 'o-')\\n plt.loglog(xT, t5T, 'ro-')\\n\\n plt.xlabel(xlab)\\n plt.ylabel(self.title_driver + ': Normalized Time')\\n plt.title(title)\\n plt.grid(True)\\n if self.equal_axis:\\n plt.axis('equal')\\n plt.legend(['Default', flagtxt], loc=0)\\n plt.savefig(\\\"%s_%s_%s.png\\\" % (name, mode, 'drv'))\\n\\n if self.special_plot_driver_on_linear:\\n\\n # Plot whatever driver does (e.g., coloring) on the same axis and normalization as linear time.\\n t5 = t5u/t3u[0]\\n t5F = t5[0::2]\\n t5T = t5[1::2]\\n\\n plt.figure(4)\\n plt.loglog(xF, t3F, 'o-')\\n plt.loglog(xT, t3T, 'ro-')\\n plt.loglog(xT, t5T, 'mo-')\\n\\n plt.xlabel(xlab)\\n plt.ylabel('Normalized Time')\\n plt.title(title)\\n plt.grid(True)\\n if self.equal_axis:\\n plt.axis('equal')\\n plt.legend(['Compute Totals', 'Compute Totals: ' + flagtxt, self.title_driver], loc=0)\\n plt.savefig(\\\"%s_%s_%s.png\\\" % (name, mode, 'spec1'))\\n\\n else:\\n\\n # Generate plots\\n\\n if nl:\\n plt.figure(1)\\n plt.loglog(x, t1, 'o-')\\n\\n plt.xlabel(xlab)\\n plt.ylabel('Nonlinear Solve: Normalized Time')\\n plt.title(title)\\n plt.grid(True)\\n if self.equal_axis:\\n plt.axis('equal')\\n plt.savefig(\\\"%s_%s_%s.png\\\" % (name, mode, 'nl'))\\n\\n if ln:\\n plt.figure(2)\\n plt.loglog(x, t3, 'o-')\\n\\n plt.xlabel(xlab)\\n plt.ylabel('Compute Totals: Normalized Time')\\n plt.title(title)\\n plt.grid(True)\\n if self.equal_axis:\\n plt.axis('equal')\\n plt.savefig(\\\"%s_%s_%s.png\\\" % (name, mode, 'ln'))\\n\\n # For procs, we also view the time/proc as a function of number of procs.\\n if mode == 'proc':\\n plt.figure(3)\\n plt.loglog(x, t3/x, 'o-')\\n\\n plt.xlabel(xlab)\\n plt.ylabel('Compute Totals: Normalized Time per Processor')\\n plt.title(title)\\n plt.grid(True)\\n if self.equal_axis:\\n plt.axis('equal')\\n plt.savefig(\\\"%s_%s_%s_per_proc.png\\\" % (name, mode, 'ln'))\\n\\n plt.show()\\n print('done')\",\n \"def start_new_trace(self):\\n fields = [\\\"instr\\\", \\\"rd\\\", \\\"rd_val\\\", \\\"rs1\\\", \\\"rs1_val\\\", \\\"rs2\\\", \\\"rs2_val\\\",\\n \\\"imm\\\", \\\"str\\\", \\\"addr\\\", \\\"binary\\\", \\\"csr\\\", \\\"mode\\\"]\\n self.csv_writer = csv.DictWriter(self.csv_fd, fieldnames=fields)\\n self.csv_writer.writeheader()\",\n \"def process_file(self):\\n self._processing_logger.log_info('Start processing')\\n self.parsing_start_time = datetime.datetime.now()\\n if os.path.exists(self.tmp_stat_file_path) \\\\\\n and not HcsParsingUtils.active_processing_exceed_timeout(self.tmp_stat_file_path):\\n self._processing_logger.log_info('This file is processed by another parser, skipping...')\\n return 2\\n self.create_tmp_stat_file()\\n hcs_index_file_path = self.hcs_root_dir + MEASUREMENT_INDEX_FILE_PATH\\n time_series_details = self._extract_time_series_details(hcs_index_file_path)\\n self.generate_ome_xml_info_file()\\n xml_info_tree = ET.parse(self.ome_xml_info_file_path).getroot()\\n plate_width, plate_height = self._get_plate_configuration(xml_info_tree)\\n wells_tags = self.read_wells_tags()\\n if wells_tags:\\n self._processing_logger.log_info(\\\"Tags \\\" + str(wells_tags))\\n if not TAGS_PROCESSING_ONLY and not EVAL_PROCESSING_ONLY:\\n if not self._localize_related_files():\\n self._processing_logger.log_info('Some errors occurred during copying files from the bucket, exiting...')\\n return 1\\n else:\\n self._processing_logger.log_info('Localization is finished.')\\n local_preview_dir = os.path.join(self.tmp_local_dir, 'preview')\\n hcs_local_index_file_path = get_path_without_trailing_delimiter(self.tmp_local_dir) \\\\\\n + MEASUREMENT_INDEX_FILE_PATH\\n for sequence_id, timepoints in time_series_details.items():\\n self._processing_logger.log_info('Processing sequence with id={}'.format(sequence_id))\\n sequence_index_file_path = self.extract_sequence_data(sequence_id, hcs_local_index_file_path)\\n conversion_result = os.system('bash \\\"{}\\\" \\\"{}\\\" \\\"{}\\\" {}'.format(\\n OME_TIFF_SEQUENCE_CREATION_SCRIPT, sequence_index_file_path, local_preview_dir, sequence_id))\\n if conversion_result != 0:\\n self._processing_logger.log_info('File processing was not successful...')\\n return 1\\n sequence_overview_index_file_path, wells_grid_mapping = self.build_sequence_overview_index(sequence_index_file_path)\\n conversion_result = os.system('bash \\\"{}\\\" \\\"{}\\\" \\\"{}\\\" {} \\\"{}\\\"'.format(\\n OME_TIFF_SEQUENCE_CREATION_SCRIPT, sequence_overview_index_file_path, local_preview_dir,\\n sequence_id, 'overview_data.ome.tiff'))\\n if conversion_result != 0:\\n self._processing_logger.log_info('File processing was not successful: well preview generation failure')\\n return 1\\n self.write_dict_to_file(os.path.join(local_preview_dir, sequence_id, 'wells_map.json'),\\n self.build_wells_map(sequence_id, wells_grid_mapping, wells_tags))\\n if LOCALIZE_USE_PIPE == \\\"true\\\":\\n cloud_transfer_result = os.system('pipe storage cp -f -r \\\"{}\\\" \\\"{}\\\"'\\n .format(local_preview_dir,\\n HcsParsingUtils.extract_cloud_path(self.hcs_img_service_dir)))\\n else:\\n cloud_transfer_result = os.system('aws s3 sync \\\"{}\\\" \\\"{}\\\"'\\n .format(local_preview_dir,\\n HcsParsingUtils.extract_cloud_path(self.hcs_img_service_dir)))\\n if cloud_transfer_result != 0:\\n self._processing_logger.log_info('Results transfer was not successful...')\\n return 1\\n self._write_hcs_file(time_series_details, plate_width, plate_height)\\n if not EVAL_PROCESSING_ONLY:\\n tags_processing_result = self.try_process_tags(xml_info_tree, wells_tags)\\n if TAGS_PROCESSING_ONLY:\\n if wells_tags:\\n for sequence_id, timepoints in time_series_details.items():\\n path = os.path.join(self.hcs_img_service_dir, sequence_id, 'wells_map.json')\\n self.write_dict_to_file(path, self.update_wells_json(path, wells_tags))\\n return tags_processing_result\\n if not TAGS_PROCESSING_ONLY:\\n eval_processing_result = self.try_process_eval()\\n if EVAL_PROCESSING_ONLY:\\n return eval_processing_result\\n self.create_stat_file()\\n return 0\",\n \"def read_tracers(datadir = 'data/', fileName = 'tracers.dat', zlim = [], head_size = 3, post = False):\\n \\n class data_struct:\\n def __init__(self):\\n self.xi = []\\n self.yi = []\\n self.xf = []\\n self.yf = []\\n self.zf = []\\n self.l = []\\n self.q = []\\n\\n data = []\\n data = data_struct()\\n\\n # compute the offset in order to skip Fortran's header byte\\n if (post):\\n head_size = 0\\n off = 2\\n if (head_size == 3):\\n off = 2\\n if (head_size == 5):\\n off = 3\\n\\n # read the cpu structure\\n dim = pc.read_dim(datadir = datadir)\\n if (dim.nprocz > 1):\\n print(\\\": number of cores in z-direction > 1\\\")\\n return -1\\n\\n # read the parameters\\n params = pc.read_param(datadir = datadir, quiet = True)\\n\\n # read the grid\\n grid = pc.read_grid(datadir = datadir, quiet = True)\\n\\n # determine the file structure\\n if (post):\\n n_proc = 1\\n tracer_file = open(datadir+fileName, 'rb')\\n trace_sub = struct.unpack(\\\"f\\\", tracer_file.read(4))[0]\\n tracer_file.close()\\n n_times = int((os.path.getsize(datadir+fileName)-4)/(4*7*int(dim.nx*trace_sub)*int(dim.ny*trace_sub)))\\n # sub sampling of the tracers\\n if (not(post)):\\n n_proc = dim.nprocx*dim.nprocy\\n trace_sub = params.trace_sub\\n n_times = int(os.path.getsize(datadir+'proc0/'+fileName)/(4*(head_size + 7*np.floor(dim.nx*trace_sub)*np.floor(dim.ny*trace_sub)/dim.nprocx/dim.nprocy)))\\n\\n # prepare the output arrays\\n tracers = np.zeros((int(dim.nx*trace_sub), int(dim.ny*trace_sub), n_times, 7))\\n mapping = np.zeros((int(dim.nx*trace_sub), int(dim.ny*trace_sub), n_times, 3))\\n\\n # temporary arrays for one core\\n if (post):\\n tracers_core = tracers\\n mapping_core = mapping\\n else:\\n tracers_core = np.zeros((int(int(dim.nx*trace_sub)/dim.nprocx), int(int(dim.ny*trace_sub)/dim.nprocy), n_times, 7))\\n mapping_core = np.zeros((int(int(dim.nx*trace_sub)/dim.nprocx), int(np.floor(dim.ny*trace_sub)/dim.nprocy), n_times, 3))\\n\\n # set the upper z-limit to the domain boundary\\n if zlim == []:\\n zlim = grid.z[-dim.nghostz-1]\\n\\n # read the data from all cores\\n for i in range(n_proc):\\n # read the cpu structure\\n if (post):\\n dim_core = pc.read_dim(datadir = datadir, proc = -1)\\n dim_core.ipx = 0\\n dim_core.ipy = 0\\n else:\\n dim_core = pc.read_dim(datadir = datadir, proc = i)\\n stride = int(dim_core.nx*trace_sub)*int(dim_core.ny*trace_sub)\\n llen = head_size + 7*stride + post\\n\\n if (post):\\n tracer_file = open(datadir+fileName, 'rb')\\n else:\\n tracer_file = open(datadir+'proc{0}/'.format(i)+fileName, 'rb')\\n tmp = array.array('f')\\n tmp.read(tracer_file, int((head_size + post + 7*int(dim_core.nx*trace_sub)*int(dim_core.ny*trace_sub))*n_times)+post)\\n tracer_file.close()\\n\\n t = []\\n\\n for j in range(n_times):\\n t.append(tmp[off-1+j*llen])\\n data.xi = tmp[off+j*llen : off+1*stride+j*llen]\\n data.yi = tmp[off+1*stride+j*llen : off+2*stride+j*llen]\\n data.xf = tmp[off+2*stride+j*llen : off+3*stride+j*llen]\\n data.yf = tmp[off+3*stride+j*llen : off+4*stride+j*llen]\\n data.zf = tmp[off+4*stride+j*llen : off+5*stride+j*llen]\\n data.l = tmp[off+5*stride+j*llen : off+6*stride+j*llen]\\n data.q = tmp[off+6*stride+j*llen : off+7*stride+j*llen]\\n\\n # Squeeze the data into 2d array. This make the visualization much faster.\\n for l in range(len(data.xi)):\\n tracers_core[l%(int(dim_core.nx*trace_sub)),int(l/(int(dim_core.nx*trace_sub))),j,:] = \\\\\\n [data.xi[l], data.yi[l], data.xf[l], data.yf[l], data.zf[l], data.l[l], data.q[l]]\\n if data.zf[l] >= zlim:\\n if (data.xi[l] - data.xf[l]) > 0:\\n if (data.yi[l] - data.yf[l]) > 0:\\n mapping_core[l%(int(dim_core.nx*trace_sub)),int(l/(int(dim_core.nx*trace_sub))),j,:] = [0,1,0]\\n else:\\n mapping_core[l%(int(dim_core.nx*trace_sub)),int(l/(int(dim_core.nx*trace_sub))),j,:] = [1,1,0]\\n else:\\n if (data.yi[l] - data.yf[l]) > 0:\\n mapping_core[l%(int(dim_core.nx*trace_sub)),int(l/(int(dim_core.nx*trace_sub))),j,:] = [0,0,1]\\n else:\\n mapping_core[l%(int(dim_core.nx*trace_sub)),int(l/(int(dim_core.nx*trace_sub))),j,:] = [1,0,0]\\n else:\\n mapping_core[l%(int(dim_core.nx*trace_sub)),int(l/(int(dim_core.nx*trace_sub))),j,:] = [1,1,1]\\n\\n # copy single core data into total data arrays\\n if (not(post)):\\n tracers[np.round(dim_core.ipx*int(dim_core.nx*trace_sub)):np.round((dim_core.ipx+1)*np.floor(dim_core.nx*trace_sub)), \\\\\\n np.round(dim_core.ipy*int(dim_core.ny*trace_sub)):np.round((dim_core.ipy+1)*np.floor(dim_core.ny*trace_sub)),j,:] = \\\\\\n tracers_core[:,:,j,:]\\n mapping[np.round(dim_core.ipx*int(dim_core.nx*trace_sub)):np.round((dim_core.ipx+1)*np.floor(dim_core.nx*trace_sub)), \\\\\\n np.round(dim_core.ipy*int(dim_core.ny*trace_sub)):np.round((dim_core.ipy+1)*np.floor(dim_core.ny*trace_sub)),j,:] = \\\\\\n mapping_core[:,:,j,:]\\n\\n # swap axes for post evaluation\\n tracers = tracers.swapaxes(0, 1)\\n mapping = mapping.swapaxes(0, 1)\\n\\n return tracers, mapping, t\",\n \"def createOutput():\\n\\n firstPeriod = True\\n # get edge No\\n edgesNo = 0\\n edgesSet = set()\\n for timestep, taxiList in vtypeDict.iteritems():\\n for tup in taxiList:\\n edgesSet.add(tup[1])\\n edgesNo = len(edgesSet)\\n\\n outputFile = open(path.FQoutput, 'w')\\n outputFile.write('<?xml version=\\\"1.0\\\"?>\\\\n')\\n outputFile.write('<paramEffects aggregationInterval=\\\"%d\\\" vehicles=\\\"%d\\\" edges=\\\"%d\\\">\\\\n' % (\\n aggInterval, vehSum, edgesNo))\\n for period, quota, vtypeDictR, taxiSum in generatePeriodQuotaSets(True):\\n if quota is None:\\n if not firstPeriod:\\n outputFile.write(\\\"\\\\t</periods>\\\\n\\\")\\n else:\\n firstPeriod = False\\n outputFile.write('\\\\t<periods period=\\\"%d\\\">\\\\n' % (period))\\n else:\\n simpleTaxiMeanVList = [0, 1]\\n simpleEdgeMeanVList = [0, 1]\\n drivenEdgesSet = set()\\n\\n if len(vtypeDictR) == 0: # if the processed FCD returns no Values\\n print(\\\"noData p\\\", period, \\\" q\\\", quota)\\n drivenEdgesSet.add(0)\\n else: # create mean from all taxi speed values\\n for timestep, taxiList in vtypeDictR.iteritems():\\n for tup in taxiList: # all elements in this timestep\\n simpleTaxiMeanVList[0] += tup[2]\\n simpleTaxiMeanVList[1] += 1\\n drivenEdgesSet.add(tup[1])\\n # create mean from all edge speed values which are driven by the\\n # chosen taxis\\n drivenEdgesList = list(drivenEdgesSet)\\n drivenEdgesList.sort()\\n # print \\\"dataSets \\\",simpleTaxiMeanVList[1]\\n\\n # --edgeDump-- #\\n \\\"\\\"\\\"\\n for i in edgeDumpDict.keys(): #all intervals\\n for edge,v in edgeDumpDict[i]:\\n if BinarySearch.isElmInList(drivenEdgesList,edge):\\n simpleEdgeMeanVList[0]+=v\\n simpleEdgeMeanVList[1]+=1\\n \\\"\\\"\\\"\\n # --vtype-- #\\n\\n for timestep, taxiList in vtypeDict.iteritems():\\n for tup in taxiList:\\n if BinarySearch.isElmInList(drivenEdgesList, tup[1]):\\n simpleEdgeMeanVList[0] += tup[2]\\n simpleEdgeMeanVList[1] += 1\\n\\n # calc values for output\\n detectedEdges = len(drivenEdgesSet)\\n relDetectedEdges = detectedEdges * 100.0 / edgesNo\\n vSim = simpleEdgeMeanVList[0] / simpleEdgeMeanVList[1]\\n vSimFCD = simpleTaxiMeanVList[0] / simpleTaxiMeanVList[1]\\n vAbsDiff = vSimFCD - vSim\\n if vSim != 0:\\n vRelDiff = vAbsDiff / vSim * 100\\n else:\\n vRelDiff = 100\\n if vRelDiff < -40:\\n vRelDiff = -35\\n\\n outputFile.write('\\\\t\\\\t<values taxiQuota=\\\"%f\\\" taxis=\\\"%d\\\" simMeanSpeed=\\\"%f\\\" simFcdMeanSpeed=\\\"%f\\\" ' % (\\n quota, taxiSum, vSim, vSimFCD,))\\n outputFile.write('detectedEdges=\\\"%d\\\" notDetectedEdges=\\\"%d\\\" ' % (\\n detectedEdges, edgesNo - detectedEdges))\\n outputFile.write('absSpeedDiff=\\\"%f\\\" relSpeedDiff=\\\"%f\\\" relDetectedEdges=\\\"%f\\\" relNotDetectedEdges=\\\"%f\\\"/>\\\\n' %\\n (vAbsDiff, vRelDiff, relDetectedEdges, 100 - relDetectedEdges))\\n outputFile.write(\\\"\\\\t</periods>\\\\n</paramEffects>\\\")\\n outputFile.close()\",\n \"def process_csv(self):\\n with open(self.filepath, mode=\\\"r\\\") as csv_file:\\n csv_reader = csv.reader(csv_file, delimiter=\\\",\\\")\\n header = next(csv_reader)\\n\\n date_idx = self._get_header_position(header, \\\"Label\\\")\\n power_idx = self._get_header_position(header, \\\"kW\\\")\\n\\n if self.inverter_id not in header[power_idx]:\\n raise Exception(\\\"Inverter data returned for the incorrect meter.\\\")\\n\\n for row in csv_reader:\\n date_obj = self.csv_str_to_date(row[date_idx])\\n power = float(row[power_idx] or 0)\\n\\n current_date = self.date_to_final_str(date_obj)\\n rounded_time = self.round_up_to_quarter_hour(date_obj)\\n\\n if current_date not in self.intermediate_readings:\\n self.intermediate_readings[\\n current_date\\n ] = self.build_intermediate_dict()\\n\\n current_reading = self.intermediate_readings[current_date][rounded_time]\\n # Here's where we sum power readings together - in to fifteen min intervals\\n self.intermediate_readings[current_date][rounded_time] = (\\n current_reading + power\\n )\\n\\n actual_time = self.date_to_intermediate_time_str(date_obj)\\n if rounded_time == actual_time:\\n # Here's where we average power readings together, in fifteen minute intervals\\n self.intermediate_readings[current_date][rounded_time] = round(\\n float(\\n self.intermediate_readings[current_date][rounded_time] / 3\\n ),\\n 2,\\n )\\n\\n return self.finalize_readings()\",\n \"def ddf_parser():\\n num_available, total = 0, 0\\n indicator_twn_tuples = list() # format of a single tuple: (indicator_name, #twn rows, earliest available year)\\n concept_metadata = dict() # {top_tag: second_layer_tag:\\n\\n # parse all ddf files provided by GapMinder and find how many of them with Taiwan statistics\\n for f_path in glob.glob(os.path.join('statistics', '*datapoints*.csv')):\\n total += 1\\n df = pd.read_csv(f_path)\\n if 'twn' in df.geo.unique():\\n num_available += 1\\n indicator = f_path.replace('statistics/ddf--datapoints--', '').replace('--by--geo--time.csv', '')\\n # print('[Indicator]', indicator)\\n print(f\\\"\\\\t{len(df[df.geo == 'twn'])} indicators including Taiwan statistics.\\\")\\n\\n # stat_name = df.columns[-1]\\n # df_p = df.pivot(index='geo', columns='time')[stat_name]\\n # df_p.insert(loc=0, column='indicator', value=stat_name)\\n # df_p.to_csv(f'statistics_transformed/{stat_name}.csv', sep=';')\\n\\n indicators.append(indicator)\\n\\n\\n # print(\\\"{:.1f}% datapoints have Taiwan statistics\\\".format(num_available / float(total) * 100))\\n\\n\\n\\n df_c = pd.read_csv(CONCEPT_CSV_PATH)\\n df_t = pd.read_csv(TAG_CSV_PATH)\\n df = pd.merge(df_c, df_t, how='left', left_on='tags', right_on='tag')\\n for idr, num_rows, earliest_year in indicator_twn_tuples:\\n ancestors = list()\\n\\n row_values = df[df['concept'] == idr].values[0]\\n name_catalog, parent, ancestor = (row_values[i] for i in [9, 17, 18])\\n if type(parent) is str:\\n ancestors.append(parent)\\n\\n # get ancestors recursively\\n while type(ancestor) is str:\\n tag_row_values = df_t[df_t['tag'] == ancestor].values[0]\\n ancestors.append(tag_row_values[1])\\n ancestor = tag_row_values[2]\\n\\n # build concept structure\\n ancestors.insert(0, name_catalog)\\n print('/'.join(ancestors[::-1]))\",\n \"def _read_traces(self, unpack_headers=False, headonly=False,\\n yield_each_trace=False):\\n self.traces = []\\n # Big loop to read all data traces.\\n while True:\\n # Read and as soon as the trace header is too small abort.\\n try:\\n # Always unpack with IEEE\\n trace = SEGYTrace(self.file, 5, self.endian,\\n unpack_headers=unpack_headers,\\n headonly=headonly)\\n if yield_each_trace:\\n yield trace\\n else:\\n self.traces.append(trace)\\n except SEGYTraceHeaderTooSmallError:\\n break\",\n \"def parse_results(results_file, measure_text):\\r\\n \\r\\n #Read in results file\\r\\n with open(results_file) as f_in:\\r\\n results_text = f_in.readlines()\\r\\n \\r\\n #Set-up output data frame\\r\\n results_df = pd.DataFrame(columns=('effect', 'time_window', 'electrodes'))\\r\\n \\r\\n r = -1 #data frame row index\\r\\n \\r\\n #Parse lines and read relevant results into data frame\\r\\n for i in range(len(results_text)):\\r\\n \\r\\n line = results_text[i]\\r\\n \\r\\n #Starting to parse a new simulation\\r\\n if 'SIMULATION SUMMARY' in line:\\r\\n r += 1\\r\\n \\r\\n #Parse basic simulation parameters\\r\\n elif 'Simulated experiments' in line:\\r\\n (field, value) = line.split('\\\\t')\\r\\n results_df.loc[r, 'n_experiments'] = int(value)\\r\\n \\r\\n elif 'Permutations' in line:\\r\\n (field, value) = line.split('\\\\t')\\r\\n results_df.loc[r, 'n_permutations'] = int(value)\\r\\n \\r\\n elif 'Sample size' in line:\\r\\n (field, value) = line.split('\\\\t')\\r\\n results_df.loc[r, 'n_subjects'] = int(value)\\r\\n \\r\\n elif 'Effect:' in line:\\r\\n (field, value) = line.split('\\\\t')\\r\\n results_df.loc[r, 'effect'] = os.path.basename(value).strip()\\r\\n \\r\\n elif 'Time window' in line:\\r\\n (field, value) = line.split('\\\\t')\\r\\n results_df.loc[r, 'time_window'] = value.strip()\\r\\n \\r\\n elif 'Electrodes:' in line:\\r\\n (field, value) = line.split('\\\\t')\\r\\n results_df.loc[r, 'electrodes'] = value.strip()\\r\\n \\r\\n elif 'Trials =' in line:\\r\\n (field, value) = line.split('\\\\t')\\r\\n results_df.loc[r, 'n_trials'] = int(value.split()[0])\\r\\n \\r\\n elif 'MEAN WINDOW' in line:\\r\\n (field, value) = results_text[i+1].split('\\\\t')\\r\\n results_df.loc[r, 'mean_amp'] = float(value)\\r\\n \\r\\n #Find correction method for current point in file\\r\\n elif 'UNCORRECTED' in line:\\r\\n method = 'uncorrected'\\r\\n elif 'SIDAK' in line:\\r\\n method = 'sidak'\\r\\n elif 'FMAX' in line:\\r\\n method = 'Fmax'\\r\\n elif 'CLUSTER 0.05' in line:\\r\\n method = 'cluster_05'\\r\\n elif 'CLUSTER 0.01' in line:\\r\\n method = 'cluster_01'\\r\\n elif 'BH' in line:\\r\\n method = 'BH'\\r\\n elif 'BY' in line:\\r\\n method = 'BY'\\r\\n elif 'BKY' in line:\\r\\n method = 'BKY'\\r\\n \\r\\n #Get the measure of interst and associate with method (from above)\\r\\n elif measure_text in line:\\r\\n (field, value) = line.split('\\\\t')\\r\\n results_df.loc[r, method] = float(value)\\r\\n \\r\\n return results_df\",\n \"def collect_data(self):\\n categories = []\\n list_of_feature_lists = []\\n feature_sets = set()\\n with open(self.csv_path, \\\"r\\\") as f:\\n reader = csv.DictReader(f)\\n # collecting some stats for FDR calculation:\\n self.PSM_count = 0\\n self.decoy_count = 0\\n\\n if self[\\\"dump_svm_matrix\\\"]:\\n self.init_svm_matrix_dump()\\n additional_matrix_info = []\\n\\n for i, row in enumerate(\\n sorted(\\n reader,\\n reverse=self[\\\"bigger_scores_better\\\"],\\n key=lambda d: float(d[self.col_for_sorting]),\\n )\\n ):\\n\\n features = self.row_to_features(row)\\n\\n if tuple(features) in feature_sets:\\n continue\\n feature_sets.add(tuple(features))\\n\\n category, psm_FDR = self.get_psm_category(row)\\n\\n list_of_feature_lists.append(features)\\n categories.append(category)\\n\\n if self[\\\"dump_svm_matrix\\\"]:\\n label = -1 if row_is_decoy(row) else 1\\n sequence = \\\"{0}.{1}#{2}.{3}\\\".format(\\n row[\\\"Sequence Pre AA\\\"].strip(),\\n row[\\\"Sequence\\\"].strip(),\\n row[\\\"Modifications\\\"].strip(),\\n row[\\\"Sequence Post AA\\\"].strip(),\\n )\\n additional_matrix_info.append(\\n {\\n \\\"psm_id\\\": row[\\\"Spectrum Title\\\"].strip(),\\n \\\"label\\\": label,\\n \\\"scannr\\\": row[\\\"Spectrum Title\\\"].strip().split(\\\".\\\")[-2],\\n \\\"peptide\\\": sequence,\\n \\\"proteins\\\": self.parse_protein_ids(row[\\\"Protein ID\\\"]),\\n }\\n )\\n\\n if i % 1000 == 0:\\n score_val = float(row[self.col_for_sorting])\\n msg = (\\n \\\"Generating feature matrix from input csv \\\"\\n \\\"(line ~{0}) with score {1} and FDR \\\"\\n \\\"{2}\\\".format(i, score_val, psm_FDR)\\n )\\n print(msg, end=\\\"\\\\r\\\")\\n\\n # All data points are collected in one big matrix, to make standardization possible\\n print(\\\"\\\\nConverting feature matrix to NumPy array...\\\")\\n X_raw = np.array(list_of_feature_lists, dtype=float)\\n\\n print(\\\"Replacing empty/NaN values with the mean of each column...\\\")\\n self.nan_replacer = Imputer()\\n self.nan_replacer.fit(X_raw)\\n X_raw = self.nan_replacer.transform(X_raw)\\n # Standardize input matrix to ease machine learning! Scaled data has zero mean and unit variance\\n print(\\\"Standardizing input matrix...\\\")\\n self.scaler = SCALER.fit(X_raw)\\n self.X = self.scaler.transform(X_raw)\\n self.categories = np.array(categories)\\n print()\\n\\n if self[\\\"dump_svm_matrix\\\"]:\\n print(\\\"Dumping SVM matrix to\\\", self[\\\"dump_svm_matrix\\\"])\\n\\n for i, matrix_row in enumerate(self.X):\\n matrix_row_info = additional_matrix_info[i]\\n self.dump_svm_matrix_row(\\n row=list(matrix_row),\\n psm_id=matrix_row_info[\\\"psm_id\\\"],\\n label=matrix_row_info[\\\"label\\\"],\\n scannr=matrix_row_info[\\\"scannr\\\"],\\n peptide=matrix_row_info[\\\"peptide\\\"],\\n proteins=matrix_row_info[\\\"proteins\\\"],\\n )\\n\\n print(\\\"Dumped SVM matrix to\\\", self[\\\"dump_svm_matrix\\\"])\\n return\",\n \"def preproc_data(base_dir):\\n n_users = 182\\n user_datas = []\\n\\n for user in tqdm(range(n_users)): \\n #iterate through each trace of user \\n user_traces = []\\n if (len(str(user)) == 1): \\n user_id = '00' + str(user)\\n elif (len(str(user)) == 2): \\n user_id = '0' + str(user)\\n else: \\n user_id = str(user)\\n dir_name = base_dir + user_id + '/Trajectory/'\\n for filename in os.listdir(dir_name): \\n #load trajectory\\n trajectory_raw = pd.read_csv(\\n dir_name + filename,\\n delimiter = ',', header = None, skiprows = 6,\\n names = ['lat','lon', '0', 'altitude', 't_1899', 'date', 'time' ])\\n\\n #modify time\\n traj = trajectory_raw.copy()\\n traj.drop(columns = '0', inplace = True)\\n\\n traj['t_1899'] = (trajectory_raw['t_1899'] - trajectory_raw['t_1899'].values[0]) * 24 * 60 * 60\\n traj_newcols = np.array(traj.columns)\\n traj_newcols[traj_newcols == 't_1899'] = 'seconds'\\n traj.columns = traj_newcols\\n\\n #get X_vals: \\n R_earth = 6.371e6\\n deg_to_rad = np.pi / 180\\n traj['X'] = R_earth * np.cos(deg_to_rad * traj['lat'].values) * np.cos(deg_to_rad * traj['lon'].values)\\n traj['Y'] = R_earth * np.cos(deg_to_rad * traj['lat'].values) * np.sin(deg_to_rad * traj['lon'].values)\\n\\n #Normalize to first point: \\n origin_x = traj['X'].values[0]\\n origin_y = traj['Y'].values[0]\\n\\n traj['X'] = traj['X'] - origin_x\\n traj['Y'] = traj['Y'] - origin_y\\n\\n txy = traj.copy()\\n txy = traj[['seconds', 'X', 'Y']]\\n txy.columns = ['T', 'X', 'Y']\\n if not np.isnan(txy.values).any(): \\n user_traces.append(txy.values)\\n\\n user_datas.append(user_traces)\\n return user_datas\",\n \"def prepareAccumulatedMetrics(self):\\n displayDF = analyzeMetricsDF(self.resultList)\\n displayDF.to_csv(\\\"data/results.csv\\\")\",\n \"def process(self):\\n parser = csv.reader(self.reader,delimiter=self.delimiter_DIC[self.delim])\\n firstRec = True\\n for fields in parser:\\n if firstRec:\\n fieldNames = fields\\n firstRec = False\\n else:\\n self.dicts.append({})\\n for i,f in enumerate(fields):\\n try:\\n self.dicts[-1][fieldNames[i]] = f\\n except:\\n import pdb\\n pdb.set_trace()\\n if self.eng is \\\"spectrumMill\\\":\\n for i,row in enumerate(self.dicts):\\n fileSM = row[self.engine[self.eng][0]]\\n acNoSM = row[self.engine[self.eng][1]]\\n masSM=row[self.engine[self.eng][2]]\\n chrgeSM=row[self.engine[self.eng][3]]\\n preAmSM=row[self.engine[self.eng][4]].replace('(','').replace(')','')\\n pepSM=row[self.engine[self.eng][5]]\\n nAmSM=row[self.engine[self.eng][6]].replace('(','').replace(')','')\\n modSM=row[self.engine[self.eng][7]].split('\\\\s')+row[self.engine[self.eng][8]].split('\\\\s')\\n modLis = [mod.strip() for mod in modSM if mod!=' ']\\n modSM = ';'.join(modLis)\\n scoreSM=row[self.engine[self.eng][9]]\\n descrimentSM=row[self.engine[self.eng][10]]\\n if modSM !='':\\n modPepInHupaFormat=self.modTermDic.spectrumMill(preAmSM,pepSM,nAmSM,modSM,self.eng)\\n parsedData=acNoSM+'\\\\t'+masSM+'\\\\t'+chrgeSM+'\\\\t'+modPepInHupaFormat+'\\\\t'+scoreSM+'\\\\n'\\n data = self.mapCaller(parsedData,self.eng)\\n #print >>self.writer,data\\n else:\\n parsedData=acNoSM+'\\\\t'+masSM+'\\\\t'+chrgeSM+'\\\\t'+preAmSM+'.'+pepSM+'.'+nAmSM+'\\\\t'+'-'+'\\\\t'+scoreSM+'\\\\n'\\n data = self.mapCaller(parsedData,self.eng)\\n #print >>self.writer,data\\n\\n if self.eng is \\\"mascot\\\":\\n \\\"\\\"\\\"\\n In Mascot, under every gi (protein) corresponding peptide information will be there\\n \\\"\\\"\\\"\\n giFound=True\\n for i,row in enumerate(self.dicts):\\n if row[self.engine[self.eng][0]]!='':\\n giAsKey = row[self.engine[self.eng][0]]\\n giFound=False\\n if giFound==False:\\n massM=row[self.engine[self.eng][1]]\\n chargeM=row[self.engine[self.eng][2]]\\n preAmM=row[self.engine[self.eng][3]]\\n pepM=row[self.engine[self.eng][4]]\\n nAmM = row[self.engine[self.eng][5]]\\n modM=row[self.engine[self.eng][6]]\\n modSiteM=row[self.engine[self.eng][7]]\\n scoreM=row[self.engine[self.eng][8]]\\n evalM=row[self.engine[self.eng][9]]\\n if modM !='':\\n \\\"\\\"\\\"\\n modificationFormat from modification.py creates a MASTER_UNIMOD dictionary \\n Where all modifications of unimod would be available. \\n At same time formatMod function in modificationFormat class would convert modification format \\\"\\\"\\\"\\n modPepInHupaFormat=self.modTermDic.mascot(preAmM,pepM,nAmM,modSiteM,modM,self.eng)\\n parsedData=giAsKey+'\\\\t'+massM+'\\\\t'+chargeM+'\\\\t'+modPepInHupaFormat+'\\\\t'+scoreM+'\\\\n'\\n data=self.mapCaller(parsedData,self.eng)\\n #print >>self.writer,data\\n else:\\n \\n parsedData=giAsKey+'\\\\t'+massM+'\\\\t'+chargeM+'\\\\t'+preAmM+'.'+pepM+'.'+nAmM+'\\\\t'+'-'+'\\\\t'+scoreM+'\\\\n'\\n data=self.mapCaller(parsedData,self.eng)\\n #print >>self.writer,data\\n\\n if self.eng is \\\"inspect\\\":\\n \\\"\\\"\\\"\\n InSpect does not have mass information in TSV file\\n So we need to fetch it from spectrum file (this is not yet done)\\n \\\"\\\"\\\"\\n for i,row in enumerate(self.dicts):\\n data = row[self.engine[self.eng][0]]+'\\\\t'+row[self.engine[self.eng][1]]+'\\\\t'+row[self.engine[self.eng][2]]+'\\\\t'+row[self.engine[self.eng][3]]+'\\\\t'+row[self.engine[self.eng][4]]+'\\\\t'+row[self.engine[self.eng][5]]+'\\\\n'\\n #return data\\n #data = self.mapCaller(data)\\n #self.writer.write(data)\\n\\n if self.eng is \\\"omssa\\\":\\n #OMSSA csv doesnot contain start and last residue of the peptide, instead contains position. So start and last residue need to fetch from protein sequence\\n for i,row in enumerate(self.dicts):\\n giO = row[self.engine[self.eng][6]]\\n massO= row[self.engine[self.eng][5]]\\n chargeO=row[self.engine[self.eng][8]]\\n preAmO = row[self.engine[self.eng][1]]#position in protein\\n pepO = row[self.engine[self.eng][2]]\\n nextAmO = row[self.engine[self.eng][3]] #position in protein\\n scoreO= row[self.engine[self.eng][4]]\\n modO=row[self.engine[self.eng][7]]\\n if modO !='':\\n #parsedData=giO+'#'+massO+'#'+chargeO+'#'+preAmO+'.'+pepO+'.'+nextAmO+'#'+modO+'#'+scoreO\\n modPepInHupaFormat=self.modTermDic.omssa(preAmO,pepO,nextAmO,modO,self.eng)\\n parsedData=giO+'\\\\t'+massO+'\\\\t'+chargeO+'\\\\t'+modPepInHupaFormat+'\\\\t'+scoreO+'\\\\n'\\n self.mapCaller(parsedData,self.eng)\\n else:\\n parsedData=giO+'\\\\t'+massO+'\\\\t'+chargeO+'\\\\t'+preAmO+'.'+pepO+'.'+nextAmO+'\\\\t'+'-'+'\\\\t'+scoreO+'\\\\n'\\n self.mapCaller(parsedData,self.eng)\",\n \"def _calc_stats(self):\\n\\n for res in self.rsts:\\n _LOG.info(\\\"Calculate statistics for '%s'\\\", res.reportid)\\n res.calc_stats(regexs=self._stats_colnames, funcnames=self._stats_funcs)\",\n \"def process_stat_files(param):\\n\\n #get the files that are actually in the output directory\\n call = ['cp', '-R']\\n call.append(param['working_dir']+'results/featureCount/')\\n call.append(param['working_dir']+'report/')\\n _, _ = subprocess.Popen(call,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE).communicate()\\n\\n featurecount_file = (param['working_dir']+\\n 'results/featureCount/featureCount_stats.txt')\\n #extract table\\n table = []\\n filehandle = open(featurecount_file)\\n #header\\n table.append(filehandle.readlines()[0].rstrip().split('\\\\t'))\\n table[0] = table[0][1:]\\n filehandle.close()\\n\\n #total number of aligned reads\\n tot_reads = param['bam_qc']['unique_aligned_reads']\\n counter = [0] * len(param['bam_qc']['unique_aligned_reads'])\\n \\n filehandle = open(featurecount_file)\\n for line in filehandle.readlines()[1:]:\\n cur_line = line.rstrip().split('\\\\t')\\n cur_line[0] = re.sub(r'_',' ',cur_line[0])\\n if cur_line[0] not in ['Unassigned MultiMapping','Assigned']:\\n counter = [ct + int(cr) for ct, cr in zip(counter, cur_line[1:])]\\n perc = ([cur_line[0]]+\\n MODULE_HELPER.get_percentage(cur_line[1:],\\n tot_reads,\\n len(cur_line)-1))\\n table.append(perc)\\n filehandle.close()\\n assigned = [tot_reads[idx] - counter[idx] for idx in range(len(tot_reads))]\\n perc = ['Assigned'] + MODULE_HELPER.get_percentage(assigned,\\n tot_reads,\\n len(counter))\\n return table\",\n \"def freqchk_method():\\n y = 0\\n csvfile = open('KIE_Output.csv', 'wb')\\n outputwriter = csv.writer(csvfile, dialect='excel')\\n outputwriter.writerow([\\\"GS_file\\\"] + [\\\"TS_File\\\"] + [\\\"Temperature\\\"] + [\\\"Pressure\\\"] + [\\\"Scale_factor\\\"] + [\\\"Chem_symbol\\\"] + [\\\"GS_number\\\"] + [\\\"TS_number\\\"] + [\\\"Labeled_isotope\\\"] + [\\\"KIE\\\"] + [\\\"KIE_tunneling\\\"])\\n heading = [\\\"GS_file\\\", \\\"TS_File\\\", \\\"Temperature\\\", \\\"Pressure\\\", \\\"Scale_factor\\\", \\\"Chem_symbol\\\", \\\"GS_number\\\", \\\"TS_number\\\", \\\"Labeled_isotope\\\", \\\"KIE\\\", \\\"KIE_tunneling\\\"]\\n x=0\\n for each_GS in GS_chkpt_file:\\n for each_TS in TS_chkpt_file:\\n for each_item in isotope_changes: #split the changes to the isotope\\n for each_temp in temp:\\n if len(each_GS) > x:\\n x = len(each_GS)\\n if len(each_TS) > x:\\n x = len(each_TS)\\n y += 1\\n chem_sym = []\\n gs_num = []\\n ts_num = []\\n isotope_mass = []\\n output = []\\n i = 0\\n while i < len(each_item):\\n chem_sym.append(each_item[i])\\n gs_num.append(each_item[i+1])\\n ts_num.append(each_item[i+2])\\n isotope_mass.append(each_item[i+3])\\n i += 4\\n \\n # run freqchk for TS without a marker\\n run_freqchk_TS_no_marker(each_TS, hyperchem_files, each_temp, pressure, scale_factor, gradient_direction)\\n #run freqchk for TS with a marker\\n run_freqchk_TS_marker(each_TS, hyperchem_files, each_temp, pressure, scale_factor, gradient_direction, ts_num, isotope_mass, number_atoms_TS)\\n #run freqchk for GS without a marker\\n run_freqchk_GS_no_marker(each_GS, hyperchem_files, each_temp, pressure, scale_factor, gradient_direction)\\n #run freqchk for GS with a marker\\n run_freqchk_GS_marker(each_GS, hyperchem_files, each_temp, pressure, scale_factor, gradient_direction, gs_num, isotope_mass, number_atoms_GS)\\n\\n #get frequencies from .txt file\\n frequency_TS_natural = map(float, get_frequencies(\\\"freq_TS_no_marker.txt\\\"))\\n frequency_TS_isotope = map(float, get_frequencies(\\\"freq_TS_marker.txt\\\"))\\n frequency_GS_natural = map(float, get_frequencies(\\\"freq_GS_no_marker.txt\\\"))\\n frequency_GS_isotope = map(float, get_frequencies(\\\"freq_GS_marker.txt\\\"))\\n\\n #remove freqchk output files\\n os.system(\\\"rm freq_TS_no_marker.txt freq_TS_marker.txt freq_GS_no_marker.txt freq_GS_marker.txt\\\")\\n\\n # create array with u values\\n u_TS_natural = np.array(calc_u(frequency_TS_natural, each_temp, scale_factor))\\n u_TS_isotope = np.array(calc_u(frequency_TS_isotope, each_temp, scale_factor))\\n u_GS_natural = np.array(calc_u(frequency_GS_natural, each_temp, scale_factor))\\n u_GS_isotope = np.array(calc_u(frequency_GS_isotope, each_temp, scale_factor))\\n if u_TS_natural[0] < 0:\\n u_neg_TS_natural= u_TS_natural[0] #negative u value\\n u_TS_natural = u_TS_natural[1:] #allows calculation on all u values that are positive\\n u_neg_TS_isotope = u_TS_isotope[0] #negative u value\\n u_TS_isotope = u_TS_isotope[1:] #allows calculation on all u values that are positive\\n else:\\n u_neg_TS_natural =[]\\n u_neg_TS_isotope = []\\n\\n # create array with exp(u/2) values\\n exp_TS_natural = np.array(exp_u_half(u_TS_natural))\\n exp_TS_isotope = np.array(exp_u_half(u_TS_isotope))\\n exp_GS_natural = np.array(exp_u_half(u_GS_natural))\\n exp_GS_isotope = np.array(exp_u_half(u_GS_isotope))\\n\\n # create array with 1-exp(-u) values\\n one_minus_exp_TS_natural = np.array(calc_one_minus_exp(u_TS_natural))\\n one_minus_exp_TS_isotope = np.array(calc_one_minus_exp(u_TS_isotope))\\n one_minus_exp_GS_natural = np.array(calc_one_minus_exp(u_GS_natural))\\n one_minus_exp_GS_isotope = np.array(calc_one_minus_exp(u_GS_isotope))\\n\\n # create array with prod values\\n prod_TS_natural = np.array(calc_prod(u_TS_natural, exp_TS_natural, one_minus_exp_TS_natural))\\n prod_TS_isotope = np.array(calc_prod(u_TS_isotope, exp_TS_isotope, one_minus_exp_TS_isotope))\\n prod_GS_natural = np.array(calc_prod(u_GS_natural, exp_GS_natural, one_minus_exp_GS_natural))\\n prod_GS_isotope = np.array(calc_prod(u_GS_isotope, exp_GS_isotope, one_minus_exp_GS_isotope))\\n \\n # calculate FTS\\n if u_neg_TS_natural:\\n FTS_TS_natural = calc_FTS_TS(prod_TS_natural, u_neg_TS_natural)\\n FTS_TS_isotope = calc_FTS_TS(prod_TS_isotope, u_neg_TS_isotope)\\n FTS_GS_natural = calc_FTS(prod_GS_natural)\\n FTS_GS_isotope = calc_FTS(prod_GS_isotope)\\n else:\\n FTS_TS_natural = calc_FTS(prod_TS_natural)\\n FTS_TS_isotope = calc_FTS(prod_TS_isotope)\\n FTS_GS_natural = calc_FTS(prod_GS_natural)\\n FTS_GS_isotope = calc_FTS(prod_GS_isotope)\\n \\n # calcualte qt for TS\\n if u_neg_TS_natural:\\n qt_TS_natural = calc_qt(u_neg_TS_natural)\\n qt_TS_isotope = calc_qt(u_neg_TS_isotope)\\n else:\\n qt_TS_natural = calc_qt(u_TS_natural[0])\\n qt_TS_isotope = calc_qt(u_TS_isotope[0])\\n\\n # build dictionary with elements and get the mass of the\\n # elements being used\\n elements = {'H':1, 'He':4, 'Li':7, 'B':11, 'C':12, 'N':14, 'O':16, 'Ne':20, 'Mg':24, 'Si':28, 'S':32, 'Cl':35, 'Ar':40, 'K':39, 'Ca':40, 'Ti':48, 'Cr':52, 'Fe':56, 'Ni':58, 'Cu':63, 'Zn':64, 'Ga':69, 'Ge':74, 'Se':80, 'Br':79, 'Kr':84, 'Sr':88, 'Zr':90, 'Mo':98, 'Ru':102, 'Pd':106, 'Ag':107, 'Cd':114, 'Sn':120, 'Sb':121, 'Te':126, 'Xe':132, 'Ba':138, 'Ce':140, 'Nd':142, 'Sm':152, 'Eu':153, 'Gd':158, 'Dy':164, 'Er':166, 'Yb':174, 'Hf':180, 'W':184, 'Os':192, 'Ir':193, 'Pt':195, 'Hg':202, 'Tl':205, 'Pb':208}\\n temp_sym = ' '.join(chem_sym[0])\\n temp_isotope_mass = isotope_mass[0]\\n temp_isotope_mass = \\\"\\\".join(repr(temp_isotope_mass))\\n temp_isotope_mass = int(temp_isotope_mass)\\n\\n # calculate KIE\\n for a in elements.keys():\\n if a == ''.join(temp_sym):\\n if elements[a] > temp_isotope_mass:\\n KIE1 = (FTS_TS_isotope / FTS_TS_natural)\\n KIE2 = (FTS_GS_natural / FTS_GS_isotope)\\n KIE3 = KIE2 * KIE1\\n KIE = 1 / KIE3\\n else:\\n KIE1 = (FTS_TS_isotope / FTS_TS_natural)\\n KIE2 = (FTS_GS_natural / FTS_GS_isotope)\\n KIE = KIE2 * KIE1\\n\\n #calculate KIE with tunneling\\n KIE_tunneling = KIE * qt_TS_natural / qt_TS_isotope\\n\\n #convert to strings\\n gs_num = map(str, gs_num)\\n ts_num = map(str, ts_num)\\n isotope_mass = map(str, isotope_mass)\\n KIE = str(KIE)\\n KIE_tunneling = str(KIE_tunneling)\\n\\n each_temp = ''.join(each_temp)\\n pressure = ''.join(pressure)\\n scale_factor = ''.join(scale_factor)\\n chem_sym = ', '.join(chem_sym)\\n gs_num = ', '.join(gs_num)\\n ts_num = ', '.join(ts_num)\\n isotope_mass = ', '.join(isotope_mass)\\n \\n output.append(each_GS)\\n output.append(each_TS)\\n output.append(each_temp)\\n output.append(pressure)\\n output.append(scale_factor)\\n output.append(chem_sym)\\n output.append(gs_num)\\n output.append(ts_num)\\n output.append(isotope_mass)\\n output.append(KIE)\\n output.append(KIE_tunneling)\\n master_output.append(output)\\n\\n outputwriter.writerow([each_GS] + [each_TS] + [each_temp] + [pressure] + [scale_factor] + [chem_sym] + [gs_num] + [ts_num] + [isotope_mass] + [KIE] + [KIE_tunneling])\\n csvfile.close()\\n\\n print ' '.join(heading)\\n for each_entry in master_output:\\n print ' '.join(each_entry)\\n \\n print \\\"\\\\n\\\", \\\"All KIE's have been calculated!\\\", \\\"\\\\n\\\"\",\n \"def process_trace(n_tr, tr, sta, orig_time, cmps, cfg):\\n cmp = tr.stats.channel[2:3]\\n sta[cmp] = {}\\n sta[cmp][\\\"times\\\"] = tr.times(reftime=orig_time)\\n\\n sta[cmp][\\\"tr_results\\\"] = np.zeros(\\n (len(cfg.picking.FILT_WINS[\\\"P\\\"]), sta[\\\"lenD\\\"])\\n )\\n sta[cmp][\\\"f1_results\\\"] = np.zeros(\\n (len(cfg.picking.FILT_WINS[\\\"P\\\"]), len(cfg.picking.KURT_WINS),\\n sta[\\\"lenD\\\"])\\n )\\n sta[cmp][\\\"f1_mean\\\"] = np.zeros(sta[\\\"lenD\\\"])\\n sta[cmp][\\\"f3_results\\\"] = np.zeros(\\n (len(cfg.picking.FILT_WINS[\\\"P\\\"]),\\n len(cfg.picking.KURT_WINS), sta[\\\"lenD\\\"])\\n )\\n sta[cmp][\\\"f3_mean_smooth\\\"] = np.zeros(\\n (len(cfg.picking.CF_MEAN_SMOOTH_WIND), sta[\\\"lenD\\\"])\\n )\\n sta[cmp][\\\"f4_all\\\"] = np.zeros((len(cfg.picking.CF_MEAN_SMOOTH_WIND),\\n sta[\\\"lenD\\\"]))\\n sta[cmp][\\\"f1_mean_smooth\\\"] = np.zeros(sta[\\\"lenD\\\"])\\n # Get suitable filters (exclude those fully outside Nyquist freq.)\\n for phase in [\\\"P\\\", \\\"S\\\"]:\\n if cmp in cmps[phase]:\\n sta[\\\"picks\\\"][\\\"poss_obs\\\"][phase][cmp] = {}\\n sta[cmp][\\\"filtwins_check\\\"] = [\\n filt_win for filt_win in cfg.picking.FILT_WINS[phase]\\n if filt_win[0] < sta[\\\"samplerate\\\"] / 2\\n ]\\n if cfg.picking.INTEGRATE_S is True:\\n tr.integrate()\\n\\n for n_filt, filt in enumerate(sta[cmp][\\\"filtwins_check\\\"]):\\n # Ensure that filter covers sample rate / 2\\n if (tr.stats.sampling_rate / 2) <= filt[0]:\\n print(\\\"Skipping this Kurtosis run due to sample rate/2<f\\\")\\n continue\\n tr.filter(\\\"bandpass\\\", freqmin=filt[0], freqmax=filt[1])\\n try:\\n sta[cmp][\\\"tr_results\\\"][n_filt] = tr.data\\n except ValueError: # If input array length is inconsistent\\n continue\\n # Loop over kurtosis windows\\n for n_kurt, kurt_win_s in enumerate(cfg.picking.KURT_WINS):\\n f1 = CF_kurtosis(kurt_win_s, tr)\\n sta[cmp][\\\"f1_results\\\"][n_filt, n_kurt] = f1 # Needed for weights\\n f2 = kurt_transform_f2(f1, kurt_win_s, tr)\\n f3 = kurt_transform_f3(f2, kurt_win_s, tr)\\n\\n sta[cmp][\\\"f3_results\\\"][n_filt, n_kurt] = f3\\n sta[cmp][\\\"f1_mean\\\"] = np.nanmean(sta[cmp][\\\"f1_results\\\"], axis=0)[0]\\n sta[cmp][\\\"f1_mean_smooth\\\"] = do_smooth(\\n sta[cmp][\\\"f1_mean\\\"], cfg.picking.CF_MEAN_SMOOTH_WIND[0],\\n tr.stats.sampling_rate\\n )\\n # ^ Throws up a warning first time due to NaN slices\\n # Compute mean CF and final kurtosis transform\\n f3_mean = np.nanmean(sta[cmp][\\\"f3_results\\\"], axis=0)[0]\\n\\n for nsm, smooth_wind in enumerate(cfg.picking.CF_MEAN_SMOOTH_WIND):\\n sta[cmp][\\\"f3_mean_smooth\\\"][nsm] = do_smooth(\\n f3_mean, smooth_wind, tr.stats.sampling_rate\\n )\\n f4 = kurt_transform_f4(sta[cmp][\\\"f3_mean_smooth\\\"][nsm],\\n np.max(cfg.picking.KURT_WINS), tr)\\n sta[cmp][\\\"f4_all\\\"][nsm] = f4\\n\\n # Now pick (avoiding end and beginning of signal)\\n # Pick the P-waves\\n if cmp in cmps[\\\"P\\\"]:\\n sta[\\\"picks\\\"][\\\"poss_obs\\\"][\\\"P\\\"][cmp][nsm] = []\\n # Find points where Kurt<0 & doesn't look like S-wave\\n p_cands = np.argwhere((f4 < 0.0))\\n for idx in p_cands.tolist():\\n kurt_wgt = np.min(np.where(np.array(\\n cfg.picking.KURT2WGHT[\\\"P\\\"]\\n <= sta[cmp][\\\"f1_mean_smooth\\\"][idx])))\\n sta[\\\"picks\\\"][\\\"poss_obs\\\"][\\\"P\\\"][cmp][nsm].append([\\n orig_time+sta[cmp][\\\"times\\\"][idx][0], f4[idx][0],\\n tr.stats.channel, kurt_wgt, idx,\\n sta[cmp][\\\"times\\\"][idx][0]\\n ])\\n # Pick the S-waves\\n if cmp in cmps[\\\"S\\\"]:\\n sta[\\\"picks\\\"][\\\"poss_obs\\\"][\\\"S\\\"][cmp][nsm] = []\\n\\n # Find points where Kurt<0 & doesn't look like S-wave\\n s_cands = np.argwhere((f4 < 0.0))\\n for idx in s_cands.tolist():\\n kurt_wgt = np.min(np.where(np.array(cfg.picking.KURT2WGHT[\\\"S\\\"]\\n <= sta[cmp][\\\"f1_mean_smooth\\\"][idx]))\\n )\\n sta[\\\"picks\\\"][\\\"poss_obs\\\"][\\\"S\\\"][cmp][nsm].append([\\n orig_time+sta[cmp][\\\"times\\\"][idx][0], f4[idx][0],\\n tr.stats.channel, kurt_wgt, idx,\\n sta[cmp][\\\"times\\\"][idx][0]\\n ])\\n return(sta)\",\n \"def analyze_from_tailed_file(self, a_file_paths, a_go_to_the_end = True): #pylint: disable-msg=R0912\\n files = []\\n for f_path in a_file_paths:\\n files.append(open(f_path, 'r'))\\n \\n f_iter = multitail.MultiFileTailer.tail(files, delay=0.4, go_to_the_end = a_go_to_the_end)\\n \\n last_time_display = None\\n on_error = False\\n \\n try:\\n \\n #init print\\n self.print_on_display(self.display, None)\\n \\n for (f_line, _) in f_iter:\\n \\n #process only tuples (other lines should be ignored)\\n matched = Analyzer.expr_re.match(f_line)\\n if matched:\\n \\n line = matched.group('line')\\n filename = matched.group('filename')\\n \\n # sometimes the tail can eat (bug) part of the line\\n # ignore this exception\\n try:\\n self.analyze(self.mem_db, line, filename)\\n except tellicastlog_parser.InvalidTellicastlogFormatError, err:\\n error_str = utils.get_exception_traceback()\\n Analyzer.LOG.error(\\\"Parser Exception %s, traceback %s\\\" %(err, error_str))\\n \\n last_time_display = self.print_on_display(self.display, last_time_display)\\n \\n kb_input = self.display.check_for_input()\\n if kb_input and kb_input == 'QUIT':\\n break # quit loop\\n elif kb_input and kb_input == 'STOPACCEPTING':\\n Analyzer.LOG.error(\\\"*********** Stop Accepting\\\")\\n self._accepting_new = False\\n elif kb_input and kb_input == 'RESTARTACCEPTING':\\n Analyzer.LOG.error(\\\"*********** Restart Accepting\\\")\\n self._accepting_new = True\\n elif kb_input and kb_input == 'OLDEST':\\n Analyzer.LOG.error(\\\"*********** OLDEST records first\\\")\\n self._sort_criteria = 'OLDEST'\\n elif kb_input and kb_input == 'NEWEST':\\n Analyzer.LOG.error(\\\"*********** NEWEST records first\\\")\\n self._sort_criteria = 'NEWEST'\\n \\n else:\\n #force update\\n self.print_on_display(self.mem_db, self.display, None)\\n \\n except KeyboardInterrupt:\\n \\n #CTRL^C pressed so silently quit\\n sys.exit(0)\\n except Exception, err:\\n \\n Analyzer.LOG.error(\\\"In Error\\\")\\n \\n error_str = utils.get_exception_traceback()\\n \\n Analyzer.LOG.error(\\\"received error %s. Traceback = %s\\\" %(err, error_str))\\n \\n on_error = True\\n finally:\\n #whatever the case always reset the screen\\n self.display.reset_screen()\\n if on_error:\\n print(\\\"Exiting on error\\\")\\n return 1 #pylint: disable-msg=W0150\\n else:\\n print(\\\"Exiting gracefully\\\")\\n return 0 #pylint: disable-msg=W0150\",\n \"def produce_all_term_data(self):\\n # remove cold start records if requested\\n test = self.test.copy()\\n test = self.handle_cold_start(test)\\n\\n outputs = self.output()\\n trainf, testf = outputs['train'], outputs['test']\\n with trainf.open('w') as ftrain, testf.open('w') as ftest:\\n self.write_libfm_data(ftrain, ftest, self.train, test)\\n\\n # Write the term-to-id guide\\n test = test.sort(('termnum'))\\n test['rownum'] = np.arange(len(test))\\n guide = test.groupby('termnum').max()['rownum']\\n with self.output()['guide'].open('w') as f:\\n guide.to_csv(f, index_label='termnum', header=True)\",\n \"def __init__ (self, fTrace, pTrace, traceType, precision, recall, totalNodes, startTime, endTime):\\n\\n self.traceType = traceType\\n self.precision = precision\\n self.recall = recall\\n self.totalNodes = totalNodes\\n self.startTime = startTime\\n self.endTime = endTime\\n self.fTraceHandle = open (fTrace, \\\"r\\\")\\n self.pTraceHandle = open (pTrace, \\\"w\\\")\\n\\n self.readNextTraceLine (self.fTraceHandle)\\n\\n self.totalEvents = 0\\n self.predictedEvents = 0\\n self.correctPredictions = 0\\n self.totalPredictions = 0\",\n \"def summaryD4(self):\\r\\n\\r\\n if len(self.window.diff_tabs.lst_indices_present)!=0:\\r\\n \\r\\n for index in self.window.diff_tabs.lst_indices_present:\\r\\n if index==1:\\r\\n \\r\\n dfD4_temp1_pos1= pd.read_csv('raw_text_D4_1_1.txt')\\r\\n dfD4_temp1_pos2= pd.read_csv('raw_text_D4_1_2.txt')\\r\\n dfD4_temp1_pos3= pd.read_csv('raw_text_D4_1_3.txt')\\r\\n dfD4_temp1_pos4= pd.read_csv('raw_text_D4_1_4.txt')\\r\\n \\r\\n D4summary_temp1=pd.concat([dfD4_temp1_pos1,dfD4_temp1_pos2,dfD4_temp1_pos3,dfD4_temp1_pos4],axis=1)\\r\\n D4summary_temp1.to_csv('D4summary_temp1.txt',index=False)\\r\\n \\r\\n if index==2:\\r\\n \\r\\n dfD4_temp2_pos1= pd.read_csv('raw_text_D4_2_1.txt')\\r\\n dfD4_temp2_pos2= pd.read_csv('raw_text_D4_2_2.txt')\\r\\n dfD4_temp2_pos3= pd.read_csv('raw_text_D4_2_3.txt')\\r\\n dfD4_temp2_pos4= pd.read_csv('raw_text_D4_2_4.txt')\\r\\n \\r\\n D4summary_temp2=pd.concat([dfD4_temp2_pos1,dfD4_temp2_pos2,dfD4_temp2_pos3,dfD4_temp2_pos4],axis=1)\\r\\n D4summary_temp2.to_csv('D4summary_temp2.txt',index=False)\\r\\n \\r\\n if index==3:\\r\\n \\r\\n dfD4_temp3_pos1= pd.read_csv('raw_text_D4_3_1.txt')\\r\\n dfD4_temp3_pos2= pd.read_csv('raw_text_D4_3_2.txt')\\r\\n dfD4_temp3_pos3= pd.read_csv('raw_text_D4_3_3.txt')\\r\\n dfD4_temp3_pos4= pd.read_csv('raw_text_D4_3_4.txt')\\r\\n \\r\\n D4summary_temp3=pd.concat([dfD4_temp3_pos1,dfD4_temp3_pos2,dfD4_temp3_pos3,dfD4_temp3_pos4],axis=1)\\r\\n D4summary_temp3.to_csv('D4summary_temp3.txt',index=False)\",\n \"def scanData(run, precisionLabel, s06Cfg, tarList):\\n try:\\n tfp = open(tarList)\\n except:\\n print(\\\"ERROR opening\\\", tarList)\\n sys.exit(1)\\n\\n tRemove = set()\\n tFinished = set()\\n tFinishedStart = True\\n tSurplusData = set()\\n nDataFinish = None\\n nExtra = 0\\n nBadMeasure = 0\\n nMissing = 0\\n first = True\\n for line in tfp:\\n corrFile, linesPerTime = line.split()\\n corrFile = re.sub('CFG', s06Cfg, corrFile)\\n corrFilePath = os.path.join(run, \\\"data\\\", precisionLabel, corrFile)\\n linesPerTime = int(linesPerTime)\\n\\n try:\\n stat = os.stat(corrFilePath)\\n except OSError:\\n if first:\\n print(\\\"ERROR: can't find required file\\\", corrFilePath)\\n print(\\\"Listing of any other missing files will be suppressed\\\")\\n first = False\\n nMissing += 1\\n tFinished = set()\\n tFinishedStart = False\\n continue\\n\\n # Get stanza count from the number of lines in the file\\n cmd = ' '.join([\\\"wc -l\\\", corrFilePath, \\\"| awk '{print $1}'\\\"])\\n try:\\n haveLines = subprocess.check_output(cmd, shell=True)\\n except subprocess.CalledProcessError as e:\\n # If we can't find the file, no chance of recovery\\n print(\\\"ERROR: can't count lines in\\\", corrFile, \\\"return code\\\", e.returncode, \\\".\\\")\\n return tFinished, tRemove, nExtra, nBadMeasure, nMissing\\n\\n # Check line count\\n haveLines = int(haveLines.rstrip().decode())\\n if haveLines % linesPerTime != 0:\\n nBadMeasure += 1\\n \\n n = haveLines//int(linesPerTime)\\n\\n # Get list of source times in the correlator file\\n cmd = ' '.join(['grep \\\"antiquark_source_origin:\\\"', corrFilePath, \\n \\\"| awk '{print $6}'\\\"])\\n try:\\n tFoundList = subprocess.check_output(cmd, shell=True).splitlines()\\n except subprocess.CalledProcessError as e:\\n # If we can't find the file, no chance of recovery\\n print(\\\"ERROR: can't find source times in\\\", corrFile, \\\"return code\\\", e.returncode, \\\".\\\")\\n return tFinished, tRemove, nExtra, nBadMeasure, nMissing\\n # Decode byte encoding\\n tFound = set([c.decode() for c in tFoundList])\\n\\n if verbose:\\n print(\\\"For\\\", corrFilePath, \\\"found\\\", haveLines, \\\"lines with\\\", \\n linesPerTime, \\\"values per time\\\")\\n print(\\\"Found times\\\", tFound)\\n\\n # Consistency check\\n if n > len(tFound):\\n nExtra += 1\\n elif n < len(tFound):\\n print(\\\"FATAL:\\\", corrFilePath, \\\"lists more time values than its length permits\\\")\\n sys.exit(1)\\n\\n # tFinished will be a list of all times common to all correlators\\n if tFinishedStart:\\n tFinished = tFound\\n tFinishedStart = False\\n else:\\n tFinished = tFinished.intersection(tFound)\\n\\n # tRemove will be a list of all times not common to all correlators\\n tSpare = tFound.difference(tFinished)\\n if len(tSpare) > 0:\\n tRemove.update(tSpare)\\n\\n if nDataFinish == None:\\n nDataFinish = n\\n elif n < nDataFinish:\\n nDataFinish = n\\n\\n # Get the locations of the JobID lines\\n cmd = ' '.join([\\\"grep -n JobID\\\", corrFilePath, \\\"| awk -F: '{print $1}'\\\"])\\n try:\\n jobIDLines = subprocess.check_output(cmd, shell=True).splitlines()\\n except subprocess.CalledProcessError as e:\\n # If we can't find the file, no chance of recovery\\n print(\\\"ERROR: can't count lines in\\\", corrFilePath, \\\"return code\\\", e.returncode, \\\".\\\")\\n return tFinished, tRemove, nExtra, nBadMeasure, nMissing\\n # Decode byte encoding\\n jobIDLines = [int(c.decode()) for c in jobIDLines]\\n\\n # Check locations of JobID lines\\n if len(jobIDLines) == 0:\\n print(\\\"ERROR: No JobID lines in\\\", corrFilePath)\\n tFinished = set()\\n return tFinished, tRemove, nExtra, nBadMeasure, nMissing\\n if jobIDLines[0] != 2:\\n print(\\\"ERROR: First JobID line is at line no\\\", jobIDLines[0], \\n \\\"but should be at line 2 in\\\", corrFilePath)\\n # Add an extrapolated location for the last stanza\\n jobIDLines += [haveLines + 2]\\n \\n # Check for correct spacing of jobID lines\\n for k in range(1,len(jobIDLines)):\\n linect = jobIDLines[k] - jobIDLines[k-1]\\n if linect < linesPerTime:\\n t0 = int(tFoundList[k-1].decode())\\n if t0 in tFinished:\\n print(\\\"ERROR: stanza for time\\\", t0, \\\"in\\\", corrFilePath, \\n \\\"has line count\\\", linect, \\\"but wanted\\\", linesPerTime)\\n print(\\\"That time will be dropped\\\")\\n tFinished.discard(t0)\\n tRemove.update([t0])\\n elif linect > linesPerTime:\\n t0 = int(tFoundList[k-1].decode())\\n if t0 not in tSurplusData:\\n print(\\\"ERROR: stanza for time\\\", t0, \\\"in\\\", corrFilePath, \\\"has line count\\\", \\n linect, \\\"but wanted\\\", linesPerTime)\\n print(\\\"The extra lines will be dropped\\\")\\n tSurplusData.update([t0])\\n\\n if nExtra > 0:\\n print(\\\"ERROR: in\\\", nExtra, precisionLabel,\\n \\\"correlator files there was a mismatch between the time stanza count\\\",\\n \\\"and the number of unique source times\\\")\\n if nBadMeasure > 0:\\n print(\\\"ERROR: In\\\", nBadMeasure, precisionLabel, nBadMeasure,\\n \\\"correlator files the line count was not an integer multiple of the fiducial count\\\",\\n \\\"per stanza, indicating either extra or missing lines.\\\")\\n\\n return tFinished, tRemove, nExtra, nBadMeasure, nMissing\",\n \"def write_tsvs(raw_dir: Path, bids_dir: Path):\\n\\n print(\\\"Writing tsvs.\\\")\\n\\n for path_to_onset in Path(raw_dir/\\\"onset_textfiles\\\").glob(\\\"*.txt\\\"):\\n\\n onsets_as_lines_with_too_much_whitespace = path_to_onset.read_text().splitlines()\\n onsets = [line.strip() for line in onsets_as_lines_with_too_much_whitespace]\\n\\n tsv_lines_without_a_header = [onset + \\\"\\\\t\\\" + \\\"4\\\" for onset in onsets]\\n tsv_lines = [\\\"onset\\\" + \\\"\\\\t\\\" + \\\"duration\\\"] + tsv_lines_without_a_header\\n full_text_of_tsv = \\\"\\\\n\\\".join(tsv_lines)\\n\\n subject_id = subject_id_of(path_to_onset)\\n task_id = path_to_onset.stem.split(\\\"_\\\")[1]\\n\\n func_path_to_imitate = the_path_that_matches(f\\\"*_task-{task_id}*.nii\\\", in_directory=bids_dir/f\\\"sub-{subject_id}/func\\\")\\n func_stem_split_into_parts = func_path_to_imitate.stem.split(\\\"_\\\")\\n tsv_stem_split_into_parts = func_stem_split_into_parts[:-1] + [\\\"events\\\"]\\n tsv_stem = \\\"_\\\".join(tsv_stem_split_into_parts)\\n tsv_path = func_path_to_imitate.with_name(tsv_stem + \\\".tsv\\\")\\n\\n tsv_path.write_text(full_text_of_tsv)\",\n \"def modelfactors(trace_files: List[str], trace_processes: Dict):\\n traces = [load(file) for file in trace_files]\\n df_mfactors = pd.DataFrame(columns=MOD_FACTORS_DOC.values())\\n reference = True\\n for (hdf5_file, trace, cpus) in zip(trace_files, traces, trace_processes.values()):\\n MOD_FACTORS_VAL['num_processes'] = cpus\\n print(\\n f\\\"==INFO== Analysing {hdf5_file} ({MOD_FACTORS_VAL['num_processes']} processes, {human_readable(os.path.getsize(hdf5_file))})\\\")\\n\\n # Computes raw data\\n ipc, freq, runtime, runtime_id, useful_av, useful_max, useful_tot, useful_id, useful_inst, useful_cyc = get_raw_data(\\n trace, cmdl_args)\\n\\n MOD_FACTORS_VAL['ipc'] = ipc\\n MOD_FACTORS_VAL['freq'] = freq\\n MOD_FACTORS_VAL['runtime'] = runtime\\n MOD_FACTORS_VAL['runtime_id'] = runtime_id\\n MOD_FACTORS_VAL['useful_av'] = useful_av\\n MOD_FACTORS_VAL['useful_max'] = useful_max\\n MOD_FACTORS_VAL['useful_tot'] = useful_tot\\n MOD_FACTORS_VAL['useful_id'] = useful_id\\n MOD_FACTORS_VAL['useful_ins'] = useful_inst\\n MOD_FACTORS_VAL['useful_cyc'] = useful_cyc\\n\\n # Computes efficiencies after getting the raw data\\n parallel_eff, load_balance, comm_eff, serial_eff, transfer_eff = get_efficiencies(\\n MOD_FACTORS_VAL['runtime'],\\n MOD_FACTORS_VAL['runtime_id'],\\n MOD_FACTORS_VAL['useful_av'],\\n MOD_FACTORS_VAL['useful_max'],\\n MOD_FACTORS_VAL['useful_id'],\\n MOD_FACTORS_VAL['comp_scale'])\\n\\n MOD_FACTORS_VAL['parallel_eff'] = parallel_eff\\n MOD_FACTORS_VAL['load_balance'] = load_balance\\n MOD_FACTORS_VAL['comm_eff'] = comm_eff\\n MOD_FACTORS_VAL['serial_eff'] = serial_eff\\n MOD_FACTORS_VAL['transfer_eff'] = transfer_eff\\n\\n # Adds the new row with the raw data and efficiencies to the dataframe\\n df_mfactors.loc[len(df_mfactors), :] = list(MOD_FACTORS_VAL.values())\\n\\n # Computes scalabilities\\n df_mfactors = get_scalabilities(df_mfactors, cmdl_args)\\n\\n return df_mfactors\",\n \"def process(filename, debug_mode=False):\\n if debug_mode:\\n global DO_REPORT\\n DO_REPORT = debug_mode\\n\\n try:\\n signal = preprocessing(filename)\\n except BaseException as e:\\n print(e)\\n sys.exit()\\n\\n labels, num_of_speakers = diarization(signal)\\n segments = lab2seg(labels)\\n res_filename = create_csv(filename, segments)\\n return res_filename, num_of_speakers\",\n \"def read_traveltime(self):\\r\\n \\r\\n #### read Travel time from txt file\\r\\n \\r\\n \\r\\n #### Particle travel time branch 1\\r\\n excelfile_surface_branch1_high = r'excel\\\\flow_rate\\\\particle_surface_branch1_high.xlsx'\\r\\n inarray_surface_branch1_high = pd.read_excel(excelfile_surface_branch1_high).to_numpy() \\r\\n \\r\\n excelfile_surface_branch1_medium = r'excel\\\\flow_rate\\\\particle_surface_branch1_medium.xlsx'\\r\\n inarray_surface_branch1_medium = pd.read_excel(excelfile_surface_branch1_medium).to_numpy() \\r\\n \\r\\n excelfile_surface_branch1_low = r'excel\\\\flow_rate\\\\particle_surface_branch1_low.xlsx'\\r\\n inarray_surface_branch1_low = pd.read_excel(excelfile_surface_branch1_low).to_numpy()\\r\\n \\r\\n excelfile_bottom_branch1_high = r'excel\\\\flow_rate\\\\particle_bottom_branch1_high.xlsx'\\r\\n inarray_bottom_branch1_high = pd.read_excel(excelfile_bottom_branch1_high).to_numpy()\\r\\n \\r\\n excelfile_bottom_branch1_medium = r'excel\\\\flow_rate\\\\particle_bottom_branch1_medium.xlsx'\\r\\n inarray_bottom_branch1_medium = pd.read_excel(excelfile_bottom_branch1_medium).to_numpy()\\r\\n \\r\\n excelfile_bottom_branch1_low = r'excel\\\\flow_rate\\\\particle_bottom_branch1_low.xlsx'\\r\\n inarray_bottom_branch1_low = pd.read_excel(excelfile_bottom_branch1_low).to_numpy()\\r\\n \\r\\n \\r\\n #### Tracer travel time branch 1\\r\\n excelfile_tracer_branch1_high = r'excel\\\\flow_rate\\\\tracer_branch1_high.xlsx'\\r\\n inarray_tracer_branch1_high = pd.read_excel(excelfile_tracer_branch1_high).to_numpy()\\r\\n \\r\\n excelfile_tracer_branch1_medium = r'excel\\\\flow_rate\\\\tracer_branch1_medium.xlsx'\\r\\n inarray_tracer_branch1_medium = pd.read_excel(excelfile_tracer_branch1_medium).to_numpy()\\r\\n \\r\\n excelfile_tracer_branch1_low = r'excel\\\\flow_rate\\\\tracer_branch1_low.xlsx'\\r\\n inarray_tracer_branch1_low = pd.read_excel(excelfile_tracer_branch1_low).to_numpy()\\r\\n \\r\\n self.inarrays_branch1 = [inarray_surface_branch1_high, inarray_surface_branch1_medium, inarray_surface_branch1_low, \\\\\\r\\n inarray_bottom_branch1_high, inarray_bottom_branch1_medium, inarray_bottom_branch1_low, \\\\\\r\\n inarray_tracer_branch1_high, inarray_tracer_branch1_medium, inarray_tracer_branch1_low]\\r\\n \\r\\n \\r\\n #### Particle travel time branch 5\\r\\n excelfile_surface_branch5_high = r'excel\\\\flow_rate\\\\particle_surface_branch5_high.xlsx'\\r\\n inarray_surface_branch5_high = pd.read_excel(excelfile_surface_branch5_high).to_numpy()\\r\\n \\r\\n excelfile_surface_branch5_medium = r'excel\\\\flow_rate\\\\particle_surface_branch5_medium.xlsx'\\r\\n inarray_surface_branch5_medium = pd.read_excel(excelfile_surface_branch5_medium).to_numpy()\\r\\n \\r\\n excelfile_surface_branch5_low = r'excel\\\\flow_rate\\\\particle_surface_branch5_low.xlsx'\\r\\n inarray_surface_branch5_low = pd.read_excel(excelfile_surface_branch5_low).to_numpy()\\r\\n \\r\\n excelfile_bottom_branch5_high = r'excel\\\\flow_rate\\\\particle_bottom_branch5_high.xlsx'\\r\\n inarray_bottom_branch5_high = pd.read_excel(excelfile_bottom_branch5_high).to_numpy()\\r\\n \\r\\n excelfile_bottom_branch5_medium = r'excel\\\\flow_rate\\\\particle_bottom_branch5_medium.xlsx'\\r\\n inarray_bottom_branch5_medium = pd.read_excel(excelfile_bottom_branch5_medium).to_numpy()\\r\\n \\r\\n excelfile_bottom_branch5_low = r'excel\\\\flow_rate\\\\particle_bottom_branch5_low.xlsx'\\r\\n inarray_bottom_branch5_low = pd.read_excel(excelfile_bottom_branch5_low).to_numpy()\\r\\n \\r\\n \\r\\n #### Tracer travel time branch 5\\r\\n excelfile_tracer_branch5_high = r'excel\\\\flow_rate\\\\tracer_branch5_high.xlsx'\\r\\n inarray_tracer_branch5_high = pd.read_excel(excelfile_tracer_branch5_high).to_numpy()\\r\\n \\r\\n excelfile_tracer_branch5_medium = r'excel\\\\flow_rate\\\\tracer_branch5_medium.xlsx'\\r\\n inarray_tracer_branch5_medium = pd.read_excel(excelfile_tracer_branch5_medium).to_numpy()\\r\\n \\r\\n excelfile_tracer_branch5_low = r'excel\\\\flow_rate\\\\tracer_branch5_low.xlsx'\\r\\n inarray_tracer_branch5_low = pd.read_excel(excelfile_tracer_branch5_low).to_numpy()\\r\\n \\r\\n \\r\\n self.inarrays_branch5 = [inarray_surface_branch5_high, inarray_surface_branch5_medium, inarray_surface_branch5_low, \\\\\\r\\n inarray_bottom_branch5_high, inarray_bottom_branch5_medium, inarray_bottom_branch5_low, \\\\\\r\\n inarray_tracer_branch5_high, inarray_tracer_branch5_medium, inarray_tracer_branch5_low]\",\n \"def main():\\n start = time.time()\\n fname = \\\"C:/Users/alexa/OneDrive/Desktop/Thesis/Bitbucket/thesisforex2/preprocessed_data/tweets_sentiment_D.txt\\\"\\n freq = 'D'\\n print ('preprocessing...\\\\n')\\n data = d.data_tweets(fname, freq)\\n size = data.get_length() \\n returns_daily = data.get_return()\\n tscv_outer = TimeSeriesSplit(n_splits=3)\\n tscv_inner = TimeSeriesSplit(n_splits=2)\\n for train, test in tscv_outer.split(returns_daily):\\n X_train_outer = returns_daily.values.ravel()[train]\\n adf_test(X_train_outer)\\n for train_inner, val in tscv_inner.split(X_train_outer):\\n adf_test(X_train_outer[train_inner])\\n\\n fname = \\\"C:/Users/alexa/OneDrive/Desktop/Thesis/Bitbucket/thesisforex2/preprocessed_data/tweets_sentiment_H.txt\\\"\\n freq = 'H'\\n print ('preprocessing...\\\\n')\\n data = d.data_tweets(fname, freq)\\n size = data.get_length() \\n returns_daily = data.get_return()\\n tscv_outer = TimeSeriesSplit(n_splits=10)\\n tscv_inner = TimeSeriesSplit(n_splits=5)\\n for train, test in tscv_outer.split(returns_daily):\\n X_train_outer = returns_daily.values.ravel()[train]\\n adf_test(X_train_outer)\\n for train_inner, val in tscv_inner.split(X_train_outer):\\n adf_test(X_train_outer[train_inner])\\n\\n end = time.time()\\n print(end - start)\",\n \"def process_timestamps(self):\\n self.conn = sqlite3.connect(':memory:')\\n self.cursor = self.conn.cursor()\\n self.cursor.execute('CREATE TABLE tracklog(dt PRIMARY KEY, lat REAL, lon REAL, elev REAL)')\\n num_points = 0\\n for d in gps.parse_gpx_iter(self.gpx_file):\\n self.cursor.execute('INSERT INTO tracklog VALUES(?,?,?,?)', d)\\n num_points += 1\\n sys.stderr.write('The GPX file contained %d Points\\\\n' % num_points)\\n self.conn.commit()\",\n \"def parse_data(filepath):\\n settings = dict()\\n intensity = list()\\n # Boolean flags to check when to start/stop\\n # reading parameters\\n read_params = False\\n read_int = False\\n read_zeeman = False\\n finished = False\\n fieldoff_intensities = list()\\n fieldon_intensities = list()\\n with open(filepath) as read_file:\\n for line in read_file:\\n if \\\"*****\\\" in line:\\n read_int = False\\n if finished is True:\\n break\\n if \\\"Scan\\\" in line:\\n if \\\"[Field ON]\\\" in line:\\n read_zeeman = True\\n scan_details = line.split()\\n settings[\\\"ID\\\"] = int(scan_details[1])\\n # settings[\\\"Date\\\"] = str(scan_details[4])\\n read_params = True\\n read_int = False\\n continue\\n if read_int is True:\\n if read_zeeman is False:\\n fieldoff_intensities += [float(value) for value in line.split()]\\n else:\\n fieldon_intensities += [float(value) for value in line.split()]\\n finished = True\\n if read_params is True and len(line.split()) > 1:\\n # Read in the frequency step, frequency, and other info\\n # needed to reconstruct the frequency data\\n scan_params = line.split()\\n shift = 1\\n settings[\\\"Frequency\\\"] = float(scan_params[0])\\n settings[\\\"Frequency step\\\"] = float(scan_params[1])\\n if len(scan_params) == 4:\\n settings[\\\"Multiplier\\\"] = 1.\\n shift = 0\\n # If the multiplier data is there, we don't shift the read\\n # index over by one\\n else:\\n settings[\\\"Multiplier\\\"] = float(scan_params[2])\\n settings[\\\"Center\\\"] = float(scan_params[2 + shift])\\n settings[\\\"Points\\\"] = int(scan_params[3 + shift])\\n read_params = False\\n # Start reading intensities immediately afterwards\\n read_int = True\\n continue\\n fieldoff_intensities = np.array(fieldoff_intensities)\\n fieldon_intensities = np.array(fieldon_intensities)\\n\\n # Generate the frequency grid\\n settings[\\\"Frequency step\\\"] = settings[\\\"Frequency step\\\"] * settings[\\\"Multiplier\\\"]\\n # This calculates the length of either side\\n side_length = settings[\\\"Frequency step\\\"] * (settings[\\\"Points\\\"] // 2)\\n start_freq = settings[\\\"Frequency\\\"] - side_length\\n end_freq = settings[\\\"Frequency\\\"] + side_length\\n frequency = np.linspace(start_freq, end_freq, settings[\\\"Points\\\"])\\n\\n return frequency, fieldoff_intensities, fieldon_intensities, settings\",\n \"def parse_trflp(lines):\\r\\n\\r\\n sample_ids = []\\r\\n otu_ids = []\\r\\n data = []\\r\\n non_alphanum_mask = re.compile('[^\\\\w|^\\\\t]')\\r\\n # not sure why the above regex doesn't cover the following regex...\\r\\n dash_space_mask = re.compile('[_ -]')\\r\\n\\r\\n for i, line in enumerate(lines):\\r\\n elements = line.strip('\\\\n').split('\\\\t')\\r\\n\\r\\n # special handling for the first line only\\r\\n if i == 0:\\r\\n # validating if the file has a header\\r\\n if elements[0] == '':\\r\\n for otu_id in elements[1:]:\\r\\n otu_ids.append(non_alphanum_mask.sub('_', otu_id))\\r\\n continue\\r\\n else:\\r\\n for j, otu_id in enumerate(elements[1:]):\\r\\n otu_ids.append(non_alphanum_mask.sub('_', 'Bin%3d' % j))\\r\\n\\r\\n # handling of all other lines\\r\\n current_row = []\\r\\n\\r\\n # converting each value in the row to int\\r\\n for count in elements[1:]:\\r\\n try:\\r\\n current_row.append(int(round(float(count), 0)))\\r\\n except ValueError:\\r\\n current_row.append(0)\\r\\n\\r\\n # if the sum of all the values is equial to 0 ignore line\\r\\n if sum(current_row) == 0:\\r\\n continue\\r\\n\\r\\n # adding sample header to list\\r\\n sample_ids.append(non_alphanum_mask.sub('.',\\r\\n dash_space_mask.sub('.', elements[0])))\\r\\n\\r\\n # validating the size of the headers to add missing columns\\r\\n # this is only valid when there is no header\\r\\n if len(current_row) > len(otu_ids):\\r\\n # modify header data\\r\\n extra_cols = []\\r\\n for j in range(len(otu_ids), len(current_row)):\\r\\n extra_cols.append(non_alphanum_mask.sub('_', 'Bin%3d' % j))\\r\\n # modify data\\r\\n for j in range(len(data)):\\r\\n data[j].extend([0] * (len(current_row) - len(otu_ids)))\\r\\n\\r\\n otu_ids.extend(extra_cols)\\r\\n elif len(current_row) < len(otu_ids):\\r\\n # modify data\\r\\n current_row.extend([0] * (len(otu_ids) - len(current_row)))\\r\\n\\r\\n data.append(current_row)\\r\\n\\r\\n return sample_ids, otu_ids, asarray(data).transpose()\",\n \"def update_term_count_dataframes(self):\\n logging.info('Starting method that updates missing Term COUNT info on disk')\\n list_records_no_termcount_data_on_disk = self.__look__missing_termcount_info()\\n num_missing_tc_entries = len(list_records_no_termcount_data_on_disk)\\n counter = 0\\n num_vids_success = 0\\n percent_tracker = PercentTracker(num_missing_tc_entries,\\n int_output_every_x_percent=1, log_level='info')\\n logging.info(str(num_missing_tc_entries) + \\\" records don't have term-COUNT data on disk.\\\")\\n for a_vid in list_records_no_termcount_data_on_disk:\\n execution_should_continue = self.var_mgr.var_retrieve(my_globals.str_execution_may_go_on)\\n if not execution_should_continue:\\n break\\n # we'll only update the timestamp in the SimpleDS if there is an actual change\\n # to the transcript. So here, we'll keep the existing timestamp\\n timestamp_updated = self.transcripts_ds.fetch_lastupdated(a_vid)\\n logging.info('Updating term COUNT for record # ' + str(counter + 1) + ' of ' + str(num_missing_tc_entries))\\n transcript = Transcript(a_vid)\\n transcript.set_transcript_directory(self.str_path_to_transcripts_files)\\n transcript.load_transcript_object_from_dictionary(self.transcripts_ds.fetch_data(a_vid))\\n transcript.get_transcript_from_disk()\\n transcript.construct_terms_count()\\n saved_to_disk_successfully = transcript.save_df_terms_count_2disk()\\n dict_for_ds = transcript.dump_transcript_metadata_to_dictionary()\\n self.transcripts_ds.update_entry(a_vid, dict_for_ds, timestamp_updated)\\n logging.debug('Added (to SimpleDS) the term-COUNT data for entry: ' + a_vid)\\n if saved_to_disk_successfully:\\n num_vids_success += 1\\n counter += 1\\n percent_tracker.update_progress(counter, show_time_remaining_estimate=True,\\n str_description_to_include_in_logging='Updating Term Count files.')\\n logging.info(\\\"Successfully saved to disk term-count data for \\\" + str(num_vids_success) + ' records.')\\n logging.info(\\\"Records processed: \\\" + str(counter))\\n self.transcripts_ds.save2disk()\",\n \"def readFiles(self):\\n #return a list of traces\\n alltraces = []\\n for dfile in self._datafiles:\\n traces,headers = readgeonet(dfile)\\n alltraces += traces\\n return alltraces\",\n \"def parse(self, f):\\n \\n for line in f:\\n self.parse_line(line)\",\n \"def processData(inputDataPath):\\n\\n\\t### Define paths\\n\\tfileParts = inputDataPath.split('/')\\n\\tSUBJ = fileParts[-2]\\n\\tOUTPUT_dir = ('/').join(fileParts[:-1])\\n\\n\\tEXP_dir = ('/').join(fileParts[:-3])\\n\\tSTIM_dir = join(EXP_dir, 'Stimuli')\\n\\n\\t# Read raw data as dataframe\\n\\traw_df = pd.read_table(inputDataPath)\\n\\n\\t# loop through all unique trials\\n\\tfor i, trial in enumerate(np.unique(raw_df['trialNum'])):\\n\\n\\t\\t# grab trial data\\n\\t\\ttrial_df = raw_df[(raw_df.trialNum == trial)]\\n\\n\\t\\t#####################################\\n\\t\\t### Step 1: Filter Raw Data\\n\\t\\t#####################################\\n\\t\\ttrial_filtered = filt.filterRaw(trial_df)\\n\\n\\t\\t\\n\\t\\t#####################################\\n\\t\\t### Step 2: Define Fixations on filtered dataframe\\n\\t\\t#####################################\\n\\t\\ttrial_filtered = filt.defineFixations(trial_filtered)\\n\\n\\n\\t\\t#####################################\\n\\t\\t### Step 3: Summarize Each Fixation\\n\\t\\t#####################################\\n\\t\\t\\n\\t\\t# check if there's an AOI for this trial\\n\\t\\tstimName = trial_filtered.imageName.iloc[0]\\n\\t\\tAOI_name = stimName.split('/')[1][:-4] + '_AOIs.png'\\n\\t\\tAOI_path = join(STIM_dir, 'AOIs/finished_AOIs', AOI_name)\\n\\t\\tif not os.path.exists(AOI_path):\\n\\t\\t\\tAOI_path = None\\n\\n\\t\\t# summarize fixations (label AOIs, if applicable)\\n\\t\\ttrial_fixations= filt.summarizeFixations(trial_filtered, AOI_path)\\n\\n\\n\\t\\t#####################################\\n\\t\\t### Step 4: Summarize Trial Overall\\n\\t\\t#####################################\\n\\t\\ttrial_summary = filt.summarizeTrial(trial_fixations)\\n\\n\\n\\t\\t#####################################\\n\\t\\t### Store this trial's output in master dataframes\\n\\t\\t#####################################\\n\\t\\tif i == 0:\\n\\t\\t\\tallTrials_filtered = trial_filtered.copy()\\n\\t\\t\\tallTrials_fixations = trial_fixations.copy()\\n\\t\\t\\tallTrials_summaries = pd.DataFrame(trial_summary).T # convert trial_summary from series to dataframe\\n\\t\\telse:\\n\\t\\t\\tallTrials_filtered = pd.concat([allTrials_filtered, trial_filtered], ignore_index=True)\\n\\t\\t\\tallTrials_fixations = pd.concat([allTrials_fixations, trial_fixations], ignore_index=True)\\n\\t\\t\\tallTrials_summaries = pd.concat([allTrials_summaries, pd.DataFrame(trial_summary).T], ignore_index=True)\\n\\n\\n\\t### Write all output to the disk for this subject\\n\\t# filtered data\\n\\tallTrials_filtered.to_csv(join(OUTPUT_dir, (SUBJ + '_filtered.tsv')), \\n\\t\\t\\t\\t\\t\\t\\t\\tsep='\\\\t',\\n\\t\\t\\t\\t\\t\\t\\t\\theader=True,\\n\\t\\t\\t\\t\\t\\t\\t\\tindex=False,\\n\\t\\t\\t\\t\\t\\t\\t\\tfloat_format='%.3f')\\n\\t\\n\\t# fixation data\\n\\tfixColOrder = ['trialNum', 'imageName', 'crossX', 'crossY',\\n\\t\\t\\t\\t\\t'fixNumber', 'duration','fixPosX', 'fixPosY',\\n\\t\\t\\t\\t\\t'dirFromPrev', 'distFromPrev', 'distFromCenter',\\n\\t\\t\\t\\t\\t'AOI', 'horizHemi', 'vertHemi']\\n\\tallTrials_fixations[fixColOrder].to_csv(join(OUTPUT_dir, (SUBJ + '_fixations.tsv')), \\n\\t\\t\\t\\t\\t\\t\\t\\tsep='\\\\t',\\n\\t\\t\\t\\t\\t\\t\\t\\theader=True,\\n\\t\\t\\t\\t\\t\\t\\t\\tindex=False,\\n\\t\\t\\t\\t\\t\\t\\t\\tfloat_format='%.2f')\\n\\n\\t# summary data\\n\\tsummaryColOrder = ['trialNum', 'imageName', 'leftEye', 'rightEye', 'eyesCombined',\\n\\t\\t\\t\\t\\t\\t'nose', 'mouth', 'none', 'nonFixation',\\n\\t\\t\\t\\t\\t\\t'left', 'right', 'top', 'bot']\\n\\tallTrials_summaries[summaryColOrder].to_csv(join(OUTPUT_dir, (SUBJ + '_trialSummary.tsv')), \\n\\t\\t\\t\\t\\t\\t\\t\\tsep='\\\\t',\\n\\t\\t\\t\\t\\t\\t\\t\\theader=True,\\n\\t\\t\\t\\t\\t\\t\\t\\tindex=False,\\n\\t\\t\\t\\t\\t\\t\\t\\tfloat_format='%.2f')\",\n \"def perform(self):\\n if self.driver.owner != self.name:\\n self.driver.owner = self.name\\n\\n channel = self.driver.get_channel(self.trace)\\n data = channel.read_data_complete(self.highres)\\n\\n msg = 'Coupling {}, Average number {}'\\n oscillo_config = msg. format(channel.sweep, data['VERT_COUPLING'])\\n self.write_in_database('oscillo_config', oscillo_config)\\n\\n # if the TrigArray lentgh is null, it's a simple single sweep waveform\\n if data['TRIGTIME_ARRAY'][0] == 0:\\n arr = np.rec.fromarrays([data['SingleSweepTimesValuesArray'],\\n data['Volt_Value_array']],\\n names=['Time (s)', 'Voltage (V)'])\\n self.write_in_database('trace_data', arr)\\n else:\\n arr = np.rec.fromarrays([data['SEQNCEWaveformTimesValuesArray'],\\n data['Volt_Value_array']],\\n names=['Time (s)', 'Voltage (V)'])\\n self.write_in_database('trace_data', )\",\n \"def read_results(self):\\n\\n myfile = open(os.path.join(self.directory, 'results.tag'), 'r')\\n self.lines = myfile.readlines()\\n myfile.close()\\n\\n # print('atoms before read', self.atoms)\\n # print('atoms_input before read', self.atoms_input)\\n\\n self.atoms = self.atoms_input\\n\\n charges, energy, free_energy = self.read_charges_and_energy()\\n if charges is not None:\\n self.results['charges'] = charges\\n\\n self.results['energy'] = energy\\n self.results['free_energy'] = free_energy\\n\\n if self.do_forces:\\n forces = self.read_forces()\\n self.results['forces'] = forces\\n\\n self.mmpositions = None\\n\\n # stress stuff begins\\n sstring = 'stress'\\n have_stress = False\\n stress = list()\\n for iline, line in enumerate(self.lines):\\n if sstring in line:\\n have_stress = True\\n start = iline + 1\\n end = start + 3\\n for i in range(start, end):\\n cell = [float(x) for x in self.lines[i].split()]\\n stress.append(cell)\\n if have_stress:\\n stress = -np.array(stress) * Hartree / Bohr**3\\n self.results['stress'] = stress.flat[[0, 4, 8, 5, 2, 1]]\\n # stress stuff ends\\n\\n # TODO: these two seem wrong with DFTB+ master but compatible with 19.1\\n # eigenvalues and fermi levels\\n #fermi_levels = self.read_fermi_levels()\\n #if fermi_levels is not None:\\n # self.results['fermi_levels'] = fermi_levels\\n #\\n #eigenvalues = self.read_eigenvalues()\\n #if eigenvalues is not None:\\n # self.results['eigenvalues'] = eigenvalues\\n\\n # calculation was carried out with atoms written in write_input\\n os.remove(os.path.join(self.directory, 'results.tag'))\",\n \"def readOutputfile(filename, verbose=False):\\n\\n # -----------------------------------------------------------------------------\\n # Defining the classes for data structure\\n T_Simulation = namedtuple('Simulation', ['step'])\\n T_Step = namedtuple('Step', ['element', 'node'])\\n\\n T_Displacement = namedtuple('Displacement', ['ux', 'uy'])\\n\\n T_Element = namedtuple('Element', ['gp', 'avstrain', 'avstress', 'eqstrain'])\\n T_GP = namedtuple('GP', ['stress', 'strain'])\\n T_Stresses = namedtuple('Stresses', ['xx', 'yy', 'zz', 'yz', 'zx', 'xy'])\\n T_Strains = namedtuple('Strains', ['xx', 'yy', 'zz', 'yz', 'zx', 'xy'])\\n # -----------------------------------------------------------------------------\\n\\n nSteps = 0 # Simulation step counter\\n\\n SimData = T_Simulation(list())\\n\\n with open(filename) as f:\\n line = f.readline() # Read in the first line of the input file\\n while True: # Loop over all lines of the input file\\n # Read the nodes displacements\\n #line = f.readline()\\n #print(line)\\n if line == 'DofManager output:\\\\n': # String starts a list of nodes displacement information\\n nSteps += 1 # The above string starts a new simulation step\\n line = f.readline() # Cancel ---------- seperator\\n line = f.readline()\\n Nodes = list() # Initialize/clear list of nodes\\n\\n while line != '\\\\n' and line != 'Element output:\\\\n': # Strings that finish the list\\n #\\t\\t\\t\\tnNode = int(line.strip().split()[1]) # Node id\\n line = f.readline()\\n dim1 = float(line.strip().split()[3]) # Displacement dim1\\n line = f.readline()\\n dim2 = float(line.strip().split()[3]) # Displacement dim2\\n Nodes.append(\\n T_Displacement(dim1, dim2)) # Append displacements of the current node to the node list\\n line = f.readline()\\n\\n\\n if verbose:\\n print('Step {}: Dofs completed.\\\\n'.format(nSteps))\\n print('---------------------------------\\\\n')\\n\\n # Read the stresses an strains at Gauss points\\n elif line == 'Element output:\\\\n': # String starts a list elements, GPs, strains and stresses\\n line = f.readline() # Cancel ---------- seperator\\n line = f.readline()\\n Elements = list() # Initialize/clear list of elements\\n\\n while line != '\\\\n' and line != '\\\\tR E A C T I O N S O U T P U T:\\\\n': # Strings that finish the list\\n #\\t\\t\\t\\t\\tnElement = line.strip().split()[2] # Element id\\n line = f.readline()\\n GPs = T_Element(list(), 0, 0, 0) # List of Gauss points\\n\\n while line != '\\\\n' and line.strip().split()[0] == 'GP': # String that starts a new GP\\n #\\t\\t\\t\\t\\t\\tnGP = int(line.strip().split()[1].split('.')[1]) # GP id\\n tmp = [float(i) for i in line.strip().split()[4:10]] # Read the strains\\n strain = T_Strains(tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5])\\n line = f.readline()\\n tmp = [float(i) for i in line.strip().split()[1:7]] # Read the stresses\\n stress = T_Stresses(tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5])\\n GPs.gp.append(\\n T_GP(stress, strain)) # Append stresses and strains of the current GP to the GP list\\n line = f.readline()\\n\\n\\n Elements.append(GPs) # Append GP list of the current element to the element list\\n\\n if verbose:\\n print('Step {}: GPs completed.\\\\n'.format(nSteps))\\n print('---------------------------------\\\\n')\\n\\n SimData.step.append(T_Step(Elements, Nodes)) # Append element and node list of the current step to the step list\\n #print('the file input ends')\\n #print(nSteps)\\n # only needed with a while loop\\n # Jump over the lines until we reach the next time step (Caught by if-clause)\\n try:\\n line = f.readline() # Will generate an error if files end is reached\\n if line == \\\"\\\":\\n raise EOFError\\n except:\\n if verbose: print(\\\"End of file reached.\\\\n\\\")\\n break # Break the 'while True' loop\\n\\n # -----------------------------------------------------------------------------\\n\\n\\n print('averaging the stress')\\n # Averaging of strains and stress of GPs of each element\\n for istep in range(len(SimData.step)):\\n\\n for ielement in range(len(SimData.step[istep].element)):\\n print(len)\\n # Initialization before each element\\n stresses = np.array([0., 0., 0., 0., 0., 0.])\\n strains = np.array([0., 0., 0., 0., 0., 0.])\\n\\n for igp in range(len(SimData.step[istep].element[ielement])):\\n print(igp)\\n # Add up all data of all GPs\\n #stresses[:] += SimData.step[istep].element[ielement].gp[igp].stress[:]\\n strains[:] += SimData.step[istep].element[ielement].gp[igp].strain[:]\\n\\n # Divide GP sum by number of GPs\\n stresses /= len(SimData.step[istep].element[ielement])\\n strains /= len(SimData.step[istep].element[ielement])\\n # Replace the field (initialized with 0) with new information\\n SimData.step[istep].element[ielement] = SimData.step[istep].element[ielement]._replace(\\n avstress=T_Stresses(stresses[0], stresses[1], stresses[2], stresses[3], stresses[4], stresses[5]))\\n SimData.step[istep].element[ielement] = SimData.step[istep].element[ielement]._replace(\\n avstrain=T_Strains(strains[0], strains[1], strains[2], strains[3], strains[4], strains[5]))\\n print('Analysis finished')\\n return SimData\",\n \"def process_meter():\\n\\n if not os.path.isdir(out_dir):\\n os.mkdir(out_dir)\\n\\n allRhymeInfo = {}\\n\\n for filename in os.listdir(in_dir):\\n if not filename.endswith(\\\".txt\\\"):\\n continue\\n\\n fileRhymeInfo = {\\n \\\"scheme\\\": [],\\n \\\"endWords\\\": [],\\n \\\"tidied\\\": [],\\n }\\n\\n with open(in_dir + filename, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n txt = f.read()\\n\\n # Assume standard line break structure.\\n # Split on \\\"\\\\n\\\\n\\\"\\n segs = txt.split(\\\"\\\\n\\\\n\\\")\\n\\n # Print to a new file\\n with open(out_dir + filename, \\\"w\\\", encoding=\\\"utf-8\\\") as f:\\n for seg in segs:\\n scheme, rhymingWords, tidiedLines = findRhymes(seg)\\n\\n # add info to file's dictionary to be returned\\n fileRhymeInfo[\\\"segs\\\"].append(seg)\\n fileRhymeInfo[\\\"scheme\\\"].append(scheme)\\n fileRhymeInfo[\\\"endWords\\\"].append(rhymingWords)\\n fileRhymeInfo[\\\"tidied\\\"].append(tidiedLines)\\n\\n # write info out to file\\n for i, ln in enumerate(tidiedLines):\\n # First line in seg is header; no rhymes\\n if i == 0:\\n print(ln, file=f)\\n continue\\n\\n # Later lines: print original line, plus a rhyme tag\\n w = rhymingWords[i-1]\\n s = scheme[i-1]\\n\\n print(f\\\"{ln:45s} [{w:^12s}]: ({s})\\\", file=f)\\n print(file=f)\\n\\n allRhymeInfo[filename] = fileRhymeInfo\\n return allRhymeInfo\",\n \"def read_snfit_results(self, snfit_res_path='../sugar_analysis_data/results/results_snfit.txt'):\\n\\n snfit_res = open (snfit_res_path)\\n \\n self.sn_name = []\\n self.z = []\\n self.x0 =[]\\n self.x0_err = []\\n self.x1 =[]\\n self.x1_err = []\\n self.c = []\\n self.c_err = []\\n self.mb = []\\n self.mb_err = []\\n self.cov_x0_x1 = [] \\n self.cov_x0_c = []\\n self.cov_x1_c = []\\n self.cov_mb_x1 = []\\n self.cov_mb_c = []\\n self.snfit_chi2 = []\\n snfit_lines = snfit_res.readlines()\\n \\n line_name = 0\\n \\n for line in range(len(snfit_lines)):\\n \\n snfit_lines[line] = snfit_lines[line].strip()\\n snfit_lines[line] = snfit_lines[line].split(' ')\\n snfit_lines[line]=[x.replace('\\\\n','') for x in snfit_lines[line]]\\n snfit_lines[line]=[x.replace(\\\"'\\\",'') for x in snfit_lines[line]]\\n \\n if snfit_lines[line][0] == 'sn_name': \\n self.sn_name.append(snfit_lines[line][1])\\n line_name = line\\n \\n if snfit_lines[line][0] == 'Redshift' and line == line_name + 35 : \\n self.z.append(float(snfit_lines[line][1])) \\n \\n if snfit_lines[line][0] == 'X0' and line == line_name + 37: \\n self.x0.append(float(snfit_lines[line][1])) \\n self.x0_err.append(float(snfit_lines[line][2]))\\n \\n if snfit_lines[line][0] == 'X1' and line == line_name + 38 : \\n self.x1.append(float(snfit_lines[line][1])) \\n self.x1_err.append(float(snfit_lines[line][2]))\\n \\n if snfit_lines[line][0] == 'Color' and line == line_name + 36: \\n self.c.append(float(snfit_lines[line][1]))\\n self.c_err.append(float(snfit_lines[line][2]))\\n \\n if snfit_lines[line][0] == 'RestFrameMag_0_B' and line == line_name + 39 : \\n self.mb.append(float(snfit_lines[line][1])) \\n self.mb_err.append(float(snfit_lines[line][2]))\\n \\n if snfit_lines[line][0] == 'CovX0X1' and line == line_name + 52: \\n self.cov_x0_x1.append(float(snfit_lines[line][1]))\\n \\n if snfit_lines[line][0] == 'CovColorX0' and line == line_name + 43: \\n self.cov_x0_c.append(float(snfit_lines[line][1])) \\n \\n \\n if snfit_lines[line][0] == 'CovColorX1' and line == line_name + 44: \\n self.cov_x1_c.append(float(snfit_lines[line][1]))\\n \\n if snfit_lines[line][0] == 'CovColorRestFrameMag_0_B' and line == line_name + 42: \\n self.cov_mb_c.append(float(snfit_lines[line][1]))\\n \\n if snfit_lines[line][0] == 'CovRestFrameMag_0_BX1' and line == line_name + 50: \\n self.cov_mb_x1.append(float(snfit_lines[line][1])) \\n\\n if snfit_lines[line][0] == '@CHI2_LC' and line == line_name + 56: \\n self.snfit_chi2.append(float(snfit_lines[line][1])) \\n \\n self.sn_name = np.array(self.sn_name,str)\\n self.z = np.array(self.z)\\n self.x0 = np.array(self.x0)\\n self.x0_err = np.array(self.x0_err)\\n self.x1 = np.array(self.x1)\\n self.x1_err = np.array(self.x1_err) \\n self.c = np.array(self.c)\\n self.c_err = np.array(self.c_err)\\n self.mb = np.array(self.mb)\\n self.mb_err = np.array(self.mb_err)\\n self.cov_x0_x1 = np.array(self.cov_x0_x1)\\n self.cov_x0_c = np.array(self.cov_x0_c)\\n self.cov_x1_c = np.array(self.cov_x1_c)\\n self.cov_mb_x1 = np.array(self.cov_mb_x1)\\n self.cov_mb_c = np.array(self.cov_mb_c) \\n self.snfit_chi2 = np.array(self.snfit_chi2)\",\n \"def crapome_parser():\\n import os.path\\n \\n # contTreshold = 30 # set this to the desired contamination score\\n resD = {}\\n \\n # crapFile = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \\\"data\\\", \\\"cav1ko\\\", \\\"processed\\\", \\\"1503486016360_gp-1.txt\\\"),\\\"rU\\\")\\n crapFile = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \\\"data\\\", \\\"Crapome-all-proteins-ptpn22-ip-ctl.txt\\\"),\\\"rU\\\")\\n \\n headerFlag = True\\n \\n fileLength = 0\\n for inpLine in crapFile: # parse crapome output file\\n if headerFlag:\\n headerFlag = False\\n continue\\n fileLength += 1\\n lineList = inpLine.split(\\\"\\\\t\\\")\\n if lineList[2] == \\\"\\\": continue\\n elif len(lineList) > 2: contScore = int(lineList[2].split(\\\"/\\\")[0])\\n else: contScore = 0\\n \\n # if contScore < contTreshold:\\n resD[lineList[0]] = contScore\\n \\n # print \\\"Contaminant treshold: \\\" + str(contTreshold)\\n \\n print(\\\"lines parsed: \\\" + str(fileLength))\\n print(\\\"Number of results: \\\" + str(len(resD)))\\n \\n # inpFile = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \\\"data\\\", \\\"cav1ko\\\", \\\"processed\\\", \\\"cav1ko-1_no0.csv\\\"),\\\"r\\\")\\n # outF = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \\\"data\\\", \\\"cav1ko\\\", \\\"processed\\\", \\\"cav1ko-1_no0_crapome.csv\\\"),\\\"w\\\")\\n inpFile = open(os.path.join(\\\"/home/mate/workspace/katamari/src/ed/bob/processed\\\", \\\"OST-24-05-2017_combined_ttest_ed_2.csv\\\"),\\\"rU\\\")\\n outF = open(os.path.join(os.path.split(os.path.dirname(__file__))[0], \\\"data\\\", \\\"processed\\\", \\\"OST-24-05-2017_combined_ttest_ed_2_cr.csv\\\"),\\\"w\\\")\\n\\n \\n \\n headerFlag = True\\n for inpLine in inpFile: # parse the input file for crapome and add crapome results to it\\n inpList = inpLine.rstrip(\\\"\\\\n\\\").split(\\\",\\\")\\n for inpI in inpList:\\n outF.write(inpI + \\\",\\\")\\n \\n if headerFlag: \\n outF.write(\\\"Crapome score\\\")\\n headerFlag = False\\n elif inpList[2].upper() in resD: outF.write(str(resD[inpList[2].upper()]))\\n else: outF.write(\\\"0\\\")\\n \\n outF.write(\\\"\\\\n\\\")\\n print(\\\"results written to file\\\")\",\n \"def read_results(self):\\n\\n with open(os.path.join(self.directory, 'results.tag'), 'r') as fd:\\n self.lines = fd.readlines()\\n\\n self.atoms = self.atoms_input\\n self.results['energy'] = float(self.lines[1])*Hartree\\n forces = self.read_forces()\\n self.results['forces'] = forces\\n\\n # stress stuff begins\\n sstring = 'stress'\\n have_stress = False\\n stress = list()\\n for iline, line in enumerate(self.lines):\\n if sstring in line:\\n have_stress = True\\n start = iline + 1\\n end = start + 3\\n for i in range(start, end):\\n cell = [float(x) for x in self.lines[i].split()]\\n stress.append(cell)\\n if have_stress:\\n stress = -np.array(stress) * Hartree / Bohr**3\\n self.results['stress'] = stress.flat[[0, 4, 8, 5, 2, 1]]\\n # stress stuff ends\\n\\n # calculation was carried out with atoms written in write_input\\n os.remove(os.path.join(self.directory, 'results.tag'))\",\n \"def process_results(stadict,dir,ot):\\n # If the absolute value of linearity \\n ignore_linearity=0.90\\n # Process our output\\n csvfile=\\\"%s/Results.csv\\\" % (dir)\\n csv=open(csvfile,'r')\\n hl=csv.readline() # Read the header\\n for line in csv:\\n lvals=line.split(',')\\n nsl=\\\"%s-%s-%s\\\" % (lvals[0],lvals[1],lvals[2])\\n difference=float(lvals[3])-float(lvals[4])\\n linearity=np.abs(float(lvals[6]))\\n if linearity>=ignore_linearity: #Could move this to the plot section but it adds complexity if you do\\n stadict=add_azi_measurement(stadict,nsl,ot,difference,linearity)\\n return stadict\",\n \"def tracers(traceField = 'bb', hMin = 2e-3, hMax = 2e4, lMax = 500, tol = 1e-2,\\n interpolation = 'weighted', trace_sub = 1, intQ = [''], varfile = 'VAR0',\\n ti = -1, tf = -1,\\n integration = 'simple', datadir = 'data/', destination = 'tracers.dat', nproc = 1):\\n\\n # returns the tracers for the specified starting locations\\n def subTracers(q, vv, p, tracers0, iproc, hMin = 2e-3, hMax = 2e4, lMax = 500, tol = 1e-2, \\n interpolation = 'weighted', integration = 'simple', intQ = ['']):\\n \\n tracers = tracers0\\n mapping = np.zeros((tracers.shape[0], tracers.shape[1], 3))\\n \\n for ix in range(tracers.shape[0]):\\n for iy in range(tracers.shape[1]):\\n xx = tracers[ix, iy, 2:5].copy()\\n s = pc.stream(vv, p, interpolation = interpolation, integration = integration, hMin = hMin, hMax = hMax, lMax = lMax, tol = tol, xx = xx)\\n tracers[ix, iy, 2:5] = s.tracers[s.sl-1]\\n tracers[ix, iy, 5] = s.l\\n if (any(intQ == 'curlyA')):\\n for l in range(s.sl-1):\\n aaInt = pc.vecInt((s.tracers[l+1] + s.tracers[l])/2, aa, p, interpolation)\\n tracers[ix, iy, 6] += np.dot(aaInt, (s.tracers[l+1] - s.tracers[l]))\\n \\n # create the color mapping\\n if (tracers[ix, iy, 4] > grid.z[-2]):\\n if (tracers[ix, iy, 0] - tracers[ix, iy, 2]) > 0:\\n if (tracers[ix, iy, 1] - tracers[ix, iy, 3]) > 0:\\n mapping[ix, iy, :] = [0,1,0]\\n else:\\n mapping[ix, iy, :] = [1,1,0]\\n else:\\n if (tracers[ix, iy, 1] - tracers[ix, iy, 3]) > 0:\\n mapping[ix, iy, :] = [0,0,1]\\n else:\\n mapping[ix, iy, :] = [1,0,0]\\n else:\\n mapping[ix, iy, :] = [1,1,1]\\n \\n q.put((tracers, mapping, iproc))\\n \\n \\n # multi core setup\\n if (np.isscalar(nproc) == False) or (nproc%1 != 0):\\n print(\\\"error: invalid processor number\\\")\\n return -1\\n queue = mp.Queue()\\n \\n # read the data\\n # make sure to read the var files with the correct magic\\n if (traceField == 'bb'):\\n magic = 'bb'\\n if (traceField == 'jj'):\\n magic = 'jj'\\n if (traceField == 'vort'):\\n magic = 'vort'\\n \\n # convert intQ string into list\\n if (isinstance(intQ, list) == False):\\n intQ = [intQ]\\n intQ = np.array(intQ)\\n \\n grid = pc.read_grid(datadir = datadir, trim = True, quiet = True) \\n dim = pc.read_dim(datadir = datadir) \\n tol2 = tol**2\\n \\n # check if user wants a tracer time series\\n if ((ti%1 == 0) and (tf%1 == 0) and (ti >= 0) and (tf >= ti)):\\n series = True\\n n_times = tf-ti+1\\n else:\\n series = False\\n n_times = 1\\n \\n tracers = np.zeros([int(trace_sub*dim.nx), int(trace_sub*dim.ny), n_times, 6+len(intQ)])\\n mapping = np.zeros([int(trace_sub*dim.nx), int(trace_sub*dim.ny), n_times, 3])\\n t = np.zeros(n_times)\\n \\n for tIdx in range(n_times):\\n if series:\\n varfile = 'VAR' + str(tIdx)\\n \\n # read the data\\n var = pc.read_var(varfile = varfile, datadir = datadir, magic = magic, quiet = True, trimall = True) \\n grid = pc.read_grid(datadir = datadir, quiet = True, trim = True)\\n t[tIdx] = var.t\\n \\n # extract the requested vector traceField\\n vv = getattr(var, traceField)\\n if (any(intQ == 'curlyA')):\\n aa = var.aa\\n \\n # initialize the parameters\\n p = pc.pClass()\\n p.dx = var.dx; p.dy = var.dy; p.dz = var.dz\\n p.Ox = var.x[0]; p.Oy = var.y[0]; p.Oz = var.z[0]\\n p.Lx = grid.Lx; p.Ly = grid.Ly; p.Lz = grid.Lz\\n p.nx = dim.nx; p.ny = dim.ny; p.nz = dim.nz\\n \\n # initialize the tracers\\n for ix in range(int(trace_sub*dim.nx)):\\n for iy in range(int(trace_sub*dim.ny)):\\n tracers[ix, iy, tIdx, 0] = grid.x[0] + int(grid.dx/trace_sub)*ix\\n tracers[ix, iy, tIdx, 2] = tracers[ix, iy, tIdx, 0]\\n tracers[ix, iy, tIdx, 1] = grid.y[0] + int(grid.dy/trace_sub)*iy\\n tracers[ix, iy, tIdx, 3] = tracers[ix, iy, tIdx, 1]\\n tracers[ix, iy, tIdx, 4] = grid.z[0]\\n \\n # declare vectors\\n xMid = np.zeros(3)\\n xSingle = np.zeros(3)\\n xHalf = np.zeros(3)\\n xDouble = np.zeros(3)\\n \\n tmp = []\\n subTracersLambda = lambda queue, vv, p, tracers, iproc: \\\\\\n subTracers(queue, vv, p, tracers, iproc, hMin = hMin, hMax = hMax, lMax = lMax, tol = tol,\\n interpolation = interpolation, integration = integration, intQ = intQ)\\n proc = []\\n for iproc in range(nproc):\\n proc.append(mp.Process(target = subTracersLambda, args = (queue, vv, p, tracers[iproc::nproc,:,tIdx,:], iproc)))\\n for iproc in range(nproc):\\n proc[iproc].start()\\n for iproc in range(nproc):\\n tmp.append(queue.get())\\n for iproc in range(nproc):\\n proc[iproc].join()\\n for iproc in range(nproc):\\n tracers[tmp[iproc][2]::nproc,:,tIdx,:], mapping[tmp[iproc][2]::nproc,:,tIdx,:] = (tmp[iproc][0], tmp[iproc][1])\\n for iproc in range(nproc):\\n proc[iproc].terminate()\\n \\n tracers = np.copy(tracers.swapaxes(0, 3), order = 'C')\\n if (destination != ''):\\n f = open(datadir + destination, 'wb')\\n f.write(np.array(trace_sub, dtype = 'float32'))\\n # write tracers into file\\n for tIdx in range(n_times):\\n f.write(t[tIdx].astype('float32'))\\n f.write(tracers[:,:,tIdx,:].astype('float32'))\\n f.close()\\n \\n tracers = tracers.swapaxes(0, 3)\\n tracers = tracers.swapaxes(0, 1)\\n mapping = mapping.swapaxes(0, 1)\\n\\n return tracers, mapping, t\",\n \"def main():\\n # Load and parse json object from file with specific\\n file_name = \\\"./benchmark.log\\\"\\n doc = re.sub(\\\"[\\\\n|\\\\t]\\\", \\\"\\\", \\\"\\\".join(benchmark.read_text_file(file_name)))\\n json_object = json.loads(\\\"\\\".join(doc))\\n\\n intervals = json_object[\\\"intervals\\\"]\\n\\n socket_keys = benchmark.get_socket_keys(intervals)\\n\\n result = benchmark.get_result_dictionary(intervals, socket_keys)\\n\\n print_to_csv(result, socket_keys)\",\n \"def clean_trace(trace):\\n\\n df = pd.read_csv(trace, delimiter=' ', header=None)\\n \\n # Meaningful column names\\n df.columns = ['Timestamp', 'Direction', 'dummy1', 'Circuit', \\n 'dummy2', 'Stream', 'dummy3', 'Command',\\n 'dummy4', 'Length']\\n\\n # Drop unnecessary columns\\n df.drop(['dummy1', 'dummy2', 'dummy3', 'dummy4'], axis=1, inplace=True)\\n\\n # Dump trash commas and fix data types\\n df['Circuit'] = df['Circuit'].apply(lambda x: x.rstrip(',')).astype('int')\\n df['Stream'] = df['Stream'].apply(lambda x: x.rstrip(',')).astype('int')\\n df['Command'] = df['Command'].apply(lambda x: x.rstrip(','))\\n \\n # Make an elapsed time in seconds column\\n df['Elapsed Time'] = df['Timestamp'] - df['Timestamp'].iloc[0]\\n return df\",\n \"def parse(self, limit=None):\\n if limit is not None:\\n logger.info(\\\"Only parsing first %d rows of each file\\\", limit)\\n logger.info(\\\"Parsing files...\\\")\\n\\n if self.testOnly:\\n self.testMode = True\\n\\n # the following will provide us the hash-lookups\\n self._process_dbxref()\\n self._process_cvterm()\\n self._process_genotypes(limit)\\n self._process_pubs(limit)\\n # do this before environments to get the external ids\\n self._process_environment_cvterm()\\n self._process_environments()\\n self._process_organisms(limit) # must be done before features\\n self._process_organism_dbxref(limit)\\n self._process_features(limit)\\n self._process_phenotype(limit)\\n self._process_phenotype_cvterm()\\n # gets external mappings for features (genes, variants, etc)\\n self._process_feature_dbxref(limit)\\n # do this after organisms to get the right taxonomy\\n self._process_stocks(limit)\\n # figures out types of some of the features\\n self._get_derived_feature_types(limit)\\n\\n # These are the associations amongst the objects above\\n self._process_stockprop(limit)\\n self._process_pub_dbxref(limit)\\n self._process_phendesc(limit)\\n self._process_feature_genotype(limit)\\n self._process_feature_pub(limit)\\n self._process_stock_genotype(limit)\\n self._process_phenstatement(limit) # these are G2P associations\\n\\n self._process_feature_relationship(limit)\\n\\n self._process_disease_models(limit)\\n # TODO add version info from file somehow\\n # (in parser rather than during fetching)\\n\\n logger.info(\\\"Finished parsing.\\\")\\n logger.info(\\\"Loaded %d nodes\\\", len(self.graph))\\n return\",\n \"def writeStats(inDir, outFname):\\n ofh = open(outFname, \\\"w\\\")\\n ofh.write(\\\"meta\\\\tkallistoProcReads\\\\tkallistoAlnReads\\\\tkallistoEstFragLen\\\\n\\\")\\n\\n inFnames = glob.glob(join(inDir, \\\"log\\\", \\\"*.log\\\"))\\n print(\\\"Parsing %d logfiles and writing to %s\\\" % (len(inFnames), outFname))\\n for inFname in inFnames:\\n cellId = basename(inFname).split(\\\".\\\")[0].split(\\\"_\\\")[0]\\n # [quant] processed 1,836,518 reads, 636,766 reads pseudoaligned\\n # [quant] estimated average fragment length: 251.99\\n for line in open(inFname):\\n if line.startswith(\\\"[quant] processed \\\"):\\n words = line.split()\\n readCount = words[2].replace(\\\",\\\",\\\"\\\")\\n alignCount = words[4].replace(\\\",\\\",\\\"\\\")\\n if line.startswith(\\\"[quant] estimated average fragment length:\\\"):\\n fragLen = line.split()[5]\\n row = [cellId, readCount, alignCount, fragLen]\\n ofh.write(\\\"\\\\t\\\".join(row)+\\\"\\\\n\\\")\\n ofh.close()\",\n \"def emit_metrics(self):\\n parse_time = time.perf_counter() - self._parsing_start_time\\n Stats.gauge(\\\"dag_processing.total_parse_time\\\", parse_time)\\n Stats.gauge(\\\"dagbag_size\\\", sum(stat.num_dags for stat in self._file_stats.values()))\\n Stats.gauge(\\n \\\"dag_processing.import_errors\\\", sum(stat.import_errors for stat in self._file_stats.values())\\n )\",\n \"def summarize_tsvs(\\n self,\\n tsv_dir,\\n dd,\\n prefix=\\\"\\\",\\n outlier_threshold=10,\\n omit_props=[\\n \\\"project_id\\\",\\n \\\"type\\\",\\n \\\"id\\\",\\n \\\"submitter_id\\\",\\n \\\"case_submitter_id\\\",\\n \\\"case_ids\\\",\\n \\\"visit_id\\\",\\n \\\"sample_id\\\",\\n \\\"md5sum\\\",\\n \\\"file_name\\\",\\n \\\"object_id\\\",\\n \\\"series_uid\\\",\\n \\\"study_uid\\\",\\n \\\"token_record_id\\\"\\n ],\\n omit_nodes=[\\\"metaschema\\\", \\\"root\\\", \\\"program\\\", \\\"project\\\", \\\"data_release\\\"],\\n outdir=\\\".\\\",\\n bin_limit=False,\\n write_report=True,\\n report_null=True,\\n ):\\n\\n summary = {}\\n\\n report = pd.DataFrame(\\n columns=[\\n \\\"prop_id\\\",\\n \\\"project_id\\\",\\n \\\"node\\\",\\n \\\"property\\\",\\n \\\"type\\\",\\n \\\"N\\\",\\n \\\"nn\\\",\\n \\\"null\\\",\\n \\\"perc_null\\\",\\n \\\"all_null\\\",\\n \\\"min\\\",\\n \\\"max\\\",\\n \\\"median\\\",\\n \\\"mean\\\",\\n \\\"stdev\\\",\\n \\\"outliers\\\",\\n \\\"bin_number\\\",\\n \\\"bins\\\",\\n ]\\n )\\n report[\\\"all_null\\\"] = report[\\\"all_null\\\"].astype(bool)\\n\\n dir_pattern = \\\"{}*{}\\\".format(prefix, \\\"tsvs\\\")\\n project_dirs = glob.glob(\\\"{}/{}\\\".format(tsv_dir, dir_pattern))\\n\\n nn_nodes, nn_props, null_nodes, null_props, all_prop_ids = [], [], [], [], []\\n\\n msg = \\\"Summarizing TSVs in '{}':\\\\n\\\".format(tsv_dir)\\n print(\\\"\\\\n\\\\n{}\\\".format(msg))\\n\\n for project_dir in project_dirs: # project_dir=project_dirs[0]\\n\\n try:\\n project_id = re.search(\\n r\\\"^{}/?([A-Za-z0-9_-]+)_tsvs$\\\".format(tsv_dir), project_dir\\n ).group(1)\\n except:\\n print(\\n \\\"Couldn't extract the project_id from project_dir '{}'!\\\".format(\\n project_dir\\n )\\n )\\n\\n fpattern = \\\"{}*{}\\\".format(prefix, \\\".tsv\\\")\\n fnames = glob.glob(\\\"{}/{}\\\".format(project_dir, fpattern))\\n\\n # msg = \\\"\\\\t\\\\tFound the following {} TSVs: {}\\\".format(len(fnames),fnames)\\n # sys.stdout.write(\\\"\\\\r\\\" + str(msg))\\n\\n # print(fnames) # trouble-shooting\\n if len(fnames) == 0:\\n continue\\n\\n for (\\n fname\\n ) in (\\n fnames\\n ): # Each node with data in the project is in one TSV file so len(fnames) is the number of nodes in the project with data.\\n\\n # print(\\\"\\\\n\\\\t\\\\t{}\\\".format(fname)) # trouble-shooting\\n\\n node_regex = (\\n re.escape(project_id) + r\\\"_([a-zA-Z0-9_]+)\\\\.tsv$\\\"\\n ) # node = re.search(r'^([a-zA-Z0-9_]+)-([a-zA-Z0-9]+)_([a-zA-Z0-9_]+)\\\\.tsv$',fname).group(3)\\n\\n try:\\n node = re.search(node_regex, fname, re.IGNORECASE).group(1)\\n\\n except Exception as e:\\n print(\\n \\\"\\\\n\\\\nCouldn't set node with node_regex on '{}':\\\\n\\\\t{}\\\".format(\\n fname, e\\n )\\n )\\n node = fname\\n\\n df = pd.read_csv(fname, sep=\\\"\\\\t\\\", header=0, dtype=str)\\n\\n if df.empty:\\n print(\\\"\\\\t\\\\t'{}' TSV is empty. No data to summarize.\\\\n\\\".format(node))\\n\\n else:\\n nn_nodes.append(node)\\n prop_regex = re.compile(\\n r\\\"^[A-Za-z0-9_]*[^.]$\\\"\\n ) # drop the links, e.g., cases.submitter_id or diagnoses.id (matches all properties with no \\\".\\\")\\n props = list(\\n filter(prop_regex.match, list(df))\\n ) # properties in this TSV to summarize\\n props = [\\n prop for prop in props if prop not in omit_props\\n ] # omit_props=['project_id','type','id','submitter_id','case_submitter_id','case_ids','visit_id','sample_id','md5sum','file_name','object_id']\\n\\n # msg = \\\"\\\\t\\\\tTotal of {} records in '{}' TSV with {} properties.\\\".format(len(df),node,len(props))\\n # sys.stdout.write(\\\"\\\\r\\\"+str(msg))\\n\\n for prop in props: # prop=props[0]\\n\\n prop_name = \\\"{}.{}\\\".format(node, prop)\\n prop_id = \\\"{}.{}\\\".format(project_id, prop_name)\\n print(prop_name)\\n\\n # because of sheepdog bug, need to inclue \\\"None\\\" in \\\"null\\\" (:facepalm:) https://ctds-planx.atlassian.net/browse/PXP-5663\\n #df.at[df[prop] == \\\"None\\\", prop] = np.nan\\n\\n null = df.loc[df[prop].isnull()]\\n nn = df.loc[df[prop].notnull()]\\n perc_null = len(null)/len(df)\\n ptype = self.get_prop_type(node, prop, dd)\\n\\n # dict for the prop's row in report dataframe\\n prop_stats = {\\n \\\"prop_id\\\": prop_id,\\n \\\"project_id\\\": project_id,\\n \\\"node\\\": node,\\n \\\"property\\\": prop,\\n \\\"type\\\": ptype,\\n \\\"N\\\": len(df),\\n \\\"nn\\\": len(nn),\\n \\\"null\\\": len(null),\\n \\\"perc_null\\\": perc_null,\\n \\\"all_null\\\": np.nan,\\n \\\"min\\\": np.nan,\\n \\\"max\\\": np.nan,\\n \\\"median\\\": np.nan,\\n \\\"mean\\\": np.nan,\\n \\\"stdev\\\": np.nan,\\n \\\"outliers\\\": np.nan,\\n \\\"bin_number\\\": np.nan,\\n \\\"bins\\\": np.nan,\\n }\\n\\n if nn.empty:\\n null_props.append(prop_name)\\n prop_stats[\\\"all_null\\\"] = True\\n\\n else:\\n nn_props.append(prop_name)\\n all_prop_ids.append(prop_id)\\n prop_stats[\\\"all_null\\\"] = False\\n\\n msg = \\\"\\\\t'{}'\\\".format(prop_id)\\n sys.stdout.write(\\\"\\\\r\\\" + str(msg).ljust(200, \\\" \\\"))\\n\\n if ptype in [\\\"string\\\", \\\"enum\\\", \\\"array\\\", \\\"boolean\\\", \\\"date\\\"]:\\n\\n if ptype == \\\"array\\\":\\n\\n all_bins = list(nn[prop])\\n bin_list = [\\n bin_txt.split(\\\",\\\") for bin_txt in list(nn[prop])\\n ]\\n counts = Counter(\\n [\\n item\\n for sublist in bin_list\\n for item in sublist\\n ]\\n )\\n\\n elif ptype in [\\\"string\\\", \\\"enum\\\", \\\"boolean\\\", \\\"date\\\"]:\\n\\n counts = Counter(nn[prop])\\n\\n df1 = pd.DataFrame.from_dict(\\n counts, orient=\\\"index\\\"\\n ).reset_index()\\n bins = [tuple(x) for x in df1.values]\\n bins = sorted(\\n sorted(bins, key=lambda x: (x[0])),\\n key=lambda x: (x[1]),\\n reverse=True,\\n ) # sort first by name, then by value. This way, names with same value are in same order.\\n\\n prop_stats[\\\"bins\\\"] = bins\\n prop_stats[\\\"bin_number\\\"] = len(bins)\\n\\n # Get stats for numbers\\n elif ptype in [\\\"number\\\", \\\"integer\\\"]: # prop='concentration'\\n\\n # make a list of the data values as floats (converted from strings)\\n nn_all = nn[prop]\\n d_all = list(nn_all)\\n\\n nn_num = (\\n nn[prop]\\n .apply(pd.to_numeric, errors=\\\"coerce\\\")\\n .dropna()\\n )\\n d = list(nn_num)\\n\\n nn_string = nn.loc[~nn[prop].isin(list(map(str, d)))]\\n non_numbers = list(nn_string[prop])\\n\\n if (\\n len(d) > 0\\n ): # if there are numbers in the data, calculate numeric stats\\n\\n # calculate summary stats using the float list d\\n mean = statistics.mean(d)\\n median = statistics.median(d)\\n minimum = min(d)\\n maximum = max(d)\\n\\n if (\\n len(d) == 1\\n ): # if only one value, no stdev and no outliers\\n std = \\\"NA\\\"\\n outliers = []\\n else:\\n std = statistics.stdev(d)\\n # Get outliers by mean +/- outlier_threshold * stdev\\n cutoff = (\\n std * outlier_threshold\\n ) # three times the standard deviation is default\\n lower, upper = (\\n mean - cutoff,\\n mean + cutoff,\\n ) # cut-offs for outliers is 3 times the stdev below and above the mean\\n outliers = sorted(\\n list(\\n set(\\n [\\n x\\n for x in d\\n if x < lower or x > upper\\n ]\\n )\\n )\\n )\\n\\n # if property type is 'integer', change min, max, median to int type\\n if ptype == \\\"integer\\\":\\n median = int(median) # median\\n minimum = int(minimum) # min\\n maximum = int(maximum) # max\\n outliers = [\\n int(i) for i in outliers\\n ] # convert outliers from float to int\\n\\n prop_stats[\\\"stdev\\\"] = std\\n prop_stats[\\\"mean\\\"] = mean\\n prop_stats[\\\"median\\\"] = median\\n prop_stats[\\\"min\\\"] = minimum\\n prop_stats[\\\"max\\\"] = maximum\\n prop_stats[\\\"outliers\\\"] = outliers\\n\\n # check if numeric property is mixed with strings, and if so, summarize the string data\\n if len(d_all) > len(d):\\n\\n msg = \\\"\\\\t\\\\tFound {} string values among the {} records of prop '{}' with value(s): {}. Calculating stats only for the {} numeric values.\\\".format(\\n len(non_numbers),\\n len(nn),\\n prop,\\n list(set(non_numbers)),\\n len(d),\\n )\\n print(\\\"\\\\n\\\\t{}\\\\n\\\".format(msg))\\n\\n prop_stats[\\\"type\\\"] = \\\"mixed {},string\\\".format(ptype)\\n\\n counts = Counter(nn_string[prop])\\n df1 = pd.DataFrame.from_dict(\\n counts, orient=\\\"index\\\"\\n ).reset_index()\\n bins = [tuple(x) for x in df1.values]\\n bins = sorted(\\n sorted(bins, key=lambda x: (x[0])),\\n key=lambda x: (x[1]),\\n reverse=True,\\n )\\n prop_stats[\\\"bins\\\"] = bins\\n prop_stats[\\\"bin_number\\\"] = len(bins)\\n\\n else: # If its not in the list of ptypes, exit. Need to add array handling.\\n print(\\n \\\"\\\\t\\\\t\\\\n\\\\n\\\\n\\\\nUnhandled property type!\\\\n\\\\n '{}': {}\\\\n\\\\n\\\\n\\\\n\\\".format(\\n prop_id, ptype\\n )\\n )\\n exit()\\n\\n if bin_limit and isinstance(prop_stats[\\\"bins\\\"], list): # if bin_limit != False\\n prop_stats[\\\"bins\\\"] = prop_stats[\\\"bins\\\"][: int(bin_limit)]\\n\\n #report = report.append(prop_stats, ignore_index=True)\\n # print(\\\"\\\\n{}\\\\n\\\".format(report))\\n # print(\\\"\\\\n{}\\\\n\\\".format(prop_stats))\\n pdf = pd.DataFrame.from_records([prop_stats])\\n pdf['all_null'] = pdf['all_null'].astype(bool)\\n report = pd.concat([report,pdf])\\n\\n\\n if not report_null: # if report_null == False\\n report = report.loc[report[\\\"all_null\\\"] != True]\\n\\n # strip the col names so we can sort the report\\n report.columns = report.columns.str.strip()\\n report.sort_values(by=[\\\"all_null\\\", \\\"node\\\", \\\"property\\\"], inplace=True)\\n\\n summary[\\\"report\\\"] = report\\n summary[\\\"all_prop_ids\\\"] = all_prop_ids\\n\\n # summarize all properties\\n nn_props = sorted(list(set(nn_props)))\\n summary[\\\"nn_props\\\"] = nn_props\\n\\n null_props = [prop for prop in null_props if prop not in nn_props]\\n summary[\\\"null_props\\\"] = sorted(list(set(null_props)))\\n\\n # summarize all nodes\\n nn_nodes = sorted(list(set(nn_nodes)))\\n summary[\\\"nn_nodes\\\"] = nn_nodes\\n\\n dd_regex = re.compile(r\\\"[^_][A-Za-z0-9_]+\\\")\\n dd_nodes = list(filter(dd_regex.match, list(dd)))\\n dd_nodes = [node for node in dd_nodes if node not in omit_nodes]\\n null_nodes = [node for node in dd_nodes if node not in nn_nodes]\\n\\n summary[\\\"null_nodes\\\"] = null_nodes\\n\\n if write_report: # write_report == True\\n\\n self.create_output_dir(outdir=outdir)\\n\\n if \\\"/\\\" in tsv_dir:\\n names = tsv_dir.split(\\\"/\\\")\\n names = [name for name in names if name != \\\"\\\"]\\n name = names[-1]\\n else:\\n name = tsv_dir\\n\\n outname = \\\"data_summary_{}.tsv\\\".format(name)\\n outname = \\\"{}/{}\\\".format(\\n outdir, outname\\n ) # ./data_summary_prod_tsvs_04272020.tsv\\n\\n report.to_csv(outname, sep=\\\"\\\\t\\\", index=False, encoding=\\\"utf-8\\\")\\n sys.stdout.write(\\\"\\\\rReport written to file:\\\".ljust(200, \\\" \\\"))\\n print(\\\"\\\\n\\\\t{}\\\".format(outname))\\n\\n return summary\",\n \"def post_process_output_file():\\n parsed_data = []\\n unparseable_data = []\\n\\n with open('../output/part-00000', 'r') as input_file:\\n for line in input_file:\\n line = line.strip()\\n try:\\n csv_splits = line.split(',')\\n csv_splits[0] = int(csv_splits[0])\\n # parsed_data is a list of lists\\n parsed_data.append(csv_splits)\\n except ValueError:\\n unparseable_data.append(line)\\n parsed_data.sort()\\n\\n with open('../output/titanic_test_data.csv', 'w') as output_file:\\n # start with lines that couldn't be parsed\\n # hopefully this will only be the original header\\n for line in unparseable_data:\\n output_file.write(\\\"%s\\\\n\\\" % line)\\n for line in parsed_data:\\n output_file.write(\\\"%d,%s\\\\n\\\" % (line[0], line[1]))\",\n \"def parse_file(self):\\n with open(self.file_name, 'r', errors='ignore') as log_file:\\n for line in log_file:\\n self.process_line(line)\",\n \"def write(self): \\n # Open csv file\\n with open(self.file_name, 'w', newline='') as file:\\n self._writer = csv.writer(file)\\n \\n # Write header rows\\n# self.write_sim_header_data(self.trace.sim.get_data())\\n \\n # Write trace table\\n self._writer.writerow(['Record #', 'Rep', 'Time',\\n 'Priority', 'Record Type', 'Name'])\\n for trace_record in self.trace._record_list:\\n self._writer.writerow(trace_record.get_row())\\n file.close()\",\n \"def lv_analysis():\\r\\n\\r\\n global params\\r\\n n = params['n']\\r\\n lvmin = params['lvmin']\\r\\n lvmax = params['lvmax']\\r\\n lvstep = params['lvstep']\\r\\n ns = params['ns']\\r\\n nt = params['nt']\\r\\n no = params['no']\\r\\n ne = params['ne']\\r\\n nf = params['nf']\\r\\n lv_dir = create_dir(TIMES_PATH + 'lv')\\r\\n filename = datetime.datetime.now().strftime(DATE_FORMAT) + '.csv'\\r\\n with open(lv_dir + filename, 'wb') as csvfile:\\r\\n fw = csv.writer(csvfile)\\r\\n fw.writerow(('lv', 'ns', 'nt', 'no', 'ne', 'nf',\\r\\n 'method1', 'method2', 'method3_1', 'method3_2'))\\r\\n lv = lvmin\\r\\n while lv <= lvmax:\\r\\n times = [0] * 4\\r\\n for i in range(n):\\r\\n times = map(sum, zip(times, get_times(lv, ns, nt, no, ne, nf)))\\r\\n show_progress('lv', lv, lvmin, lvmax, lvstep, i, n)\\r\\n times = map(lambda x : float(x) / n, times)\\r\\n fw.writerow((lv, ns, nt, no, ne, nf) + tuple(times))\\r\\n lv += lvstep\\r\\n csvfile.close()\",\n \"def loop_nonThreaded():\\n nonlocal index, total\\n nonlocal d_tree\\n nonlocal fn_inputReadCallback\\n nonlocal fn_analysisCallback\\n nonlocal fn_outputWriteCallback\\n nonlocal dret_inputSet\\n nonlocal dret_analyze\\n nonlocal dret_outputSet\\n nonlocal str_desc\\n\\n b_analyzeStatusHist: bool = False\\n b_inputStatusHist: bool = False\\n b_outputStatusHist: bool = False\\n\\n if int(self.verbosityLevel) and self.toConsole():\\n iterator = tqdm( self.d_inputTree.items(),\\n desc = str_desc)\\n else:\\n iterator = self.d_inputTree.items()\\n\\n for path, data in iterator:\\n dret_inputSet = {}\\n dret_analyze = {}\\n dret_outputSet = {}\\n # Read (is sometimes skipped) / Analyze / Write (also sometimes skipped)\\n if fn_inputReadCallback:\\n dret_inputSet = inputSet_read(path, data)\\n try:\\n b_inputStatusHist = b_inputStatusHist or dret_inputSet['status']\\n except:\\n pass\\n if fn_analysisCallback:\\n try:\\n dret_analyze = analysis_do(path, d_tree[path], index)\\n except:\\n dret_analyze['status'] = False\\n self.dp.qprint(\\\"Analysis failed\\\", comms = 'error')\\n try:\\n b_analyzeStatusHist = b_analyzeStatusHist or dret_analyze['status']\\n except:\\n pass\\n if fn_outputWriteCallback:\\n if 'status' in dret_analyze.keys():\\n if dret_analyze['status']:\\n dret_outputSet = outputSet_write(path, d_tree[path])\\n try:\\n b_outputStatusHist = b_outputStatusHist or dret_outputSet['status']\\n except:\\n pass\\n index += 1\\n dret_inputSet['status'] = b_inputStatusHist\\n dret_analyze['status'] = b_analyzeStatusHist\\n dret_outputSet['status'] = b_outputStatusHist\\n tree_removeDeadBranches()\",\n \"def write_csv(file_name, data):\\n\\n with open(file_name, \\\"w\\\") as fp:\\n\\n writer = RiscvInstructionTraceCsv(fp)\\n writer.start_new_trace()\\n\\n for entry in data:\\n writer.write_trace_entry(entry)\",\n \"def parse(self):\\r\\n # open the file\\r\\n # try to find the first line with Time =\\r\\n # send the file to a recursive residualParser\\r\\n try:\\r\\n with open(self.filepath, 'rb') as f:\\r\\n for line in f:\\r\\n if line.startswith('Time ='):\\r\\n self.timestep = self.__getTime(line)\\r\\n self.__residuals[self.timestep] = {}\\r\\n self.__parseResiduals(f)\\r\\n except Exception as e:\\r\\n raise 'Failed to parse {}:\\\\n\\\\t{}'.format(self.filepath, e)\",\n \"def process_log(log_file):\\n result_list = []\\n file_root = get_fname_root(log_file)\\n\\n with open(log_file) as l_file:\\n reading_steps = False\\n result_dict = {}\\n for line in l_file:\\n line = line.strip()\\n if STEP_PAT.match(line):\\n reading_steps = True\\n result_dict[FILE_NAME] = file_root\\n result_dict[TIMESTEP] = int(line.split()[2])\\n elif reading_steps:\\n if len(line) == 0:\\n break\\n s_line = line.split()\\n if s_line[0] == TOTENG:\\n for key_id, key in enumerate([TOTENG, KINENG, TEMP]):\\n result_dict[key] = float(s_line[2 + key_id * 3])\\n elif s_line[0] == POTENG:\\n for key_id, key in enumerate([POTENG, E_BOND, E_ANGL]):\\n result_dict[key] = float(s_line[2 + key_id * 3])\\n elif s_line[0] == E_DIHED:\\n for key_id, key in enumerate([E_DIHED, E_IMPRO, E_VDWL]):\\n result_dict[key] = float(s_line[2 + key_id * 3])\\n elif s_line[0] == E_COUL:\\n for key_id, key in enumerate([E_COUL, E_LONG, PRESS]):\\n result_dict[key] = float(s_line[2 + key_id * 3])\\n result_list.append(dict(result_dict))\\n else:\\n # when stop matching, done reading file (either by normal or abnormal termination)\\n break\\n\\n return result_list\",\n \"def all(config_file):\\n with open(config_file) as f:\\n config = json.load(f)\\n scenes = get_realsense_scenes(config['realsense_dir'])\\n all_dfs = []\\n for scene in scenes:\\n scene_data = get_data_from_scene(scene)\\n logger.info(\\\"Evaluating - %s\\\", scene['scene_name'])\\n df = run_test_on_scene(scene_data, config)\\n all_dfs.append(df)\\n\\n df = pd.concat(all_dfs, axis=0)\\n df = df.reset_index()\\n print(df)\\n df.to_csv(config['save_csv'])\",\n \"def write_log(self):\\n with open(self.trav_stat_file, 'a') as stat_file:\\n travel_writer = csv.writer(stat_file)\\n # Every row starts with the start and destnation\\n row = [self.start, self.dest]\\n # This uses a static list so that the order is fixed\\n for state in [\\\"waiting\\\", \\\"riding\\\", \\\"transferring\\\"]:\\n state_total = sum(self.time_record[state])\\n row.append(state_total)\\n travel_writer.writerow(row)\",\n \"def update_results(self):\\n clis = []\\n aps = []\\n\\n with open(self.curr_csv) as fileo:\\n file_ = fileo.readlines()\\n file_enum = enumerate(file_)\\n num = 0\\n for num, line in file_enum:\\n line = line.replace('\\\\0', '')\\n if not line:\\n continue\\n if line.startswith('BSSID'):\\n continue\\n if line.startswith('Station'):\\n num += 1\\n break\\n aps.append(line)\\n for line in file_[num:]:\\n clis.append(line)\\n\\n def clean_rows(reader):\\n \\\"\\\"\\\"\\n Airodump-ng's csv info comes a bit unclean.\\n Strip each line of its extra blank spaces\\n \\\"\\\"\\\"\\n return [[a.strip() for a in row] for row in reader if row]\\n self._aps = clean_rows(csv.reader(StringIO('\\\\n'.join(aps))))\\n self._clients = clean_rows(csv.reader(StringIO('\\\\n'.join(clis))))\",\n \"def parseFile()-> None:\\n logging.info(f\\\"Parsing file with Pandas {getTime()}\\\")\\n with open(DATA_FILE) as f:\\n data = pd.read_csv(f)\\n db = connect(\\\"result.db\\\")\\n\\n data.to_sql(\\\"data\\\",db,if_exists=\\\"replace\\\")\\n\\n result = pd.DataFrame({\\\"Uniqe Countries\\\":[len(set(data[\\\"location\\\"]))]})\\n\\n with open(RESULT_FILE,\\\"w\\\") as f:\\n f.write(result.to_csv(index=False))\\n logging.info(f\\\"Finsied parsing {getTime()}\\\")\",\n \"def do_a_series_of_propagations(self):\\n index = 0\\n header = 'col1'\\n while index < self.rounds and self.flag:\\n index = index + 1\\n print(\\\"\\\\nLabel propagation round: \\\" + str(index)+\\\".\\\\n\\\")\\n self.do_a_propagation()\\n print(index)\\n with open ('./data/lpa.txt','w') as f:\\n for i in self.nodes:\\n f.write(str(self.labels[i])+'\\\\t')\\n f.write(str(i)+'\\\\t')\\n f.write('\\\\n')\\n \\n print(\\\"\\\")\\n print(\\\"Modularity is: \\\" + str(round(modularity( self.labels,self.graph,0.2), 40)) + \\\".\\\\n\\\")\\n json_dumper(self.labels, self.args.assignment_output)\",\n \"def Parse(filename, blockLengths):\\n global DELAY1\\n global DELAY2\\n global BLOCK \\n global TRIAL \\n global PRACTICED \\n global FIXATION_ONSET\\n global ENCODING_ONSET \\n global ENCODING_RT \\n global EXECUTION_ONSET \\n global EXECUTION_RT \\n global PROBE_ONSET \\n global PROBE_RT \\n global PROBE_ACC \\n\\n fin = open(filename, 'rU')\\n subject = filename.split('.')[0].split('-')[-1]\\n lines = fin.readlines()\\n tokens = [x.split('\\\\t') for x in lines]\\n tokens = [[y.strip() for y in x] for x in tokens]\\n colNames = tokens[0]\\n rows = tokens[1:]\\n\\n DELAY1 = colNames.index(\\\"Delay1\\\")\\n DELAY2 = colNames.index(\\\"Delay2\\\")\\n BLOCK = colNames.index(\\\"BlockNum\\\")\\n TRIAL = colNames.index(\\\"Trials\\\")\\n PRACTICED = colNames.index(\\\"Practiced\\\")\\n FIXATION_ONSET = colNames.index(\\\"Fixation1.OnsetTime\\\")\\n ENCODING_ONSET = colNames.index(\\\"Encoding.OnsetTime\\\")\\n ENCODING_RT = colNames.index(\\\"Encoding.RT\\\")\\n EXECUTION_ONSET = colNames.index(\\\"Execution.OnsetTime\\\")\\n EXECUTION_RT = colNames.index(\\\"Execution.RT\\\")\\n PROBE_ONSET = colNames.index(\\\"Probe.OnsetTime\\\")\\n PROBE_RT = colNames.index(\\\"Probe.RT\\\")\\n PROBE_ACC = colNames.index(\\\"Probe.ACC\\\")\\n\\n trials = [Trial(r) for r in rows]\\n trials = [t for t in trials if t.ok] # Excludes trials where values are missing\\n FIRST_TRIALS = []\\n previous = None\\n blockLengths=[0]+blockLengths\\n for t in trials:\\n\\n if t.block > len(blockLengths):\\n raise Exception, \\\"Not enough block lengths supplied\\\"\\n\\n t.blockOffset = 2 * reduce(add, blockLengths[0:t.block])\\n #print t.block, blockLengths[0:t.block]\\n \\n # print t.blockOffset\\n # Identify the first trials\\n if previous == None or t.block != previous.block:\\n FIRST_TRIALS.append(t)\\n previous = t \\n \\n #FIRST_TRIALS = [t for t in trials if (t.trial % 10) == 1]\\n #print FIRST_TRIALS\\n \\n for f in FIRST_TRIALS:\\n subset = [t for t in trials if t.block == f.block]\\n for s in subset:\\n s.blockBegin = f.fixationOnset - 4000\\n\\n #print [t.encodingOnset-t.blockBegin for t in trials]\\n #print trials\\n\\n BLOCKS = set(t.block for t in trials)\\n BLOCKS = list(BLOCKS)\\n BLOCKS.sort()\\n #print BLOCKS\\n\\n P = {'Yes' : 'Practiced', 'No' : 'Novel'}\\n\\n fout = open(\\\"s%s_sessions_dcm.m\\\" % subject, 'w')\\n\\n # For DCM analysis, we need a special model that contains\\n # All the trials in a particular format, and that does\\n # not distinguish between the different shoes.\\n\\n correct = [t for t in trials if t.acc == 1]\\n errors = [t for t in trials if t.acc == 0]\\n\\n nc = 5\\n\\n if len(errors) > 0:\\n for phase in ['Encoding', 'Execution', 'Probe']:\\n RTs = [e.rts[phase]/1000.0 for e in errors if e.rts[phase]>0]\\n if len(RTs) > 0:\\n nc += 1\\n \\n\\n i = 1 # counter\\n\\n fout.write(\\\"names=cell(1,%d);\\\\n\\\" % nc)\\n fout.write(\\\"onsets=cell(1,%d);\\\\n\\\" % nc)\\n fout.write(\\\"durations=cell(1,%d);\\\\n\\\" % nc)\\n\\n # Encoding and Execution, divided by Practice (Yes/No)\\n # ------------------------------------------------------------\\n \\n for phase in ['Encoding', 'Execution']: \\n for practice in [['Yes', 'No'], ['No']]:\\n appropriate = [c for c in correct if c.practiced in practice]\\n pName = \\\"\\\"\\n if len(practice) == 1:\\n pName = \\\"_Novel\\\"\\n fout.write(\\\"names{%d}='%s%s';\\\\n\\\" % (i, phase, pName))\\n onsets = \\\"%s\\\" % [a.ScanTime(a.onsets[phase]) for a in appropriate]\\n durations = \\\"%s\\\" % [a.rts[phase]/1000.0 for a in appropriate]\\n fout.write(\\\"onsets{%d}=%s;\\\\n\\\" % (i, onsets.replace(\\\";\\\", \\\"\\\")))\\n fout.write(\\\"durations{%d}=%s;\\\\n\\\" % (i, durations.replace(\\\";\\\", \\\"\\\")))\\n \\n RTs = [a.rts[phase]/1000.0 for a in appropriate]\\n meanRT = reduce(add, RTs)/len(RTs)\\n\\n i += 1\\n #print \\\"<%d>, Practiced=%s, Phase=%s, RT=%.3f\\\" % (b, practice, phase, meanRT)\\n\\n # Probes, altogether (assumes no effect of practice)\\n # ------------------------------------------------------------\\n fout.write(\\\"names{%d}='Probe';\\\\n\\\" % i)\\n onsets = \\\"%s\\\" % [c.ScanTime(c.onsets['Probe']) for c in correct]\\n durations = \\\"%s\\\" % [c.rts['Probe']/1000.0 for c in correct]\\n fout.write(\\\"onsets{%d}=%s;\\\\n\\\" % (i, onsets.replace(\\\";\\\", \\\"\\\")))\\n fout.write(\\\"durations{%d}=%s;\\\\n\\\" % (i, durations.replace(\\\";\\\", \\\"\\\")))\\n i += 1\\n\\n # Error trials\\n # ------------------------------------------------------------\\n # Note that, in the new design of the experiment, there might\\n # be encoding errors only, or encoding/execution errors only,\\n # because trials are aborted if one phase times out.\\n if len(errors) > 0:\\n for phase in ['Encoding', 'Execution', 'Probe']:\\n O = [e.ScanTime(e.onsets[phase]) for e in errors if e.onsets[phase]>0 and e.rts[phase]>0]\\n D = [e.rts[phase]/1000.0 for e in errors if e.onsets[phase]>0 and e.rts[phase]>0]\\n if len(D) > 0:\\n onsets = \\\"%s\\\" % O\\n durations = \\\"%s\\\" % D\\n fout.write(\\\"names{%d}='%s/Error';\\\\n\\\" % (i, phase))\\n fout.write(\\\"onsets{%d}=%s;\\\\n\\\" % (i, onsets.replace(\\\";\\\", \\\"\\\")))\\n fout.write(\\\"durations{%d}=%s;\\\\n\\\" % (i, durations.replace(\\\";\\\", \\\"\\\")))\\n i += 1\\n\\n fout.write(\\\"save('dcm_session.mat', 'names', 'onsets', 'durations');\\\\n\\\" % b)\\n fout.flush()\\n fout.close()\\n\\n #print blockLengths\\n rout = open(\\\"s%s_session_regressors.txt\\\" % subject, 'w')\\n for i in range(len(blockLengths[1:])):\\n for j in range(blockLengths[i+1]):\\n for s in range(len(blockLengths[1:])-1): # Do not print a column for last block\\n if s == i:\\n rout.write(\\\"1 \\\")\\n else:\\n rout.write(\\\"0 \\\")\\n rout.write(\\\"\\\\n\\\")\\n rout.flush()\\n rout.close()\",\n \"def read_statistics(self):\\n self.psdata=[]\\n self.powerspectra=[]\\n self.ds=[]\\n self.dsigmasq=[]\\n self.dsigma=[]\\n self.bsdata=[]\\n self.eqbispectra=[]\\n self.fNLeq=[]\\n\\n for sub in range(self.Nsubs):\\n self.psdata.append(np.load(self.datadir+self.filebase+\\\"_\\\"+str(sub)+\\\".npy\\\"))\\n self.powerspectra.append(np.trim_zeros(self.psdata[-1][0][1:]))\\n self.bsdata.append(np.load(self.datadir+self.fbbispec+\\\"_\\\"+str(sub)+\\\".npy\\\"))\\n self.eqbispectra.append(self.bsdata[-1][0][1:len(self.powerspectra[-1])])\\n\\n self.ds.append(np.load(self.datadir+\\\"stat_\\\"+str(sub)+\\\".npy\\\")[0])\\n self.dsigmasq.append(np.load(self.datadir+\\\"stat_\\\"+str(sub)+\\\".npy\\\")[1])\\n self.dsigma = np.array([np.sqrt(dsq) for dsq in self.dsigmasq])\\n\\n self.klist=np.arange(1, len(self.powerspectra[-1]))*(2.*np.pi/self.Lsub)\\n # subtract the mean ds\\n self.ds = self.ds - np.mean(self.ds)\\n self.fNLeq=np.mean(self.eqbispectra, axis=0)\\n self.fNLeqsubs=np.mean(self.eqbispectra, axis=1)\\n self.fNLeqds=[]\\n for i in range(len(self.eqbispectra)):\\n self.fNLeqds.append(np.array([self.ds[i]*self.eqbispectra[i][j] for j in range(45)]))\",\n \"def main(config_path):\\n logging.info(\\\"Loading raw data files. This may take a few minutes.\\\")\\n config = yaml.load(config_path, yaml.SafeLoader)\\n min_year = config[\\\"min_year\\\"]\\n max_year = config[\\\"max_year\\\"]\\n\\n # The Eviction Lab data came in two files (2014-2016 and 2017-2018) with different formats, so\\n # we need to read them in separately and merge them later.\\n eviction_df = load_evictions_data(\\n config[\\\"eviction_data_path\\\"],\\n \\\"EXECUTED_DATE\\\",\\n min_year,\\n max_year,\\n create_geoid = True\\n )\\n census_df = load_census_data(config[\\\"acs_data_path\\\"])\\n\\n # Generate the time series data and save output\\n logging.info(\\\"Generating time series data (monthly counts of housing loss events).\\\")\\n\\n # Calculating eviction totals separately because number of evictions does not always equal number of rows in the df\\n evictions_monthly = aggregate_evictions_using_rate_estimates(\\n eviction_df,\\n config[\\\"path_to_eviction_filing_rates\\\"],\\n estimate_var = \\\"filings\\\",\\n time_group = \\\"month\\\"\\n )\\n evictions_monthly = evictions_monthly[[\\\"eviction-filings\\\", \\\"month\\\"]].groupby(\\\"month\\\").sum().reset_index()\\n\\n\\n # Creating timeseries df and merging on separate eviction counts\\n timeseries_df = generate_time_series_df(eviction_df)\\n timeseries_df = timeseries_df.merge(evictions_monthly, how=\\\"outer\\\")\\n timeseries_df.drop_duplicates().to_csv(\\n config[\\\"timeseries_output_csv_path\\\"], index=False\\n )\\n logging.info(\\n \\\"Output timeseries CSV saved to %s.\\\" % config[\\\"timeseries_output_csv_path\\\"]\\n )\\n\\n # Process evictions data--get totals/rates across the analysis period & totals/rates\\n # by year\\n eviction_df = aggregate_evictions_using_rate_estimates(\\n eviction_df,\\n config[\\\"path_to_eviction_filing_rates\\\"],\\n estimate_var = \\\"filings\\\",\\n time_group = \\\"year\\\"\\n )\\n eviction_years_df = create_year_cols_from_df(\\n eviction_df,\\n [\\\"evictions\\\", \\\"eviction-filings\\\", \\\"eviction-rate\\\"], # \\\"eviction-filing-rate\\\"\\n {\\\"evictions\\\": \\\"total-evictions\\\"},\\n \\\"year\\\",\\n \\\"GEOID\\\",\\n )\\n\\n eviction_totals = get_totals_across_years(eviction_df, \\\"GEOID\\\", \\\"evictions\\\").rename(\\n columns={\\\"sum\\\": \\\"total-evictions\\\", \\\"mean\\\": \\\"avg-evictions\\\"}\\n )\\n eviction_filing_totals = get_totals_across_years(\\n eviction_df, \\\"GEOID\\\", \\\"eviction-filings\\\",\\n ).rename(columns={\\\"sum\\\": \\\"total-eviction-filings\\\", \\\"mean\\\": \\\"avg-eviction-filings\\\"})\\n\\n\\n # Join evictions, mortgage, tax, and ACS data together into a single dataframe\\n merged = (\\n census_df\\n .merge(eviction_totals, on=\\\"GEOID\\\", how=\\\"left\\\")\\n .merge(eviction_df[[\\\"GEOID\\\"]].dropna().drop_duplicates(),on=\\\"GEOID\\\",how=\\\"left\\\",)\\n .merge(eviction_years_df, on=\\\"GEOID\\\", how=\\\"left\\\")\\n )\\n\\n merged[\\\"overall-city-eviction-rate\\\"] = ((np.sum(merged[\\\"avg-evictions\\\"][np.isfinite(merged[\\\"avg-evictions\\\"])]))/sum(merged[\\\"total-renter-occupied-households\\\"]))*100\\n\\n merged[\\\"avg-eviction-rate\\\"] = (\\n merged[\\\"avg-evictions\\\"] / merged[\\\"total-renter-occupied-households\\\"]\\n ) * 100\\n\\n merged[\\\"ratio-to-mean-eviction-rate\\\"] = (\\n merged[\\\"avg-eviction-rate\\\"] / merged[\\\"overall-city-eviction-rate\\\"]\\n )\\n\\n # Add geographic identifier columns\\n merged = merged.rename(columns={\\\"GEOID\\\": \\\"census_tract_GEOID\\\"})\\n merged[\\\"county_GEOID\\\"] = merged[\\\"census_tract_GEOID\\\"].apply(lambda x: x[:5])\\n merged.loc[merged[\\\"county_GEOID\\\"] == \\\"36005\\\", \\\"county\\\"] = \\\"Bronx\\\"\\n merged.loc[merged[\\\"county_GEOID\\\"] == \\\"36047\\\", \\\"county\\\"] = \\\"Brooklyn\\\"\\n merged.loc[merged[\\\"county_GEOID\\\"] == \\\"36061\\\", \\\"county\\\"] = \\\"Manhattan\\\"\\n merged.loc[merged[\\\"county_GEOID\\\"] == \\\"36081\\\", \\\"county\\\"] = \\\"Queens\\\"\\n merged.loc[merged[\\\"county_GEOID\\\"] == \\\"36085\\\", \\\"county\\\"] = \\\"Staten Island\\\"\\n merged[\\\"state\\\"] = \\\"New York\\\"\\n\\n\\n # Write main output file to CSV\\n merged.drop_duplicates().to_csv(config[\\\"output_csv_path\\\"], index=False)\\n logging.info(\\\"Output CSV saved to %s.\\\" % config[\\\"output_csv_path\\\"])\",\n \"def run(file_name, first_year, last_year):\\r\\n\\twith open(file_name) as file:\\r\\n\\t\\treader = csv.DictReader(file)\\r\\n\\r\\n\\t\\t#Counts amount of reports per state.\\r\\n\\t\\t#counter = sc.ReportCounter()\\r\\n\\r\\n\\t\\t#Allows the csv to be iterable more than once.\\r\\n\\t\\trows = list(reader)\\r\\n\\r\\n\\t\\tlats, lons = [], []\\r\\n\\t\\tfor year in range(first_year, last_year+1):\\r\\n\\t\\t\\tfor row in rows:\\r\\n\\t\\t\\t\\t#counter.update_count(row['state'])\\r\\n\\t\\t\\t\\tif row['year'] == str(year):\\r\\n\\t\\t\\t\\t\\tlatitude, longitude = get_lat_and_long(row)\\r\\n\\t\\t\\t\\t\\tlats.append(float(latitude))\\r\\n\\t\\t\\t\\t\\tlons.append(float(longitude))\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tplot(lats, lons, year)\",\n \"def main():\\n parser = argparse.ArgumentParser(description='Process input file and save to output file.')\\n\\n parser.add_argument('-i',\\n '--input',\\n help='Trip report file (txt file) to process.',\\n action='store')\\n\\n parser.add_argument('-o',\\n '--output',\\n help='Output file (json).',\\n action='store')\\n\\n if len(sys.argv) == 1:\\n parser.print_help()\\n sys.exit(1)\\n\\n args = parser.parse_args()\\n\\n if not args.input:\\n print('Please specify the trip report input text file.')\\n sys.exit(1)\\n\\n if args.output:\\n output_file = args.output\\n else:\\n output_file = OUTPUT_DEFAULT\\n print(f'No output file specified. Using the default: {OUTPUT_DEFAULT}')\\n\\n trip_list = [] # the list of trips(dictionaries) to output to the data file\\n trip_started = False\\n day_started = False\\n\\n with open(args.input, 'r') as fh:\\n\\n while True:\\n\\n line = fh.readline()\\n\\n if not line:\\n break\\n\\n if line.isspace():\\n continue\\n\\n if '________' in line:\\n continue\\n\\n if line.startswith('TRIP'): # detect start of a trip (anywhere from 1-5 days long)\\n # print('Start trip' + line)\\n\\n trip = Parser.trip_parser(line) # create a trip(dictionary)\\n trip['days'] = [] # adds a day list (a list of sectors(dictionaries)) to the trip list\\n\\n trip_started = True # sets trip started to true\\n continue\\n\\n # if new day has not started, create a new day\\n if trip_started and not day_started and Parser.new_day(line):\\n day = {'sign_on': line[43:48], 'day_sectors': []}\\n day_started = True # sets day started to true\\n\\n if trip_started and day_started:\\n if not Parser.end_day(line):\\n # print('During day: ' + line)\\n day['day_number'] = line[24:26].strip() # assign a day number to that day\\n\\n if Parser.in_sector(line): # check if a sector has started\\n day['day_sectors'].append(Parser.sector_parser(line)) # append sector to day\\n\\n else:\\n day['sign_off'] = line[53:58].strip() # get sign off time from line\\n day['flight_duty_period'] = line[71:76].strip() # get flight duty period\\n flight_duty_split = day['flight_duty_period'].split('h') # split flight duty period on 'h'\\n day['flight_duty_period_hours'] = int(flight_duty_split[0]) # convert to hours\\n day['flight_duty_period_minutes'] = int(flight_duty_split[1]) # convert to minutes\\n\\n day_started = False # sets day started to false\\n\\n if not day_started:\\n if 'Sign_off' in line: # indicated the day is finished and its only a single day trip\\n day['lay_over'] = '0h00' # hard coded 0h00 layover as this is return flight from home base\\n day['lay_over_hours'] = 0 # hard coded 0 hours\\n day['lay_over_minutes'] = 0 # hard coded 0 minutes\\n\\n # order the day using an OrderedDict, before adding it to the trip dict\\n day_ordered = Parser.order_day(day)\\n trip['days'].append(day_ordered)\\n\\n elif '--------------------------------' in line: # the day is over and now layover\\n lay_over = line[88:93].strip() # get layover from line\\n day['lay_over'] = lay_over # add to day dictionary\\n day['lay_over_hours'] = Parser.layover_split(lay_over)[0] # split and convert to int\\n day['lay_over_minutes'] = Parser.layover_split(lay_over)[1] # split and convert to int\\n\\n # order the day using an OrderedDict, before adding it to the trip dict\\n day_ordered = Parser.order_day(day)\\n trip['days'].append(day_ordered)\\n\\n if not line[28:36].isspace() and line[27:35] == 'Sign_off': # detect end of a trip\\n trip_started = False # set trip started to False\\n\\n trip_list.append(trip) # append the trip(dictionary) to the trip list\\n\\n with open(output_file, 'w') as fh: # Convert everything (including datetime object) to string\\n fh.write(json.dumps(trip_list, default=str, indent=4)) # write to json file for output\\n\\n Display.display_data(output_file) # display analytics data within the terminal\\n\\n return output_file\",\n \"def _read_log(self):\\n\\n line_regex = compile(r\\\"\\\\[I\\\\]\\\\s*\\\\(\\\\d+ms\\\\)[^\\\\d]+(?P<counter>\\\\d+)\\\"\\n r\\\"[^\\\\d]+(?P<timestamp>\\\\d+(\\\\.\\\\d+)?)[^\\\\d]+\\\"\\n r\\\"(?P<acceleration>\\\\d+);\\\")\\n values = []\\n with open(self.filepath) as file:\\n for line in file:\\n match = line_regex.match(line)\\n if match:\\n values.append({\\n 'counter':\\n int(match['counter']),\\n 'timestamp':\\n int(float(match['timestamp']) * 1000),\\n 'acceleration':\\n int(match['acceleration'])\\n })\\n\\n self.values = values\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5701113","0.5631786","0.5608315","0.55364835","0.54893756","0.5474661","0.5458289","0.54296297","0.54242486","0.5418956","0.5402291","0.5402081","0.53681874","0.53458184","0.5335917","0.53273916","0.53256774","0.5292377","0.5272078","0.52447605","0.5243715","0.5230438","0.5226937","0.5205854","0.520284","0.5196248","0.5187156","0.51606536","0.5147545","0.51475257","0.513859","0.5137577","0.51262546","0.5120211","0.5117179","0.51152813","0.5090145","0.5089757","0.5085187","0.5084248","0.50617725","0.50562316","0.5047235","0.5045858","0.50445586","0.50425994","0.5032958","0.5025375","0.5018115","0.5008679","0.5006444","0.49975994","0.49973577","0.4974597","0.49732763","0.4964352","0.495874","0.49536207","0.4931007","0.49264702","0.49235973","0.4914851","0.49133348","0.49106124","0.49018294","0.49002144","0.48972657","0.48963326","0.4895052","0.48919672","0.48887235","0.48881784","0.48874184","0.4886134","0.48847795","0.48806375","0.48789254","0.48732784","0.48676232","0.4865611","0.4864459","0.48599806","0.48592576","0.48486632","0.4845971","0.48452222","0.4843112","0.48417965","0.48405796","0.48404533","0.48334396","0.48329037","0.48232287","0.48208302","0.48206636","0.48197278","0.48181397","0.48177826","0.48163068","0.48159248"],"string":"[\n \"0.5701113\",\n \"0.5631786\",\n \"0.5608315\",\n \"0.55364835\",\n \"0.54893756\",\n \"0.5474661\",\n \"0.5458289\",\n \"0.54296297\",\n \"0.54242486\",\n \"0.5418956\",\n \"0.5402291\",\n \"0.5402081\",\n \"0.53681874\",\n \"0.53458184\",\n \"0.5335917\",\n \"0.53273916\",\n \"0.53256774\",\n \"0.5292377\",\n \"0.5272078\",\n \"0.52447605\",\n \"0.5243715\",\n \"0.5230438\",\n \"0.5226937\",\n \"0.5205854\",\n \"0.520284\",\n \"0.5196248\",\n \"0.5187156\",\n \"0.51606536\",\n \"0.5147545\",\n \"0.51475257\",\n \"0.513859\",\n \"0.5137577\",\n \"0.51262546\",\n \"0.5120211\",\n \"0.5117179\",\n \"0.51152813\",\n \"0.5090145\",\n \"0.5089757\",\n \"0.5085187\",\n \"0.5084248\",\n \"0.50617725\",\n \"0.50562316\",\n \"0.5047235\",\n \"0.5045858\",\n \"0.50445586\",\n \"0.50425994\",\n \"0.5032958\",\n \"0.5025375\",\n \"0.5018115\",\n \"0.5008679\",\n \"0.5006444\",\n \"0.49975994\",\n \"0.49973577\",\n \"0.4974597\",\n \"0.49732763\",\n \"0.4964352\",\n \"0.495874\",\n \"0.49536207\",\n \"0.4931007\",\n \"0.49264702\",\n \"0.49235973\",\n \"0.4914851\",\n \"0.49133348\",\n \"0.49106124\",\n \"0.49018294\",\n \"0.49002144\",\n \"0.48972657\",\n \"0.48963326\",\n \"0.4895052\",\n \"0.48919672\",\n \"0.48887235\",\n \"0.48881784\",\n \"0.48874184\",\n \"0.4886134\",\n \"0.48847795\",\n \"0.48806375\",\n \"0.48789254\",\n \"0.48732784\",\n \"0.48676232\",\n \"0.4865611\",\n \"0.4864459\",\n \"0.48599806\",\n \"0.48592576\",\n \"0.48486632\",\n \"0.4845971\",\n \"0.48452222\",\n \"0.4843112\",\n \"0.48417965\",\n \"0.48405796\",\n \"0.48404533\",\n \"0.48334396\",\n \"0.48329037\",\n \"0.48232287\",\n \"0.48208302\",\n \"0.48206636\",\n \"0.48197278\",\n \"0.48181397\",\n \"0.48177826\",\n \"0.48163068\",\n \"0.48159248\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6252766"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84789,"cells":{"query":{"kind":"string","value":"Store state, cpu_id for each timestamp from trace.txt and flush all the values for next iterations."},"document":{"kind":"string","value":"def flush_parse_initialize(self):\n self.current_cluster = 0\n self.current_frequency_of_clusters = []\n self.timestamp = []\n self.currentstates_of_clusters = []\n self.state_time_map = {}\n self.cpuid_time_map = {}\n self.cpu_freq_time_spent = {}\n self.cpuids_of_clusters = []\n self.parse() # Parse trace.txt generated from trace-cmd instrumentation\n # Initialize the states of each core of clusters and frequency of\n # each clusters with its minimum freq\n # cpu_id is assigned for each of clusters.\n # For IKS devices cpuid remains same in other clusters\n # and for other it will increment by 1\n count = 0\n for cluster, cores_number in enumerate(self.numberofcores_in_cluster):\n self.currentstates_of_clusters.append([-1 for dummy in range(cores_number)])\n self.current_frequency_of_clusters.append(self.minimum_frequency_cluster[cluster])\n if self.device.scheduler == 'iks':\n self.cpuids_of_clusters.append([j for j in range(cores_number)])\n else:\n self.cpuids_of_clusters.append(range(count, count + cores_number))\n count += cores_number\n\n # Initialize the time spent in each state/frequency for each core.\n for i in range(self.device.number_of_cores * self.multiply_factor):\n self.cpu_freq_time_spent[\"cpu{}\".format(i)] = {}\n for j in self.unique_freq():\n self.cpu_freq_time_spent[\"cpu{}\".format(i)][j] = 0\n # To determine offline -1 state is added\n offline_value = -1\n self.cpu_freq_time_spent[\"cpu{}\".format(i)][offline_value] = 0\n if 0 not in self.unique_freq():\n self.cpu_freq_time_spent[\"cpu{}\".format(i)][0] = 0"},"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 record_trace(self):\n\n tfname = str(int(time.time())) + \".obd2_reader.trace\"\n self.tf_out = open(tfname, 'a')\n self.RecordTrace = 1\n print \"Recoding trace to:\", tfname","def update_records(self):\n impl.get_runtime().sync()\n self.clear_frontend()\n self._traced_records = impl.get_runtime(\n ).prog.get_kernel_profiler_records()","def process_spike_sim_log(spike_log, csv):\n logging.info(\"Processing spike log : %s\" % spike_log)\n instr_cnt = 0\n spike_instr = \"\"\n\n RD_RE = re.compile(r\"(?P<pri>\\d) 0x(?P<addr>[a-f0-9]+?) \" \\\n \"\\((?P<bin>.*?)\\) x\\s*(?P<reg>\\d*?) 0x(?P<val>[a-f0-9]+)\")\n CORE_RE = re.compile(r\"core.*0x(?P<addr>[a-f0-9]+?) \\(0x(?P<bin>.*?)\\) (?P<instr>.*?)$\")\n INSTR_RE = re.compile(r\"(?P<instr>[a-z\\.]+?)(\\s+?)(?P<operand>.*)\")\n GPR_RE = re.compile(r\"^[a-z][0-9a-z]$\")\n CSR_RE = re.compile(r\"csr\")\n ILLE_RE = re.compile(r\"trap_illegal_instruction\")\n\n # Remove all the init spike boot instructions\n cmd = (\"sed -i '/core.*0x0000000000001010/,$!d' %s\" % spike_log)\n os.system(cmd)\n # Remove all instructions after ecall (end of program excecution)\n cmd = (\"sed -i '/ecall/q' %s\" % spike_log)\n os.system(cmd)\n\n gpr = {}\n gpr[\"zero\"] = 0\n\n with open(spike_log, \"r\") as f, open(csv, \"w\") as csv_fd:\n trace_csv = RiscvInstructiontTraceCsv(csv_fd)\n trace_csv.start_new_trace()\n for line in f:\n # Extract instruction infromation\n m = CORE_RE.search(line)\n if m:\n spike_instr = m.group(\"instr\")\n rv_instr_trace = RiscvInstructiontTraceEntry()\n rv_instr_trace.instr_str = spike_instr\n rv_instr_trace.addr = m.group(\"addr\")\n rv_instr_trace.binary = m.group(\"bin\")\n if spike_instr == \"wfi\":\n trace_csv.write_trace_entry(rv_instr_trace)\n continue\n nextline = f.readline()\n if nextline != \"\":\n if ILLE_RE.search(nextline):\n continue\n m = RD_RE.search(nextline)\n if m:\n # Extract RD information\n instr_cnt += 1\n rv_instr_trace.rd = gpr_to_abi(\"x%0s\" % m.group(\"reg\"))\n rv_instr_trace.rd_val = m.group(\"val\")\n rv_instr_trace.privileged_mode = m.group(\"pri\")\n gpr[rv_instr_trace.rd] = rv_instr_trace.rd_val\n s = INSTR_RE.search(spike_instr)\n if s:\n rv_instr_trace.instr = s.group(\"instr\")\n operand_str = s.group(\"operand\").replace(\" \", \"\")\n if operand_str != \"\" :\n operands = operand_str.split(\",\")\n if CSR_RE.search(s.group(\"instr\")):\n # CSR instruction\n operand = operands[-1]\n if GPR_RE.search(operand) or operand == \"zero\":\n rv_instr_trace.rs1 = operand\n rv_instr_trace.rs1_val = gpr[operand]\n else:\n rv_instr_trace.imm = operand\n else:\n # Non CSR instruction\n for i in range(1, len(operands)):\n operand = operands[i]\n if GPR_RE.search(operand) or operand == \"zero\":\n if i == 1:\n rv_instr_trace.rs1 = operand\n rv_instr_trace.rs1_val = gpr[operand]\n else:\n rv_instr_trace.rs2 = operands[i]\n rv_instr_trace.rs2_val = gpr[operand]\n else:\n rv_instr_trace.imm = operand\n trace_csv.write_trace_entry(rv_instr_trace)\n logging.info(\"Processed instruction count : %d\" % instr_cnt)","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n #self.fl,\n #self.ie,\n self.read_from_memory(self.pc),\n self.read_from_memory(self.pc + 1),\n self.read_from_memory(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.register[i], end='')\n\n print()","def parsetemp(dirname, name, time, computer):\n with open(dirname+\"/\"+name) as f:\n lines = f.read().split(\"\\n\")\n\n if len(lines) < 11:\n return\n\n cpu = float(lines[9].split()[2])\n mb = float(lines[10].split()[2])\n\n state = libcomputer.TState(time, cpu, mb)\n computer.tstates.append(state)","def get_raw_data(trace: Trace, cmdl_args):\n # Retrieves states dataframe with the intresting columns\n df_state = trace.df_state[[STATE_COLS.APP.value, STATE_COLS.TASK.value, STATE_COLS.THREAD.value, STATE_COLS.START.value,\n STATE_COLS.END.value, STATE_COLS.VAL.value]]\n\n # Computes the elapse times of each state\n df_state['el_time'] = df_state[STATE_COLS.END.value] - df_state[STATE_COLS.START.value]\n\n # Removes start and end columns from rows cause we don't need them. Load the data into memory.\n df_state = df_state.drop(columns=[STATE_COLS.START.value, STATE_COLS.END.value]).compute()\n\n # Computes runtime (in us)\n runtime = df_state.groupby([STATE_COLS.APP.value, STATE_COLS.TASK.value, STATE_COLS.THREAD.value])['el_time'].sum().max() / 1000\n # Filters rows by useful and groups dataframe by process\n df_state_useful_grouped = df_state.loc[df_state[STATE_COLS.VAL.value] == STATE_VALUES.RUNNING.value].groupby([STATE_COLS.APP.value, STATE_COLS.TASK.value, STATE_COLS.THREAD.value])\n # Computes useful average time (in us)\n useful_av = df_state_useful_grouped['el_time'].sum().mean() / 1000\n # Computes useful max time (in us)\n useful_max = df_state_useful_grouped['el_time'].sum().max() / 1000\n # Computes useful tot time (in us)\n useful_tot = df_state_useful_grouped['el_time'].sum().sum() / 1000\n\n # Dimemas simulation for ideal times\n if cmdl_args.dimemas:\n runtime_id, useful_id = get_ideal_data(trace.metadata.path, len(trace.metadata.cpu_list))\n else:\n runtime_id = float('NaN')\n useful_id = float('NaN')\n\n\n # Loads only meaningful columns from df_states and filters useful rows\n df_state_useful = trace.df_state[[STATE_COLS.APP.value, STATE_COLS.TASK.value, STATE_COLS.THREAD.value, STATE_COLS.END.value, STATE_COLS.VAL.value]]\n df_state_useful = df_state_useful.loc[df_state_useful[STATE_COLS.VAL.value] == STATE_VALUES.RUNNING.value].drop(columns=STATE_COLS.VAL.value).compute()\n\n # Loads only meaningful columns from df_events\n df_event = trace.df_event[[EVENT_COLS.APP.value, EVENT_COLS.TASK.value, EVENT_COLS.THREAD.value, EVENT_COLS.TIME.value,\n EVENT_COLS.EVTYPE.value, EVENT_COLS.EVVAL.value]]\n\n # Filters for PAPI_TOT_INS and set as index the process identifier\n df_event_ins = df_event.loc[df_event[EVENT_COLS.EVTYPE.value] == EVENT_VALUES.PAPI_TOT_INS.value].drop(columns=EVENT_COLS.EVTYPE.value).compute().set_index([EVENT_COLS.APP.value, EVENT_COLS.TASK.value, EVENT_COLS.THREAD.value])\n\n # Gets total useful instructions by grouping and applying a custom filtering function\n useful_ins = df_event_ins.groupby([EVENT_COLS.APP.value,EVENT_COLS.TASK.value, EVENT_COLS.THREAD.value]).apply(is_useful, useful_states=df_state_useful)[EVENT_COLS.EVVAL.value].sum()\n\n # Filter for PAPI_TOT_CYC and set as indexes the process identifier\n df_event_cyc = df_event.loc[df_event[EVENT_COLS.EVTYPE.value] == EVENT_VALUES.PAPI_TOT_CYC.value].drop(columns=EVENT_COLS.EVTYPE.value).compute().set_index([EVENT_COLS.APP.value, EVENT_COLS.TASK.value, EVENT_COLS.THREAD.value])\n\n # Gets total useful cycles by grouping and applying a custom filtering function\n useful_cyc= df_event_cyc.groupby([EVENT_COLS.APP.value,EVENT_COLS.TASK.value, EVENT_COLS.THREAD.value]).apply(is_useful, useful_states=df_state_useful)[EVENT_COLS.EVVAL.value].sum()\n\n # Computes average IPC\n try:\n ipc = useful_ins / useful_cyc\n except ValueError:\n ipc = float('NaN')\n # Computes average frequency\n try:\n freq = useful_cyc / useful_tot / 1000\n except ValueError:\n freq = float('NaN')\n\n return ipc, freq, runtime, runtime_id, useful_av, useful_max, useful_tot, useful_id, useful_ins, useful_cyc","def trace_context(n):\n # Drop the first four lines: the clock speed, the threshold, and the first\n # active/inactive pair.\n for line in runcmd([TRACE, n]).splitlines()[2:]:\n if len(line.strip()) is 0:\n continue\n m = re.search(r'^PID: (\\d+).*start at (\\d+).*\\(([\\d\\.]+) ms\\)', line)\n if not m:\n print line\n yield (int(m.group(1)), int(m.group(2)), float(m.group(3)))","def exec_time_processor(self):\n with open(join(self.logs_dir, \"clock_time.dat\"), 'w') as fh:\n fh.write(\"Time ExecutionTime ClockTime\\n\")\n while True:\n rexp = (yield)\n fh.write(self.time_str + \"\\t\" +\n \"\\t\".join(x for x in rexp.groups()) + \"\\n\")\n self._tick = True","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n #self.fl,\n #self.ie,\n self.memory_read(self.pc),\n self.memory_read(self.pc + 1),\n self.memory_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.registers[i], end='')\n\n print()","def inner():\n for line in file_obj:\n logdata = tilak_haproxylog.parse_line(line)\n if logdata is not None:\n logdata[\"hits\"] = 1\n for value_key in value_keynames:\n if value_key not in logdata:\n logdata[value_key] = 0\n status_code = int(logdata[\"status_code\"])\n if 100 <= status_code <= 199:\n logdata[\"rsp_1xx\"] = 1\n elif 200 <= status_code <= 299:\n logdata[\"rsp_2xx\"] = 1\n elif 300 <= status_code <= 399:\n logdata[\"rsp_3xx\"] = 1\n elif 400 <= status_code <= 499:\n logdata[\"rsp_4xx\"] = 1\n elif 500 <= status_code <= 599:\n logdata[\"rsp_5xx\"] = 1\n else:\n logdata[\"rsp_other\"] = 1\n ret_data = dict(zip(index_keynames, (logdata[index_key] for index_key in index_keynames)))\n ret_data.update(dict(zip(value_keynames, (logdata[value_key] for value_key in value_keynames))))\n yield (logdata[\"ts\"], ret_data)","def process_timestamps(self):\n self.conn = sqlite3.connect(':memory:')\n self.cursor = self.conn.cursor()\n self.cursor.execute('CREATE TABLE tracklog(dt PRIMARY KEY, lat REAL, lon REAL, elev REAL)')\n num_points = 0\n for d in gps.parse_gpx_iter(self.gpx_file):\n self.cursor.execute('INSERT INTO tracklog VALUES(?,?,?,?)', d)\n num_points += 1\n sys.stderr.write('The GPX file contained %d Points\\n' % num_points)\n self.conn.commit()","def flush():\n global CACHE, STATS_KEYS_COUNT\n CACHE = {}\n STATS_KEYS_COUNT = 0","def flush(self):\n # Create the cache path\n CachedXMLNode.create_cache_path()\n FindingsCache.create_cache_path()\n\n # Create the context\n context = dotdict({})\n\n try:\n self._add_scan_status_to_context(context)\n except RuntimeError, rte:\n # In some very strange scenarios we get this error:\n #\n # Can NOT call get_run_time before start()\n #\n # Just \"ignore\" this call to flush and write the XML in the next call\n msg = 'xml_file.flush() failed to add scan status to context: \"%s\"'\n om.out.debug(msg % rte)\n return\n\n self._add_root_info_to_context(context)\n self._add_scan_info_to_context(context)\n self._add_findings_to_context(context)\n self._add_errors_to_context(context)\n\n # Write to file\n self._write_context_to_file(context)","def save_state(self):\n\t\tf = open('output.csv', 'a')\n\t\tstate = ';'.join([str(datetime.now()), str(self.thin._actuation_value), str(self.thin.temperature), str(self.thin.presence), str(self.outside.temperature)])\n\t\tprint(state)\n\t\tf.write(state + '\\n')\n\t\tf.close()","def log_stats(self):\n while True:\n for stats in self.stats.values():\n stats.log_stats()\n\n yield from asyncio.sleep(stats_delay)","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n #self.fl,\n #self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.mem[i], end='')\n\n print()","def _flush(self):\n for x in xrange(0,10):\n self._eng.iterate()","def trace(self):\n\n print(\n f\"TRACE: {self.pc} | {self.ram_read(self.pc)} {self.ram_read(self.pc + 1)} {self.ram_read(self.pc + 2)} |\")\n\n for i in range(8):\n print(f\"R[{i}] is {self.reg[i]}\")\n\n print()","def flush_on_term(self):\n self.influx.flush()","def loadts(args):\n # writing and reading pickle are both about 10x faster than reading csv\n # hence, simplify repeated execs by providing pickle file\n time_before = time.time()\n # timestart = time.time()\n d = dict() # dictionary of numpy arrays that hold timestamps per IP\n p = dict() # dictionary of IPs, holding # timestamps per IP\n offset = dict() # dict to hold tsval offset per IP\n\n try:\n pklfile = open(args.tsfile + \".pickle\", 'rb')\n d, p, offset = pickle.load(pklfile)\n pklfile.close()\n except:\n print(\"TS pickle loading failed, loading from csv\")\n logging.debug(\"TS pickle loading failed, loading from csv\")\n with open(args.tsfile, \"r\") as csvfile:\n datareader = csv.reader(csvfile)\n count = 0\n for row in datareader:\n count += 1\n try:\n ip = row[0]\n tcpt = row[1]\n recvt = row[2]\n except:\n print(\"Error in line \" + str(count) + \"of \" + str(args.tsfile) + \", skipping.\")\n logging.error(\"Error in line \" + str(count) + \"of \" + str(args.tsfile) + \", skipping.\")\n continue\n if ip in d:\n if p[ip] == 9999:\n d[ip].resize(100 * 1000, 2)\n if p[ip] > (100 * 1000) - 1: # more than 100k measurements can not be a target host\n continue\n if ip in offset:\n # recv_t is zero-based and scaled to be in seconds precision\n d[ip][p[ip], :] = \\\n [np.float64(tcpt),\n np.float64(np.uint64(recvt) - np.uint64(offset[ip])) / np.float64(1000.0 * 1000.0)]\n p[ip] = p[ip] + 1\n else:\n print(\"ip not in offset dict (should never happen, exiting): \" + str(ip))\n sys.exit(1)\n else: # ip is not in d, i.e. has not been seen before\n d[ip] = np.zeros((10000, 2), dtype=np.float64)\n p[ip] = 0\n d[ip][p[ip], :] = [np.float64(tcpt), np.float64(0.0)]\n p[ip] += 1\n offset[ip] = recvt\n logging.debug(\"timestamp np structure built after: {}, count: {} {} {}\".format(time.time() - time_before, count, len(d), len(p)))\n # resize all to correct length (removes trailing zeroes)\n for ip, value in p.items():\n d[ip].resize((p[ip], 2))\n\n pklfile = open(args.tsfile + \".pickle\", 'wb')\n pickle.dump([d, p, offset], pklfile)\n pklfile.close()\n print(\"ts data loaded in {} seconds, # IP addresses: {} \".format(round(time.time() - time_before, 2), len(d)))\n logging.debug(\"ts data loaded in {} seconds, # IP addresses: {} \".format(round(time.time() - time_before, 2), len(d)))\n return d, p, offset","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n #self.fl,\n #self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.register[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n #self.fl,\n #self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.register[i], end='')\n\n print()","def read_trace(self, trace):\n csv_reader = csv.DictReader(self.csv_fd)\n for row in csv_reader:\n new_trace = RiscvInstructiontTraceEntry()\n new_trace.rd = row['rd']\n new_trace.rd_val = row['rd_val']\n new_trace.addr = row['addr']\n new_trace.binary = row['binary']\n new_trace.instr_str = row['str']\n trace.append(new_trace)","def _push(self):\n if len(self._stat_now):\n self._stat_now['epoch_num'] = self.epoch_num\n self._stat_now['global_step'] = self.global_step\n\n self._stats.append(self._stat_now)\n self._stat_now = {}\n self._write_stat()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n # self.fl,\n # self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.register[i], end='')\n\n print()","def _flush_stats(self, train=True):\n\t\tif train:\n\t\t\tself.train_accuracy.flush_buffer()\n\t\t\tself.train_epochs.flush_buffer()\n\t\t\tself.train_loss.flush_buffer()\n\t\t\tself.train_confusion_matrix.flush_buffer()\n\t\t\tself.learning_rate.flush_buffer()\n\t\telse:\n\t\t\tself.val_accuracy.flush_buffer()\n\t\t\tself.val_epochs.flush_buffer()\n\t\t\tself.val_loss.flush_buffer()\n\t\t\tself.val_confusion_matrix.flush_buffer()\n\n\t\tif self.plot:\n\t\t\tself._plot(train=train)","def execute(self, args: Namespace):\n data = {}\n\n with open(args.data, 'r') as file:\n reader = csv.reader(file, delimiter=';')\n\n for row in reader:\n if reader.line_num == 1:\n if 'Timestamp, Decimal, TriState, State' != ','.join(row):\n print('Not a valid CSV file!')\n return\n\n else:\n dt = datetime.strptime(row[0], '%Y-%m-%d %H:%M:%S.%f')\n value = tri_state_value(row[2])\n device = data.setdefault(tri_state_device(row[2].strip()), {})\n device.setdefault(dt.date(),[]).append((dt.strftime('%H:%M'), value))\n\n for k in sorted(data.keys()):\n device = data[k]\n print('Device {}:'.format(tint_yellow(k)))\n\n for d in sorted(device.keys()):\n device[d].sort(key=lambda x: x[0])\n print('\\t{}:'.format(tint_blue(d)))\n\n for (t, v) in device[d]:\n if v:\n print('\\t\\tAt {} the device was turned {}.'.format(tint_blue(t),\n tint_green('ON')))\n else:\n print('\\t\\tAt {} the device was turned {}.'.format(tint_blue(t),\n tint_red('OFF')))","def preproc_data(base_dir):\n n_users = 182\n user_datas = []\n\n for user in tqdm(range(n_users)): \n #iterate through each trace of user \n user_traces = []\n if (len(str(user)) == 1): \n user_id = '00' + str(user)\n elif (len(str(user)) == 2): \n user_id = '0' + str(user)\n else: \n user_id = str(user)\n dir_name = base_dir + user_id + '/Trajectory/'\n for filename in os.listdir(dir_name): \n #load trajectory\n trajectory_raw = pd.read_csv(\n dir_name + filename,\n delimiter = ',', header = None, skiprows = 6,\n names = ['lat','lon', '0', 'altitude', 't_1899', 'date', 'time' ])\n\n #modify time\n traj = trajectory_raw.copy()\n traj.drop(columns = '0', inplace = True)\n\n traj['t_1899'] = (trajectory_raw['t_1899'] - trajectory_raw['t_1899'].values[0]) * 24 * 60 * 60\n traj_newcols = np.array(traj.columns)\n traj_newcols[traj_newcols == 't_1899'] = 'seconds'\n traj.columns = traj_newcols\n\n #get X_vals: \n R_earth = 6.371e6\n deg_to_rad = np.pi / 180\n traj['X'] = R_earth * np.cos(deg_to_rad * traj['lat'].values) * np.cos(deg_to_rad * traj['lon'].values)\n traj['Y'] = R_earth * np.cos(deg_to_rad * traj['lat'].values) * np.sin(deg_to_rad * traj['lon'].values)\n\n #Normalize to first point: \n origin_x = traj['X'].values[0]\n origin_y = traj['Y'].values[0]\n\n traj['X'] = traj['X'] - origin_x\n traj['Y'] = traj['Y'] - origin_y\n\n txy = traj.copy()\n txy = traj[['seconds', 'X', 'Y']]\n txy.columns = ['T', 'X', 'Y']\n if not np.isnan(txy.values).any(): \n user_traces.append(txy.values)\n\n user_datas.append(user_traces)\n return user_datas","def save_scopeTraces(fileName, scope, channel, noPulses):\n scope._get_preamble(channel)\n results = utils.PickleFile(fileName, 1)\n results.add_meta_data(\"timeform_1\", scope.get_timeform(channel))\n\n #ct = scope.acquire_time_check()\n #if ct == False:\n # print 'No triggers for this data point. Will skip and set data to 0.'\n # results.save()\n # results.close()\n # return False\n\n t_start, loopStart = time.time(),time.time()\n for i in range(noPulses):\n try:\n ct = scope.acquire_time_check(timeout=.4)\n results.add_data(scope.get_waveform(channel), 1)\n except Exception, e:\n print \"Scope died, acquisition lost.\"\n print e\n if i % 100 == 0 and i > 0:\n print \"%d traces collected - This loop took : %1.1f s\" % (i, time.time()-loopStart)\n loopStart = time.time()\n print \"%d traces collected TOTAL - took : %1.1f s\" % (i, (time.time()-t_start))\n results.save()\n results.close()\n return True","def generate_csv(self, context): # pylint: disable=R0912,R0914\n temp = self.percentage()\n total_state = self.unique_freq()\n offline_value = -1\n ghz_conversion = 1000000\n mhz_conversion = 1000\n with open(self.outfile, 'a+') as f:\n writer = csv.writer(f, delimiter=',')\n reader = csv.reader(f)\n # Create the header in the format below\n # workload name, iteration, state, A7 CPU0,A7 CPU1,A7 CPU2,A7 CPU3,A15 CPU4,A15 CPU5\n if sum(1 for row in reader) == 0:\n header_row = ['workload', 'iteration', 'state']\n count = 0\n for cluster, states_list in enumerate(self.currentstates_of_clusters):\n for dummy_index in range(len(states_list)):\n header_row.append(\"{} CPU{}\".format(self.corename_of_clusters[cluster], count))\n count += 1\n writer.writerow(header_row)\n if offline_value in total_state:\n total_state.remove(offline_value) # remove the offline state\n for i in sorted(total_state):\n temprow = []\n temprow.extend([context.result.spec.label, context.result.iteration])\n if \"state{}\".format(i) in self.idlestate_description:\n temprow.append(self.idlestate_description[\"state{}\".format(i)])\n else:\n state_value = float(i)\n if state_value / ghz_conversion >= 1:\n temprow.append(\"{} Ghz\".format(state_value / ghz_conversion))\n else:\n temprow.append(\"{} Mhz\".format(state_value / mhz_conversion))\n for j in range(self.device.number_of_cores * self.multiply_factor):\n temprow.append(\"{0:.3f}\".format(temp[\"cpu{}\".format(j)][i]))\n writer.writerow(temprow)\n check_off = True # Checking whether core is OFFLINE\n for i in range(self.device.number_of_cores * self.multiply_factor):\n temp_val = \"{0:.3f}\".format(temp[\"cpu{}\".format(i)][offline_value])\n if float(temp_val) > 1:\n check_off = False\n break\n if check_off is False:\n temprow = []\n temprow.extend([context.result.spec.label, context.result.iteration])\n temprow.append(\"OFFLINE\")\n for i in range(self.device.number_of_cores * self.multiply_factor):\n temprow.append(\"{0:.3f}\".format(temp[\"cpu{}\".format(i)][offline_value]))\n writer.writerow(temprow)","def batch_data(data, state_queue):\n while True:\n time.sleep(BATCH_SLEEP_TIME)\n state_queue.put((\"device_values\", [data]))","def run(self):\n\t\tself._data_updater_thread.start()\n\t\tf = open('output.csv', 'w') #TODO: handle output file correctly (cfg)\n\t\tf.write('(datetime;valve;thin_temp;thin_pres;out_temp)\\n')\n\t\tf.close()","def step1(step1_input, step1_output, map_file):\n\n logger.info(\"###Step 1:\")\n graf = defaultdict(dict)\n start = clock()\n #create brands-website map dictionsry\n website_map = {}\n with open(map_file) as csv_file:\n rdr = csv.DictReader(csv_file)\n for row in rdr:\n website_map[re.sub('[.,;:]', '', row['BrandName'])] = row['Website'] \n check_time(start, \"populate website_map\")\n #gather graph data \n start1 = clock()\n with open(step1_input, 'rb') as csv_file:\n rdr = csv.reader(csv_file)\n check_time(start1, \"Reading input file...\")\n header = rdr.next()\n start_gather = clock()\n for row in rdr:\n one_list = [i for i,x in enumerate(row) if x == '1']\n for pos in one_list:\n pos_idx = one_list.index(pos)\n try:\n site = website_map[header[pos_idx]]\n except KeyError:\n site = header[pos_idx]\n for other_pos in one_list[pos_idx+1:]:\n other_pos_idx = one_list.index(other_pos)\n try:\n other_site = website_map[header[other_pos_idx]]\n except KeyError:\n other_site = header[other_pos_idx]\n try:\n graf[site][other_site] += 1\n except KeyError:\n graf[site][other_site] = 1\n check_time(start_gather, \"Done gathering data...\")\n start_write = clock()\n write_to_file(step1_output, graf)\n check_time(start_write, \"Done writing output file.\")\n check_time(start1, \"Step 1 end...\")\n return 0","def parse_trace(self):\n current = '' # current basic block being parsed\n previous = '0' # previous basic block beding parsed\n edge_count = 0\n uniq_count = 0\n with open(self._fifo_name, 'r') as fifo:\n for line in fifo:\n if line[6] == '4':\n continue\n # process traceed tbs\n current = line.split(':')[0]\n\n parse_edge = (previous, current)\n edge_count += 1\n if not parse_edge in TRACE_EDGES:\n TRACE_EDGES.add(parse_edge)\n uniq_count += 1\n previous = current","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n #self.fl,\n #self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n #self.fl,\n #self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n #self.fl,\n #self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n #self.fl,\n #self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n #self.fl,\n #self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n #self.fl,\n #self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n #self.fl,\n #self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n #self.fl,\n #self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n #self.fl,\n #self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def _flush(self):\n self._d = {}","def do_tick(self):\n\n notifications.clear_received()\n last_rounds_notifications = notifications.get_last()\n notifications.clear()\n self.turn += 1\n actions = [actor.tick_action(last_rounds_notifications) for actor in self.actors]\n for action in actions:\n action()\n\n number_notifications = len(last_rounds_notifications.get())\n active_interventions = len(CityMap.get_interventions())\n self._csv_log([\n self.turn,\n number_notifications,\n notifications.received,\n active_interventions,\n CityMap.moves,\n len(self.get_ambulances()),\n len(self.get_policemen()),\n CityMap.ambulance_moves,\n CityMap.policeman_moves,\n len(self.intervening_policemen()),\n len(self.patroling_policemen()),\n len(self.assisting_ambulances())\n ]\n )\n\n CityMap.clear_moves()","def start_new_trace(self):\n fields = [\"instr\", \"rd\", \"rd_val\", \"rs1\", \"rs1_val\", \"rs2\", \"rs2_val\",\n \"imm\", \"str\", \"addr\", \"binary\", \"csr\", \"mode\"]\n self.csv_writer = csv.DictWriter(self.csv_fd, fieldnames=fields)\n self.csv_writer.writeheader()","def processMachineLog(file_name):\n\n # labelling of data lists\n date = []\n timeDay = []\n iteration = []\n iterationTime = [] # time it takes to complete a single cycle\n timeElapsed = [] # time elapsed since start of test for the day\n \n \"\"\" sample of important lines from log\n ##### Begin Iteration # 1 at Wed Jan 27 16:32:27 EST 2016\n ##### Completed Iteration # 1 time: 13.643001secs Total time: 13.648001secs at Wed Jan 27 16:32:41 EST 2016\n \"\"\"\n\n # opens csv file and sorts the data into the lists\n # with open(file_name, 'rb') as csvfile:\n with open(file_name, 'rb') as logFile:\n data = logFile.readlines()\n for line in data:\n if line.startswith(\"##### Completed\"):\n iteration.append(line.split(\" \")[4])\n iterationTime.append(line.split(\" \")[7][:-4]) # remove \"secs\" from the value\n # Get the Day of week, month, and date to put into date list\n dayMoDate = line.split(\" \")[14] + \" \" + line.split(\" \")[15] + \" \" + line.split(\" \")[16] + \" \" + line.split(\" \")[19].rstrip()\n date.append(dayMoDate)\n # get the time in AM/PM format (because Jess can't read 24HR format to save her life)\n convertTime = time.strftime(\"%I:%M:%S %p\", (time.strptime(line.split(\" \")[17] , \"%H:%M:%S\")))\n timeDay.append(convertTime)\n # get the total time (H:M:S format) that has elapsed since the beginning of the test\n timeSecs = float(line.split(\" \")[11][:-4]) # remove \"secs\" from the value\n timeElapsed.append(datetime.timedelta(seconds=timeSecs))\n \n # form the dataframe with all the lists as columns\n df = pd.DataFrame({'Date': date, 'Time': timeDay, 'Cycle': iteration, 'Cycle Duration': iterationTime, 'Time Elapsed': timeElapsed})\n return df","def _trigger(self):\n if len(self._stat_now):\n self._stat_now['epoch_num'] = self.epoch_num\n self._stat_now['global_step'] = self.global_step\n\n self._stats.append(self._stat_now)\n self._stat_now = {}\n self._write_stat()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n # self.fl,\n # self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n # self.fl,\n # self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n # self.fl,\n # self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n # self.fl,\n # self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n # self.fl,\n # self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n # self.fl,\n # self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n # self.fl,\n # self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n # self.fl,\n # self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n # self.fl,\n # self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n # self.fl,\n # self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n # self.fl,\n # self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def _main_process(hashtags, start_ndx):\r\n\tglobal timekeeper, total_inserted, half_hour_timer\r\n\t\r\n\tlogging.error('Total # of hashtags: {0}'.format(len(hashtags)))\r\n\r\n\tndx = 0 + start_ndx\r\n\tfor hashtag in hashtags:\r\n\r\n\t\thashtag = hashtag.hashtag.encode('utf-8')\r\n\r\n\t\tlogging.error('-------#{0}: {1}--------'.format(ndx, hashtag))\r\n\r\n\t\tmax_time = random.randint(10, 100)\r\n\t\tif time.time() - timekeeper >= max_time:\r\n\t\t\tsleep_time = random.randint(7, 15)\r\n\t\t\tlogging.error('Sleeping for {0}s. Max time: {1}...'.format(sleep_time, max_time))\r\n\t\t\ttime.sleep(sleep_time)\r\n\t\t\ttimekeeper = time.time()\r\n\r\n\t\tif time.time() - half_hour_timer >= 1800:\r\n\t\t\tsleep_time = 300\r\n\t\t\tlogging.error('Sleeping for *5 minutes*....')\r\n\t\t\ttime.sleep(sleep_time)\r\n\t\t\thalf_hour_timer = time.time()\r\n\r\n\t\ttry:\r\n\t\t\t_process_hashtag(hashtag)\r\n\t\texcept requests.exceptions.SSLError as e:\r\n\t\t\tlogging.error(e)\r\n\t\t\ttime.sleep(20)\r\n\t\t\t_process_hashtag(hashtag)\r\n\t\texcept Exception as e:\r\n\t\t\tlogging.error('******** EXTREME ERROR ********')\r\n\t\t\tlogging.error(e)\r\n\t\t\tlogging.error('...... skipping hashtag \"{0}\".....'.format(hashtag))\r\n\t\t\ttime.sleep(300)\r\n\t\t\tcontinue\r\n\r\n\t\tndx += 1\r\n\r\n\tlogging.error('total_inserted = {0}'.format(total_inserted))","def trace(self):\n\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n # self.flag,\n #self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n # self.fl,\n # self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def trace(self):\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n # self.fl,\n #self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')\n\n print()","def run(self):\n self.timestamp['start'] = datetime.datetime.now().strftime('%Y%m%dT%H%M%S')\n\n for point in self._prepare_grid():\n graph = self._prepare_graph(**point)\n env = self._prepare_env(graph, **point)\n log = self._prepare_logger(graph, env, **point)\n\n try:\n env.run(until=self.runtime)\n except Exception as e:\n print(e)\n log.close()\n\n # self.timestamp[grid.hash_grid_point(point)].append(datetime.datetime.now().strftime('%Y%m%dT%H%M%S'))\n\n self.timestamp['end'] = datetime.datetime.now().strftime('%Y%m%dT%H%M%S')","def trace(self):\n print(f\"TRACE: %02X | %02X %02X %02X |\" % (\n self.pc,\n # self.fl,\n # self.ie,\n self.ram_read(self.pc),\n self.ram_read(self.pc + 1),\n self.ram_read(self.pc + 2)\n ), end='')\n\n for i in range(8):\n print(\" %02X\" % self.reg[i], end='')","def tick(self):\n self.world.tick()\n # self.world_snapshot = self.world_queue.get(timeout=60.0)\n # Update data structures for the current frame.\n current_actors = set(\n [vehicle.id for vehicle in self.world.get_actors().filter('vehicle.*')])\n self.spawned_actors = current_actors.difference(self._active_actors)\n self.destroyed_actors = self._active_actors.difference(current_actors)\n self._active_actors = current_actors\n\n world_snapshot = self.world.get_snapshot()\n for v in current_actors:\n line = '{:06},{},{:d}' + ',{:.3f}' * 9\n tf = world_snapshot.find(v).get_transform()\n vehicle = self.world.get_actor(v)\n extent = vehicle.bounding_box.extent\n type_id = vehicle.type_id\n line = line.format(world_snapshot.frame, type_id, v,\n tf.location.x, tf.location.y, tf.location.z,\n tf.rotation.roll, tf.rotation.pitch, tf.rotation.yaw,\n extent.x * 2, extent.y * 2, extent.z * 2)\n self.file_writer.writerow(line.split(','))\n\n self.synchronize_sensors()","def run(self):\n lineage_csv_gz = self.input_files_local[0][0]\n output_db = self.output_files_local()[0]\n log.write(f\"input: {lineage_csv_gz} output: {output_db}\")\n\n with IdSeqDictForUpdate(output_db, IdSeqDictValue.VALUE_TYPE_ARRAY) as lineage_dict:\n batch_list = {}\n with gzip.open(lineage_csv_gz, \"rt\") as gzf:\n for line in gzf:\n fields = line.rstrip().split(\",\")\n taxid = fields[0]\n species, genus, family = fields[-1:-4:-1]\n batch_list[taxid] = [species, genus, family]\n if len(batch_list) >= BATCH_INSERT_SIZE:\n lineage_dict.batch_inserts(batch_list.items())\n batch_list = {}\n lineage_dict.batch_inserts(batch_list.items())","def save_scopeTraces_Multiple(fileNames, scope, channels, noPulses):\n results = []\n for i in range(len(fileNames)):\n\t scope._get_preamble(channels[i])\n\t results.append(utils.PickleFile(fileNames[i], 1))\n\t results[i].add_meta_data(\"timeform_1\", scope.get_timeform(channels[i]))\n\n #ct = scope.acquire_time_check()\n #if ct == False:\n # print 'No triggers for this data point. Will skip and set data to 0.'\n # results.save()\n # results.close()\n # return False\n\n t_start, loopStart = time.time(),time.time()\n for i in range(noPulses):\n try:\n ct = scope.acquire_time_check(timeout=.4)\n for j in range(len(results)):\n\t\t results[j].add_data(scope.get_waveform(channels[j]), 1)\n except Exception, e:\n print \"Scope died, acquisition lost.\"\n print e\n if i % 100 == 0 and i > 0:\n print \"%d traces collected - This loop took : %1.1f s\" % (i, time.time()-loopStart)\n loopStart = time.time()\n print \"%d traces collected TOTAL - took : %1.1f s\" % (i, (time.time()-t_start))\n for i in range(len(results)):\n\t results[i].save()\n return True","def _storePerfStats(self, results):\n self.state = ZenProcessTask.STATE_STORE_PERF\n byConf = reverseDict(self._deviceStats._pidToProcess)\n for procStat, pids in byConf.iteritems():\n if len(pids) != 1:\n log.debug(\"There are %d pids by the name %s - %s\",\n len(pids), procStat._config.name, procStat._config.originalName)\n procName = procStat._config.name\n for pid in pids:\n if not AS400PLUG in self._device.zCollectorPlugins:\n cpu = results.get(CPU + str(pid), None)\n else:\n cpu = results.get(AS400CPU + str(pid), None) / 10 ## as we get millis vs centis\n mem = results.get(MEM + str(pid), None)\n procStat.updateCpu(pid, cpu)\n procStat.updateMemory(pid, mem)\n self._save(procName, 'cpu_cpu', procStat.getCpu(),\n 'DERIVE', min=0)\n self._save(procName, 'mem_mem',\n procStat.getMemory() * 1024, 'GAUGE')\n return results","def log(self):\n f = open(self.log_dir + 'parsed.log', 'a')\n try:\n # Write: local time | CurrentCost \"time\" | id | temp/C | power/W \n f.write(\"%s\\t%s\\t%s\\t%s\\t%s\\n\" \n % (self.ts('now'), self.ts('cc'), self.id, self.temp, self.watts))\n finally:\n f.close()","def test_state(self):\n # blocks [0 3583] [3840 4058]\n test_file1 = os.path.join(INPUT_HYPM_PATH, 'unit_364-2013-206-2-0.mdd')\n # blocks [0 1279] [1536 1791] [2048 2303] [2560 2815] [3072 4059]\n test_file2 = os.path.join(INPUT_HYPM_PATH, 'unit_364-2013-206-3-0.mdd')\n\n # parse the two .mdd files into the node and instrument group files\n mdd.procall([test_file1, test_file2])\n\n file_state = self.get_file_state('node58p1.dat')\n # there is an unprocessed '/n' in between records\n expected_file_state = {StateKey.UNPROCESSED_DATA: [[4059, 4060]],\n StateKey.FILE_SIZE: 4060,\n StateKey.OUTPUT_INDEX: 1}\n\n if file_state != expected_file_state:\n print file_state\n self.fail(\"Expected file state 1 does not match\")\n\n # blocks [0 2047] [2304 4095] [4096 7451]\n test_file3 = os.path.join(INPUT_HYPM_PATH, 'unit_364-2013-206-6-0.mdd')\n\n # parse another .mdd file adding on to the node file, and making\n # another sequence of instrument group files\n mdd.procall([test_file3])\n\n file_state = self.get_file_state('node58p1.dat')\n expected_file_state = {StateKey.UNPROCESSED_DATA: [[4059, 4060]],\n StateKey.FILE_SIZE: 7452,\n StateKey.OUTPUT_INDEX: 2}\n\n if file_state != expected_file_state:\n print \"file state: '%s'\" % file_state\n self.fail(\"Expected file state 2 does not match\")\n\n data_orig = self.read_full_file('node58p1.dat')\n\n # read the data from all generated files into one data string\n data_out = self.read_full_file('node58p1_0.status_1236801.dat')\n data_out += self.read_full_file('node58p1_0.wa_wfp_1236820.dat')\n data_out += self.read_full_file('node58p1_0.wc_wfp_1236820.dat')\n data_out += self.read_full_file('node58p1_0.we_wfp_1236820.dat')\n data_out += self.read_full_file('node58p1_1.status_1236801.dat')\n data_out += self.read_full_file('node58p1_1.wa_wfp_1236822.dat')\n data_out += self.read_full_file('node58p1_1.wc_wfp_1236822.dat')\n data_out += self.read_full_file('node58p1_1.we_wfp_1236822.dat')\n\n # confirm data in the node file matches those output in the instrument groups\n if not TestSioUnpack.compare_sio_matches(data_orig, data_out):\n self.fail(\"Failed sio block compare\")","def save_state(self):\n\t\tself._history['time'].append(self.t)\n\t\tstate = np.array(self.x[np.newaxis,:,:])\n\t\tself._history['state'] = np.vstack([self._history['state'],state])","def post_process_renaissance(done_exec, tmp_file):\n\n wallclock_times = [-0.0] * done_exec.num_iters\n with open(tmp_file) as f:\n rows = iter(csv.reader(f))\n\n headers = rows.__next__()\n assert headers[0] == \"benchmark\"\n assert headers[1] == \"nanos\"\n\n for i, row in enumerate(rows):\n assert row[0] == done_exec.benchmark\n # nanos -> seconds.\n wallclock_times[i] = int(row[1]) / 1000000000\n\n assert len(wallclock_times) == done_exec.num_iters\n return wallclock_times","def _save_traces(self, blocks):\n docs = [{\"id\": block, \"name\": \"traces_extracted\", \"value\": True} for block in blocks]\n self.client.bulk_index(index=self.indices[\"block_flag\"], docs=docs)","def start(self, train_set, val_set):\n \n for epoch in range(self.start_epoch, self.num_epochs+self.start_epoch):\n _, __, ___, last_itr = self.iterate(epoch, \"train\", train_set)\n self.meter.tb_log.add_scalar(f'learning_rate', self.get_current_lr(), last_itr)\n\n state = {\n \"epoch\": epoch,\n \"best_metric\": self.best_metric,\n \"state_dict\": self.net.state_dict(),\n \"optimizer\": self.optimizer.state_dict(),\n }\n \n with torch.no_grad():\n val_loss, val_dice, val_iou, __ = self.iterate(epoch, \"val\", val_set)\n key_metrics = {\"loss\": val_loss, \"dice\": -1.*val_dice, \"iou\": -1.*val_iou} # -1* for the scheduler\n self.scheduler.step(val_loss)\n\n is_last_epoch = epoch == (self.num_epochs - 1)\n if key_metrics[self.key_metric] < self.best_metric or is_last_epoch:\n logging.info(\"******** Saving state ********\")\n\n if self.multi_gpu_flag:\n # fix parameters names in a state dict. (caused by nn.DataParallel)\n new_state_dict = {}\n for k in state[\"state_dict\"]:\n if k.startswith(\"module.\"):\n new_k = re.sub(\"module.\", \"\", k)\n new_state_dict[new_k] = copy.deepcopy(state[\"state_dict\"][k])\n del state[\"state_dict\"]\n gc.collect()\n state[\"state_dict\"] = new_state_dict\n\n state[\"val_IoU\"] = val_iou\n state[\"val_dice\"] = val_dice\n state[\"val_loss\"] = val_loss\n state[\"best_metric\"] = self.best_metric = key_metrics[self.key_metric]\n\n ckpt_name = \"best_model\"\n if is_last_epoch:\n ckpt_name = \"last_model\"\n torch.save(state, f\"{self.model_path}/{ckpt_name}.pth\")\n \n # save meta-data into the workdir\n self.dump_meta()","def thread_main(self, sess):\n for x_h, x_m, y in self.data_iterator():\n sess.run(self.enqueue_op, feed_dict={self.x_h:x_h, self.x_m:x_m})","def do_timestamp_messages(self, messages):\n timestamp = self.env.now\n self.reception_records[timestamp] = messages\n log.debug(\"{} recorded {}\".format(self, self.reception_records))","def collect_data(self):\n self.lines = []\n\n while True:\n self._process_serial_data()","def process_events(cat_data, n_run, cfg, sta_locs):\n import time\n import os\n import shutil\n import sys\n import logging\n from obspy import read\n from obspy.geodetics.base import gps2dist_azimuth\n import matplotlib.pyplot as plt\n\n if cfg.output.FORCE_RECALC is True:\n w = open(\"refined_events.dat\", \"w\")\n w.close()\n if cfg.plotting.DO_PLOT_1 is True or cfg.plotting.DO_PLOT_2 is True:\n fig = plt.figure(figsize=(18, 10))\n else:\n fig = []\n # Prepare directory\n if (os.path.exists(\"runs/run{:}\".format(n_run))\n and os.path.isdir(\"runs/run{:}\".format(n_run))):\n shutil.rmtree(\"runs/run{:}\".format(n_run))\n copytree(\"NLLOC_run\", \"runs/run{:}\".format(n_run))\n os.chdir(\"runs/run{:}\".format(n_run))\n for n_ev, ev in enumerate(cat_data):\n start = time.time()\n ev_id = ev.event_descriptions[0].text\n sys.stdout.flush()\n ev_dict = {}\n ev_dict[\"stations\"] = {}\n orig_lat, orig_lon = [ev.origins[0].latitude, ev.origins[0].longitude]\n logging.debug(\"startint logging\")\n st = read(\"../../{:}/{:}/MSEED/*.msd\".format(\n cfg.input.DIR_TO_EVENTDIRS, ev_id), format=\"MSEED\")\n print(n_run, ev_id)\n for n_tr, tr in enumerate(st):\n if st[n_tr].stats.sampling_rate > 40.0:\n try:\n st[n_tr].resample(40)\n except ZeroDivisionError:\n continue\n st1, st2, st_mag = [st.copy(), st.copy(), st.copy()]\n # Append distance to trace\n stations_data = sorted(set([tr.stats.station for tr in st\n if tr.stats.station not in\n cfg.sta_select.STA_BLACKLIST]))\n stations_dist = {sta_code: gps2dist_azimuth(\n sta_locs[sta_code][\"lat\"], sta_locs[sta_code][\"lon\"],\n orig_lat, orig_lon)[0] for sta_code in stations_data\n if gps2dist_azimuth(\n sta_locs[sta_code][\"lat\"], sta_locs[sta_code][\"lon\"],\n orig_lat, orig_lon)[0]/1000 <= cfg.sta_select.MAX_DIST}\n path_to_figs = \"../../{:}/{:}/figs\".format(\n cfg.input.DIR_TO_EVENTDIRS, ev_id)\n if not os.path.exists(path_to_figs):\n os.mkdir(path_to_figs)\n print(\"Doing first refinement\")\n sys.stdout.flush()\n if (\"R\" in cfg.picking.CMPS_REFINE_1[\"S\"] or\n \"T\" in cfg.picking.CMPS_REFINE_1[\"S\"]):\n rot = True\n else:\n rot = False\n evt_refine_1, rms, found = refine_events(\n st1, stations_dist, cfg.picking.CMPS_REFINE_1,\n cfg.picking.MAX_PICK_DIFF_REFINE1, ev,\n cfg.ploting.DO_PLOT_1, 1, fig, \"const\", path_to_figs, ev_dict,\n ev_id, cfg, rot\n )\n if found is False:\n continue\n print(\"RMS = \", rms)\n sys.stdout.flush()\n prev_rms = rms\n print(\"Doing second refinement\")\n sys.stdout.flush()\n if (\"R\" in cfg.picking.CMPS_REFINE_2[\"S\"] or\n \"T\" in cfg.picking.CMPS_REFINE_2[\"S\"]):\n rot = True\n else:\n rot = False\n evt_refine_2, rms, found = refine_events(\n st2, stations_dist, cfg.picking.CMPS_REFINE_2,\n cfg.picking.MAX_PICK_DIFF_REFINE2, evt_refine_1,\n cfg.plotting.DO_PLOT_2, 2, fig, \"dist\", path_to_figs, ev_dict,\n ev_id, rot\n )\n if found is False:\n continue\n print(\"RMS = \", rms)\n if rms > prev_rms * 1.25:\n print(\"RMS is significantly increasing (*25%) - skipping event\")\n continue\n prev_rms = rms\n evt_refine_2 = compute_magnitude(evt_refine_2, st_mag, cfg)\n write_evt(evt_refine_2, ev_id)\n end = time.time()\n print(\"Time taken for event: {:3.1f} mins\".format((end-start)/60))","def analysis_host_sec(self):\n #calc the date\n time_now = int(time.time())\n time_local = time.localtime(time_now)\n date = time.strftime(\"%Y-%m-%d\",time_local)\n sum_cpu_ratio = 0\n sum_phy_mem_size = 0\n sum_virt_mem_size = 0\n\n key_re_word = \"%s qa_work\" % self.pid\n for line in self.file_top.readlines():\n if re.search(key_re_word, line):\n #analysis_cpu_rate()\n sum_cpu_ratio += float(line.split()[8])\n self.cpu_list_1sec.append(float(line.split()[8]))\n\n #analysis_host_phy_mem_size(), the standerd unit is \"g\"\n if \"m\" in line.split()[5]:\n phy_mem_size = float(line.split()[5].strip(\"m\")) / 1000\n elif \"g\" in line.split()[5]:\n phy_mem_size = float(line.split()[5].strip(\"g\"))\n elif \"k\" in line.split()[5]:\n phy_mem_size = float(line.split()[5].strip(\"k\")) / 1000 / 1000\n else:\n phy_mem_size = 0.0\n self.phy_mem_list_1sec.append(float(phy_mem_size))\n sum_phy_mem_size += phy_mem_size\n\n #analysis_host_virt_mem_size(), the standerd unit is \"g\"\n if \"m\" in line.split()[4]:\n vir_mem_size = float(line.split()[4].strip(\"m\")) / 1000\n elif \"g\" in line.split()[4]:\n vir_mem_size = float(line.split()[4].strip(\"g\"))\n elif \"k\" in line.split()[4]:\n vir_mem_size = float(line.split()[4].strip(\"k\")) / 1000 / 1000\n else:\n vir_mem_size = 0\n self.virt_mem_list_1sec.append(float(vir_mem_size))\n sum_virt_mem_size += vir_mem_size\n\n elif re.search(\"top -\", line):\n final_time = date + \" \" + line.split()[2]\n self.top_pertime.append(final_time)\n top_num = min(len(self.top_pertime), len(self.cpu_list_1sec), len(self.phy_mem_list_1sec), len(self.virt_mem_list_1sec))\n\n #cal the average data\n average_cpu_ratio = round(sum_cpu_ratio/len(self.cpu_list_1sec), 2)\n average_phy_mem_size = round(sum_phy_mem_size/len(self.phy_mem_list_1sec), 2)\n average_virt_mem_size = round(sum_virt_mem_size/len(self.virt_mem_list_1sec), 2)\n #cal the max data\n max_cpu_ratio = max(self.cpu_list_1sec)\n max_phy_mem_size = max(self.phy_mem_list_1sec)\n max_virt_mem_size = max(self.virt_mem_list_1sec)\n #insert into mysql-top_list_1sec_avg\n print \"average_cpu_ratio: %s\" % average_cpu_ratio\n print \"average_phy_mem_size: %s\" % average_phy_mem_size\n print \"average_virt_mem_size: %s\" % average_virt_mem_size\n print \"max_cpu_ratio: %s\" % max_cpu_ratio\n print \"max_phy_mem_size: %s\" % max_phy_mem_size\n print \"max_virt_mem_size: %s\" % max_virt_mem_size\n if self.db_onoff == \"on\":\n self.mysql.insert_table_sql_top_avg(self.time_sql, max_cpu_ratio, max_phy_mem_size, max_virt_mem_size)","def log_stats_thread(root):\n start = time.time()\n\n while True:\n time.sleep(3)\n timenow = time.time()\n elapsed = str(timedelta(seconds = timenow - start))\n inodesps = inodecount[root] / (timenow - start)\n logger.info('CRAWL STATS (path {0}, files {1}, dirs {2}, elapsed {3}, perf {4:.3f} inodes/s, {5} paths still scanning {6}, memory usage {7})'.format(\n root, filecount[root], dircount[root], elapsed, inodesps, len(scan_paths), scan_paths, get_mem_usage()))\n dps = total_doc_count[root] / (timenow - start)\n logger.info('ES UPLOAD STATS (path {0}, uploaded {1} docs, elapsed {2}, perf {3:.3f} docs/s)'.format(\n root, total_doc_count[root], elapsed, dps))","def _write_cache(step, event_file_suffix=None, **kwargs):\n file_suffix = _TT_EVENT_FILE_SUFFIX\n if event_file_suffix is not None:\n file_suffix = string_ops.string_join([file_suffix, event_file_suffix],\n separator='.')\n # TODO(deveci): Parametrize max_queue, so that flushing op can be called\n # less frequently.\n # Setting max_queue to 100 appears to be safe even when the number of\n # iterations are much lower, as the destructor of the writer flushes it.\n summary_write_ops = []\n summary_writer = summary.create_file_writer_v2(\n self._parameters.trace_dir,\n filename_suffix=file_suffix,\n max_queue=_TT_SUMMARY_MAX_QUEUE)\n graph.add_to_collection(\n TENSOR_TRACER_SUMMARY_COLLECTION, summary_writer)\n\n step_value = step[0]\n dt = step_value.dtype\n\n # The step parameter to a summary write call must be 64-bit.\n if dt.__ne__(dtypes.int64) and dt.__ne__(\n dtypes.uint64) and dt.__ne__(dtypes.float64):\n step_value = math_ops.cast(step_value, dtypes.int64)\n\n with summary_writer.as_default():\n summary_metadata = summary_pb2.SummaryMetadata(\n plugin_data=summary_pb2.SummaryMetadata.PluginData(\n plugin_name=_TT_TENSORBOARD_PLUGIN_NAME))\n for key, value in kwargs.items():\n # Check whether we need to compute aggregated statistics that merge\n # all cores statistics.\n if not self._parameters.collect_summary_per_core:\n # Merge only statistics tensor, if it is any other tensor we simply,\n # concatenate them.\n # Also, if there is only a single core (first dim. is 0), then skip\n # aggregation.\n if key == _TT_SUMMARY_TAG and value.shape.as_list()[0] != 1:\n value = self.aggregate_global_cache(value)\n with ops.control_dependencies([summary_writer.init()]):\n summary_write_ops.append(summary.write(\n _TT_SUMMARY_TAG + '/' + key + '.' + graph_summary_tag,\n value, metadata=summary_metadata,\n step=step_value))\n return control_flow_ops.group(summary_write_ops)","def process_iteration_result(self, result, context):\n self.infile = os.path.join(context.output_directory, 'trace.txt')\n if os.path.isfile(self.infile):\n self.logger.debug('Running result_processor \"dvfs\"')\n self.outfile = os.path.join(settings.output_directory, 'dvfs.csv')\n self.flush_parse_initialize()\n self.calculate()\n self.percentage()\n self.generate_csv(context)\n self.logger.debug('Completed result_processor \"dvfs\"')\n else:\n self.logger.debug('trace.txt not found.')","def flush(self):\n with self._lock:\n batch = self._batch\n timestamps = self._timestamps\n\n items = []\n for identity, value in batch.items():\n metric = {}\n typ, name, tags = identity\n metric[\"name\"] = name\n if typ:\n metric[\"type\"] = typ\n else:\n metric[\"timestamp\"] = timestamps[identity]\n\n if tags:\n metric[\"attributes\"] = dict(tags)\n\n metric[\"value\"] = value\n items.append(metric)\n\n items = tuple(items)\n\n batch.clear()\n timestamps.clear()\n\n common = self._common.copy()\n common[\"timestamp\"] = self._interval_start\n now = int(time.time() * 1000.0)\n interval = now - self._interval_start\n common[\"interval.ms\"] = interval\n\n self._interval_start = now\n\n return items, common","def _log_file_processing_stats(self, known_file_paths):\n # File Path: Path to the file containing the DAG definition\n # PID: PID associated with the process that's processing the file. May\n # be empty.\n # Runtime: If the process is currently running, how long it's been\n # running for in seconds.\n # Last Runtime: If the process ran before, how long did it take to\n # finish in seconds\n # Last Run: When the file finished processing in the previous run.\n headers = [\"File Path\", \"PID\", \"Runtime\", \"# DAGs\", \"# Errors\", \"Last Runtime\", \"Last Run\"]\n\n rows = []\n now = timezone.utcnow()\n for file_path in known_file_paths:\n last_runtime = self.get_last_runtime(file_path)\n num_dags = self.get_last_dag_count(file_path)\n num_errors = self.get_last_error_count(file_path)\n file_name = os.path.basename(file_path)\n file_name = os.path.splitext(file_name)[0].replace(os.sep, \".\")\n\n processor_pid = self.get_pid(file_path)\n processor_start_time = self.get_start_time(file_path)\n runtime = (now - processor_start_time) if processor_start_time else None\n last_run = self.get_last_finish_time(file_path)\n if last_run:\n seconds_ago = (now - last_run).total_seconds()\n Stats.gauge(f\"dag_processing.last_run.seconds_ago.{file_name}\", seconds_ago)\n\n rows.append((file_path, processor_pid, runtime, num_dags, num_errors, last_runtime, last_run))\n\n # Sort by longest last runtime. (Can't sort None values in python3)\n rows.sort(key=lambda x: x[3] or 0.0)\n\n formatted_rows = []\n for file_path, pid, runtime, num_dags, num_errors, last_runtime, last_run in rows:\n formatted_rows.append(\n (\n file_path,\n pid,\n f\"{runtime.total_seconds():.2f}s\" if runtime else None,\n num_dags,\n num_errors,\n f\"{last_runtime:.2f}s\" if last_runtime else None,\n last_run.strftime(\"%Y-%m-%dT%H:%M:%S\") if last_run else None,\n )\n )\n log_str = (\n \"\\n\"\n + \"=\" * 80\n + \"\\n\"\n + \"DAG File Processing Stats\\n\\n\"\n + tabulate(formatted_rows, headers=headers)\n + \"\\n\"\n + \"=\" * 80\n )\n\n self.log.info(log_str)","def after_epoch(self):\n line = ' '.join([str(k) + ': ' + str(v) for k, v in self.trainer.status.items()])\n with open(os.path.join(self.root_path, 'log.txt'), 'a+') as fout:\n fout.write(line + '\\n')","def analysis_dev_sec(self):\n #calc the date\n time_now = int(time.time())\n time_local = time.localtime(time_now)\n date = time.strftime(\"%Y-%m-%d\",time_local)\n sum_cpu_ratio = 0\n sum_gpu_mem_size = 0\n # key: time key\n key_re_time = \"[0-9]+ [0-9]+:[0-9]+:[0-9]+ 20[12][][0-9]\"\n # key: temperature key\n key_re_temper = \"[0-9]+C\"\n # key: gpu percent key\n key_re_percent = \"[0-9]+%\"\n # key: gpu mem key\n key_re_mem = \"%s\" % self.pid\n key_re_mem_null = \"No running processes found\"\n # key: line ending key\n key_ending = \"====ending====\"\n\n new_gpu_data_count = 0\n sum_gpu_usage_percent_all = 0\n for line in self.file_gpu.readlines():\n if re.search(key_re_time, line):\n # time own unit\n # 1. colect the gpu time info\n final_time = date + \" \" + line.split()[3]\n self.gpu_pertime.append(final_time)\n elif re.search(key_re_temper, line) and re.search(key_re_percent, line):\n #print \"2222, data_line: %s\" % line\n # 2. colect the gpu temperature info\n # 3. colect the gpu usage percentage info\n temper = float(line.split()[2].rstrip(\"C\"))\n gpu_usage = float(line.split()[12].rstrip(\"%\"))\n if new_gpu_data_count == 0:\n self.gpu_temper_1.append(temper)\n self.gpu_usage_percent_1.append(gpu_usage)\n elif new_gpu_data_count == 1:\n self.gpu_temper_2.append(temper)\n self.gpu_usage_percent_2.append(gpu_usage)\n elif new_gpu_data_count == 2:\n self.gpu_temper_3.append(temper)\n self.gpu_usage_percent_3.append(gpu_usage)\n elif new_gpu_data_count == 3:\n self.gpu_temper_4.append(temper)\n self.gpu_usage_percent_4.append(gpu_usage)\n new_gpu_data_count += 1\n elif re.search(key_re_mem, line) or re.search(key_re_mem_null, line):\n # 4. colect the gpu mem info\n this_gpu_num = line.split()[1]\n if \"MiB\" in line.split()[5]:\n this_gpu_mem = float(line.split()[5].strip(\"MiB\"))\n # TODO_this: if there have other unit\n\n if this_gpu_num == \"0\":\n self.gpu_mem_1.append(this_gpu_mem)\n elif this_gpu_num == \"1\":\n self.gpu_mem_2.append(this_gpu_mem)\n elif this_gpu_num == \"2\":\n self.gpu_mem_3.append(this_gpu_mem)\n elif this_gpu_num == \"3\":\n self.gpu_mem_4.append(this_gpu_mem)\n elif this_gpu_num == \"No\":\n self.gpu_mem_1.append(0)\n self.gpu_mem_2.append(0)\n self.gpu_mem_3.append(0)\n self.gpu_mem_4.append(0)\n \n elif re.search(key_ending, line):\n # control unit\n # 1.complete the gpu_mem list\n max_len_gpu_mem = max(len(self.gpu_mem_4), len(self.gpu_mem_3), len(self.gpu_mem_2), len(self.gpu_mem_1))\n min_len_gpu_mem = min(len(self.gpu_mem_4), len(self.gpu_mem_3), len(self.gpu_mem_2), len(self.gpu_mem_1))\n if max_len_gpu_mem != min_len_gpu_mem:\n if len(self.gpu_mem_1) != max_len_gpu_mem:\n self.gpu_mem_1.append(0)\n if len(self.gpu_mem_2) != max_len_gpu_mem:\n self.gpu_mem_2.append(0)\n if len(self.gpu_mem_3) != max_len_gpu_mem:\n self.gpu_mem_3.append(0)\n if len(self.gpu_mem_4) != max_len_gpu_mem:\n self.gpu_mem_4.append(0)\n new_gpu_data_count = 0\n\n # ! because all the list is equal\n for i in range(len(self.gpu_mem_1)):\n self.gpu_usage_percent_all.append(self.gpu_usage_percent_1[i] + self.gpu_usage_percent_2[i] + self.gpu_usage_percent_3[i] + self.gpu_usage_percent_4[i])\n\n #self.gpu_mem_all.append(self.gpu_mem_1[i] + self.gpu_mem_2[i] + self.gpu_mem_3[i] + self.gpu_mem_4[i])\n self.gpu_mem_all.append(self.gpu_mem_1[i] + self.gpu_mem_2[i] + self.gpu_mem_3[i] + self.gpu_mem_4[i])\n sum_gpu_mem_size += max(self.gpu_mem_1[i], self.gpu_mem_2[i], self.gpu_mem_3[i], self.gpu_mem_4[i])\n\n self.gpu_temper_max.append(max(self.gpu_temper_1[i] ,self.gpu_temper_2[i] ,self.gpu_temper_3[i] ,self.gpu_temper_4[i]))\n\n version_gpu_usage_percent_all = max(self.gpu_usage_percent_all)\n\n version_gpu_mem_all = max(self.gpu_mem_all)\n version_gpu_mem_avg = round(sum_gpu_mem_size/len(self.gpu_mem_all), 2)\n\n version_gpu_temper_max = max(self.gpu_temper_max)\n\n print \"version_gpu_usage_percent_all: %s\" % version_gpu_usage_percent_all\n print \"version_gpu_mem_all: %s\" % version_gpu_mem_all\n print \"version_gpu_mem_avg: %s\" % version_gpu_mem_avg\n print \"version_gpu_temper_max: %s\" % version_gpu_temper_max\n\n # insert into database: nvidia_list_1sec\n if self.db_onoff == \"on\":\n # insert into database: nvidia_list_1sec_avg\n self.mysql.insert_table_sql_nvidia_version(self.time_sql, version_gpu_usage_percent_all, version_gpu_mem_avg, version_gpu_temper_max)\n # insert into database: nvidia_list_1sec_max\n #self.mysql.insert_table_sql_nvidia_version(self.time_sql, version_gpu_usage_percent_all, version_gpu_mem_all, version_gpu_temper_max)","def flush(self):\n logger.debug('Flushing session state to file %s', self.file_path)\n\n with open(self.file_path, 'wb') as f:\n pickle.dump(self.data, f)","def step(self):\n with paddle.no_grad():\n for index, tensors in self.trace:\n grad_trace = self.create_trace(index, tensors)\n if self._async_q is not None:\n self._async_q.put(grad_trace)\n self._async_e.wait()\n self._async_e.clear()\n else:\n index, grads = grad_trace\n self._update(index, grads)\n self.trace = []","def _flush(self):\n old_pumps = self._pumps\n new_pumps = self._pumps = set()\n for p in old_pumps:\n p.flush()\n if p.clientIO.disconnected and p.serverIO.disconnected:\n continue\n new_pumps.add(p)","def _process_raw_data(self):\n sysfs_per_line = self._raw_sysfs_data.splitlines()\n del sysfs_per_line[0] #throw away the first line, it's just the counts, we don't care...\n\n self.levels = dict()\n\n for level in range(0, len(sysfs_per_line)):\n line = sysfs_per_line[level]\n cts = list()\n cts_strings = re.findall('\\[(.+?)\\]', line)\n for ct_string in cts_strings:\n new_ct = CastleSysfsComponentTreeState(ct_string)\n new_ct.raw_sysfs_string = ct_string\n cts.append(new_ct)\n self.levels[level]=cts","def data_process():\n global localtime\n global value_dict\n sensor_types = sEtting.sensor_types\n sensor_values = []\n msg = None\n value_dict = collections.OrderedDict.fromkeys(sEtting.payload_header)\n value_dict[\"ver_format\"] = sEtting.ver_format\n value_dict[\"FAKE_GPS\"] = sEtting.fake_gps\n value_dict[\"app\"] = sEtting.app\n value_dict[\"ver_app\"] = sEtting.ver_app\n value_dict[\"device_id\"] = sEtting.device_id\n value_dict[\"date\"] = localtime.strftime(\"%Y-%m-%d\")\n value_dict[\"time\"] = localtime.strftime(\"%H:%M:%S\")\n value_dict[\"device\"] = sEtting.device\n\n for sensor in sensor_types:\n if sensor == 'pm25-at':\n value_dict[\"s_d0\"] = get_reading_csv(sensor)\n elif sensor == 'temperature':\n value_dict[\"s_t0\"] = get_reading_csv(sensor)\n elif sensor == 'humidity':\n value_dict[\"s_h0\"] = get_reading_csv(sensor)\n elif sensor == 'pm10-at':\n value_dict[\"s_d1\"] = get_reading_csv(sensor)\n else:\n print 'Not support sensor type.'\n if sEtting.fake_gps == 1:\n value_dict[\"gps_lat\"] = sEtting.fgps_lat\n value_dict[\"gps_lon\"] = sEtting.fgps_lon\n value_dict[\"gps_alt\"] = sEtting.fgps_alt\n value_dict[\"gps_fix\"] = 0\n else:\n value_dict[\"gps_lat\"] = get_gps()[0]\n value_dict[\"gps_lon\"] = get_gps()[1]\n value_dict[\"gps_alt\"] = get_gps()[2]\n value_dict[\"gps_fix\"] = gpsd.fix.mode\n value_dict[\"gps_num\"] = 0\n #if debug_enable == '0':\n msg = \"|\" + \"|\".join([\"=\".join([key, str(val)])\n for key, val in value_dict.items()])\n return msg\n #elif debug_enable == '1':\n # msg_debug = \",\".join([\"=\".join([key, str(val)]) for key, val in value_dict.items()])\n # return msg_debug","def flush(self):\n for k, l in self.logs.items():\n self.full_logs[k].extend(l)\n self.logs = dict()","def _read_log(self):\n\n line_regex = compile(r\"\\[I\\]\\s*\\(\\d+ms\\)[^\\d]+(?P<counter>\\d+)\"\n r\"[^\\d]+(?P<timestamp>\\d+(\\.\\d+)?)[^\\d]+\"\n r\"(?P<acceleration>\\d+);\")\n values = []\n with open(self.filepath) as file:\n for line in file:\n match = line_regex.match(line)\n if match:\n values.append({\n 'counter':\n int(match['counter']),\n 'timestamp':\n int(float(match['timestamp']) * 1000),\n 'acceleration':\n int(match['acceleration'])\n })\n\n self.values = values","def _read_traces(self, unpack_headers=False, headonly=False,\n yield_each_trace=False):\n self.traces = []\n # Determine the filesize once.\n if isinstance(self.file, io.BytesIO):\n pos = self.file.tell()\n self.file.seek(0, 2) # go t end of file\n filesize = self.file.tell()\n self.file.seek(pos, 0)\n else:\n filesize = os.fstat(self.file.fileno())[6]\n # Big loop to read all data traces.\n i = -1\n while True:\n # Read and as soon as the trace header is too small abort.\n try:\n trace = SEGYTrace(self.file, self.data_encoding, self.endian,\n unpack_headers=unpack_headers,\n filesize=filesize, headonly=headonly)\n i += 1\n if yield_each_trace:\n yield trace\n else:\n if self.hdf_writer == 0:\n self.traces.append(trace)\n else:\n if headonly and not self.hdf_writer.need_writing:\n self.hdf_writer.count_of_traces += 1\n elif self.hdf_writer.need_writing:\n self.hdf_writer.add_trace(trace, i)\n else:\n self.traces.append(trace)\n\n except SEGYTraceHeaderTooSmallError:\n break","def run(self):\n LOG.debug(\"ReaderThread up and running\")\n\n lastevictTime = 0\n while ALIVE:\n for col in allLivingCollectors():\n for line in col.collect():\n self.processLine(col, line)\n now = int(time.time())\n if now - lastevictTime > self.evictinterval:\n lastevictTime = now\n now -= self.evictinterval\n for col in allCollectors():\n col.evictOldkeys(now)\n # BUGBUG : not good\n time.sleep(1)","def queryTCS():\n timestamp = datetime.datetime.now().isoformat()\n values = []\n for statusPiece in statusPieces:\n TN.write(statusPiece+\"\\r\\n\")\n value = TN.read_until(\"\\n\", 0.5)\n value = value.strip()\n if not value:\n value = \"?\"\n values.append(value)\n if values[2] == \"?\" or int(values[2]) != 2:\n return # only record if in tracking state\n with open(filename, \"a\") as f:\n f.write(\"%s %s %s %s %s %s\\n\"%tuple([timestamp]+values))","def thread_main(self, sess):\n for x_h, x_m, y in self.data_iterator():\n sess.run(self.enqueue_op, feed_dict={self.x_h:x_h, self.x_m:x_m, self.y:y})","def run(self):\n\n # driver=\"H5FD_CORE\" another driver for Solid State devs?\n theFile = tables.open_file(self.hdfFileName, \"w\")\n theFile.create_group(\"/\", \"transitionLogs\")\n theLog = theFile.create_earray(where=theFile.root,\n name=\"log\",\n atom=tables.StringAtom(itemsize=120),\n shape=(0,),\n title=\"log messages\",\n filters=tables.Filters(complevel=9,\n complib='zlib'))\n speciesTables = {}\n\n try:\n # do a loop!\n while True:\n try:\n msg = self.transitionsPipe.recv()\n # msg=messagequeue.get()\n except EOFError:\n break\n cmd = msg[0]\n if cmd == \"parameters\":\n # expect two dictionaries\n parameters, runParameters = msg[1], msg[2]\n\n if type(parameters) is dict:\n if \"/parameters\" in theFile:\n parameterTable = theFile.root.parameters\n else:\n parameterTable = theFile.create_table(\n \"/\",\n \"parameters\",\n HDFLoggingProcess.parameterTableFormat)\n parameterRow = parameterTable.row\n varTypeEnum = parameterTable.coldescrs[\"varType\"].enum\n varTypeDict = {int: varTypeEnum[\"INT\"],\n str: varTypeEnum[\"STR\"],\n float: varTypeEnum[\"FLOAT\"],\n bool: varTypeEnum[\"BOOL\"]}\n runType = varTypeEnum[\"RUN\"]\n\n for k, v in parameters.items():\n varType = varTypeDict[type(v)]\n parameterRow[\"varName\"] = str(k)\n parameterRow[\"varType\"] = varType\n parameterRow[\"varValue\"] = str(v)\n parameterRow.append()\n\n for k, v in runParameters.items():\n parameterRow[\"varName\"] = str(k)\n parameterRow[\"varType\"] = runType\n parameterRow[\"varValue\"] = str(v)\n parameterRow.append()\n\n parameterTable.close()\n del parameterRow, parameterTable\n elif type(parameters) is scenario:\n print(\"writing scenarios\")\n parameters.writeToHDF(theFile.root, 'scenario')\n else:\n print(\"unsupported type: {}\".format(type(parameters)))\n\n # need a table def and a transition log\n elif cmd == \"registerTransitionType\":\n # change lists to enumerations!\n # expect list of extra columns as msg[2]\n theColumns = {}\n for name, col in msg[2].items():\n if type(col) is dict:\n # this is an enumeration type used\n # for the from/to state\n col = tables.EnumCol(tables.Enum(col),\n \"start\",\n \"uint16\")\n elif type(col) is str:\n # column of type defined by string\n col = eval(col) # ToDo: remove eval\n theColumns[name] = col\n\n # gets species name and table format as dict\n transitions = type(\"transitions\",\n (tables.IsDescription,),\n theColumns)\n speciesTables[msg[1]] = theFile.create_table(\n \"/transitionLogs\",\n msg[1],\n transitions,\n filters=tables.Filters(\n complevel=9,\n complib=\"lzo\",\n least_significant_digit=3))\n\n elif cmd == \"changeFile\":\n # close tables and file\n for t in speciesTables.values():\n t.close()\n del t\n del speciesTables\n theLog.close()\n del theLog\n theFile.close()\n del theFile\n\n # set new file name\n self.hdfFileName = msg[1]\n # open new one\n # potentially a driver=\"H5FD_CORE\" ?\n theFile = tables.open_file(self.hdfFileName, \"w\")\n theFile.create_group(\"/\", \"transitionLogs\")\n theLog = theFile.create_earray(\n where=theFile.root,\n name=\"log\",\n atom=tables.StringAtom(itemsize=120),\n shape=(0,),\n title=\"log messages\",\n filters=tables.Filters(complevel=9,\n complib='zlib'))\n speciesTables = {}\n # expecting replay of species tables\n\n elif cmd == \"logTransition\":\n # gets species name and values in order as defined by the\n # table format\n # todo: check the format!\n table = speciesTables[msg[1]]\n row = table.row\n agentId, t1, t2, fromState, toState, effort = msg[2]\n row[\"agentId\"] = agentId\n row[\"timeStamp\"] = t2\n row[\"fromState\"] = fromState\n row[\"toState\"] = toState\n row[\"dwellTime\"] = t2-t1\n row[\"effort\"] = effort\n\n if len(msg) > 2:\n # are there any extra parameters?\n for name, value in msg[3].items():\n if type(value) is str:\n row[name] = numpy.array(value.encode(),\n dtype=\"S\")\n else:\n row[name] = value\n row.append()\n del table, row\n\n # also a progress table\n elif cmd == \"progress\":\n # if not there, create new table\n if \"/progress\" not in theFile:\n theFile.create_table(\n '/',\n 'progress',\n HDFLoggingProcess.hdfProgressTable)\n # add values as they are...\n theFile.root.progress.append([msg[1]])\n\n elif cmd == \"message\":\n theLog.append(numpy.array([str(msg[1])], dtype=\"S120\"))\n\n elif cmd == \"end\":\n break\n\n else:\n print(\"unknown type {}\".format(msg[0]))\n except:\n raise\n finally:\n # messagequeue.close()\n self.transitionsPipe.close()\n del self.transitionsPipe\n # print(\"finished \", messagepipe)\n # done, be pedantic about closing all resources\n for t in speciesTables.values():\n t.close()\n del t\n del speciesTables\n theLog.close()\n del theLog\n theFile.close()\n del theFile","def _store_rows(self):\n\n for value in self.values:\n self.counters.append(value['counter'])\n self.timestamps.append(value['timestamp'])\n self.acceleration.append(value['acceleration'])"],"string":"[\n \"def record_trace(self):\\n\\n tfname = str(int(time.time())) + \\\".obd2_reader.trace\\\"\\n self.tf_out = open(tfname, 'a')\\n self.RecordTrace = 1\\n print \\\"Recoding trace to:\\\", tfname\",\n \"def update_records(self):\\n impl.get_runtime().sync()\\n self.clear_frontend()\\n self._traced_records = impl.get_runtime(\\n ).prog.get_kernel_profiler_records()\",\n \"def process_spike_sim_log(spike_log, csv):\\n logging.info(\\\"Processing spike log : %s\\\" % spike_log)\\n instr_cnt = 0\\n spike_instr = \\\"\\\"\\n\\n RD_RE = re.compile(r\\\"(?P<pri>\\\\d) 0x(?P<addr>[a-f0-9]+?) \\\" \\\\\\n \\\"\\\\((?P<bin>.*?)\\\\) x\\\\s*(?P<reg>\\\\d*?) 0x(?P<val>[a-f0-9]+)\\\")\\n CORE_RE = re.compile(r\\\"core.*0x(?P<addr>[a-f0-9]+?) \\\\(0x(?P<bin>.*?)\\\\) (?P<instr>.*?)$\\\")\\n INSTR_RE = re.compile(r\\\"(?P<instr>[a-z\\\\.]+?)(\\\\s+?)(?P<operand>.*)\\\")\\n GPR_RE = re.compile(r\\\"^[a-z][0-9a-z]$\\\")\\n CSR_RE = re.compile(r\\\"csr\\\")\\n ILLE_RE = re.compile(r\\\"trap_illegal_instruction\\\")\\n\\n # Remove all the init spike boot instructions\\n cmd = (\\\"sed -i '/core.*0x0000000000001010/,$!d' %s\\\" % spike_log)\\n os.system(cmd)\\n # Remove all instructions after ecall (end of program excecution)\\n cmd = (\\\"sed -i '/ecall/q' %s\\\" % spike_log)\\n os.system(cmd)\\n\\n gpr = {}\\n gpr[\\\"zero\\\"] = 0\\n\\n with open(spike_log, \\\"r\\\") as f, open(csv, \\\"w\\\") as csv_fd:\\n trace_csv = RiscvInstructiontTraceCsv(csv_fd)\\n trace_csv.start_new_trace()\\n for line in f:\\n # Extract instruction infromation\\n m = CORE_RE.search(line)\\n if m:\\n spike_instr = m.group(\\\"instr\\\")\\n rv_instr_trace = RiscvInstructiontTraceEntry()\\n rv_instr_trace.instr_str = spike_instr\\n rv_instr_trace.addr = m.group(\\\"addr\\\")\\n rv_instr_trace.binary = m.group(\\\"bin\\\")\\n if spike_instr == \\\"wfi\\\":\\n trace_csv.write_trace_entry(rv_instr_trace)\\n continue\\n nextline = f.readline()\\n if nextline != \\\"\\\":\\n if ILLE_RE.search(nextline):\\n continue\\n m = RD_RE.search(nextline)\\n if m:\\n # Extract RD information\\n instr_cnt += 1\\n rv_instr_trace.rd = gpr_to_abi(\\\"x%0s\\\" % m.group(\\\"reg\\\"))\\n rv_instr_trace.rd_val = m.group(\\\"val\\\")\\n rv_instr_trace.privileged_mode = m.group(\\\"pri\\\")\\n gpr[rv_instr_trace.rd] = rv_instr_trace.rd_val\\n s = INSTR_RE.search(spike_instr)\\n if s:\\n rv_instr_trace.instr = s.group(\\\"instr\\\")\\n operand_str = s.group(\\\"operand\\\").replace(\\\" \\\", \\\"\\\")\\n if operand_str != \\\"\\\" :\\n operands = operand_str.split(\\\",\\\")\\n if CSR_RE.search(s.group(\\\"instr\\\")):\\n # CSR instruction\\n operand = operands[-1]\\n if GPR_RE.search(operand) or operand == \\\"zero\\\":\\n rv_instr_trace.rs1 = operand\\n rv_instr_trace.rs1_val = gpr[operand]\\n else:\\n rv_instr_trace.imm = operand\\n else:\\n # Non CSR instruction\\n for i in range(1, len(operands)):\\n operand = operands[i]\\n if GPR_RE.search(operand) or operand == \\\"zero\\\":\\n if i == 1:\\n rv_instr_trace.rs1 = operand\\n rv_instr_trace.rs1_val = gpr[operand]\\n else:\\n rv_instr_trace.rs2 = operands[i]\\n rv_instr_trace.rs2_val = gpr[operand]\\n else:\\n rv_instr_trace.imm = operand\\n trace_csv.write_trace_entry(rv_instr_trace)\\n logging.info(\\\"Processed instruction count : %d\\\" % instr_cnt)\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n #self.fl,\\n #self.ie,\\n self.read_from_memory(self.pc),\\n self.read_from_memory(self.pc + 1),\\n self.read_from_memory(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.register[i], end='')\\n\\n print()\",\n \"def parsetemp(dirname, name, time, computer):\\n with open(dirname+\\\"/\\\"+name) as f:\\n lines = f.read().split(\\\"\\\\n\\\")\\n\\n if len(lines) < 11:\\n return\\n\\n cpu = float(lines[9].split()[2])\\n mb = float(lines[10].split()[2])\\n\\n state = libcomputer.TState(time, cpu, mb)\\n computer.tstates.append(state)\",\n \"def get_raw_data(trace: Trace, cmdl_args):\\n # Retrieves states dataframe with the intresting columns\\n df_state = trace.df_state[[STATE_COLS.APP.value, STATE_COLS.TASK.value, STATE_COLS.THREAD.value, STATE_COLS.START.value,\\n STATE_COLS.END.value, STATE_COLS.VAL.value]]\\n\\n # Computes the elapse times of each state\\n df_state['el_time'] = df_state[STATE_COLS.END.value] - df_state[STATE_COLS.START.value]\\n\\n # Removes start and end columns from rows cause we don't need them. Load the data into memory.\\n df_state = df_state.drop(columns=[STATE_COLS.START.value, STATE_COLS.END.value]).compute()\\n\\n # Computes runtime (in us)\\n runtime = df_state.groupby([STATE_COLS.APP.value, STATE_COLS.TASK.value, STATE_COLS.THREAD.value])['el_time'].sum().max() / 1000\\n # Filters rows by useful and groups dataframe by process\\n df_state_useful_grouped = df_state.loc[df_state[STATE_COLS.VAL.value] == STATE_VALUES.RUNNING.value].groupby([STATE_COLS.APP.value, STATE_COLS.TASK.value, STATE_COLS.THREAD.value])\\n # Computes useful average time (in us)\\n useful_av = df_state_useful_grouped['el_time'].sum().mean() / 1000\\n # Computes useful max time (in us)\\n useful_max = df_state_useful_grouped['el_time'].sum().max() / 1000\\n # Computes useful tot time (in us)\\n useful_tot = df_state_useful_grouped['el_time'].sum().sum() / 1000\\n\\n # Dimemas simulation for ideal times\\n if cmdl_args.dimemas:\\n runtime_id, useful_id = get_ideal_data(trace.metadata.path, len(trace.metadata.cpu_list))\\n else:\\n runtime_id = float('NaN')\\n useful_id = float('NaN')\\n\\n\\n # Loads only meaningful columns from df_states and filters useful rows\\n df_state_useful = trace.df_state[[STATE_COLS.APP.value, STATE_COLS.TASK.value, STATE_COLS.THREAD.value, STATE_COLS.END.value, STATE_COLS.VAL.value]]\\n df_state_useful = df_state_useful.loc[df_state_useful[STATE_COLS.VAL.value] == STATE_VALUES.RUNNING.value].drop(columns=STATE_COLS.VAL.value).compute()\\n\\n # Loads only meaningful columns from df_events\\n df_event = trace.df_event[[EVENT_COLS.APP.value, EVENT_COLS.TASK.value, EVENT_COLS.THREAD.value, EVENT_COLS.TIME.value,\\n EVENT_COLS.EVTYPE.value, EVENT_COLS.EVVAL.value]]\\n\\n # Filters for PAPI_TOT_INS and set as index the process identifier\\n df_event_ins = df_event.loc[df_event[EVENT_COLS.EVTYPE.value] == EVENT_VALUES.PAPI_TOT_INS.value].drop(columns=EVENT_COLS.EVTYPE.value).compute().set_index([EVENT_COLS.APP.value, EVENT_COLS.TASK.value, EVENT_COLS.THREAD.value])\\n\\n # Gets total useful instructions by grouping and applying a custom filtering function\\n useful_ins = df_event_ins.groupby([EVENT_COLS.APP.value,EVENT_COLS.TASK.value, EVENT_COLS.THREAD.value]).apply(is_useful, useful_states=df_state_useful)[EVENT_COLS.EVVAL.value].sum()\\n\\n # Filter for PAPI_TOT_CYC and set as indexes the process identifier\\n df_event_cyc = df_event.loc[df_event[EVENT_COLS.EVTYPE.value] == EVENT_VALUES.PAPI_TOT_CYC.value].drop(columns=EVENT_COLS.EVTYPE.value).compute().set_index([EVENT_COLS.APP.value, EVENT_COLS.TASK.value, EVENT_COLS.THREAD.value])\\n\\n # Gets total useful cycles by grouping and applying a custom filtering function\\n useful_cyc= df_event_cyc.groupby([EVENT_COLS.APP.value,EVENT_COLS.TASK.value, EVENT_COLS.THREAD.value]).apply(is_useful, useful_states=df_state_useful)[EVENT_COLS.EVVAL.value].sum()\\n\\n # Computes average IPC\\n try:\\n ipc = useful_ins / useful_cyc\\n except ValueError:\\n ipc = float('NaN')\\n # Computes average frequency\\n try:\\n freq = useful_cyc / useful_tot / 1000\\n except ValueError:\\n freq = float('NaN')\\n\\n return ipc, freq, runtime, runtime_id, useful_av, useful_max, useful_tot, useful_id, useful_ins, useful_cyc\",\n \"def trace_context(n):\\n # Drop the first four lines: the clock speed, the threshold, and the first\\n # active/inactive pair.\\n for line in runcmd([TRACE, n]).splitlines()[2:]:\\n if len(line.strip()) is 0:\\n continue\\n m = re.search(r'^PID: (\\\\d+).*start at (\\\\d+).*\\\\(([\\\\d\\\\.]+) ms\\\\)', line)\\n if not m:\\n print line\\n yield (int(m.group(1)), int(m.group(2)), float(m.group(3)))\",\n \"def exec_time_processor(self):\\n with open(join(self.logs_dir, \\\"clock_time.dat\\\"), 'w') as fh:\\n fh.write(\\\"Time ExecutionTime ClockTime\\\\n\\\")\\n while True:\\n rexp = (yield)\\n fh.write(self.time_str + \\\"\\\\t\\\" +\\n \\\"\\\\t\\\".join(x for x in rexp.groups()) + \\\"\\\\n\\\")\\n self._tick = True\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n #self.fl,\\n #self.ie,\\n self.memory_read(self.pc),\\n self.memory_read(self.pc + 1),\\n self.memory_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.registers[i], end='')\\n\\n print()\",\n \"def inner():\\n for line in file_obj:\\n logdata = tilak_haproxylog.parse_line(line)\\n if logdata is not None:\\n logdata[\\\"hits\\\"] = 1\\n for value_key in value_keynames:\\n if value_key not in logdata:\\n logdata[value_key] = 0\\n status_code = int(logdata[\\\"status_code\\\"])\\n if 100 <= status_code <= 199:\\n logdata[\\\"rsp_1xx\\\"] = 1\\n elif 200 <= status_code <= 299:\\n logdata[\\\"rsp_2xx\\\"] = 1\\n elif 300 <= status_code <= 399:\\n logdata[\\\"rsp_3xx\\\"] = 1\\n elif 400 <= status_code <= 499:\\n logdata[\\\"rsp_4xx\\\"] = 1\\n elif 500 <= status_code <= 599:\\n logdata[\\\"rsp_5xx\\\"] = 1\\n else:\\n logdata[\\\"rsp_other\\\"] = 1\\n ret_data = dict(zip(index_keynames, (logdata[index_key] for index_key in index_keynames)))\\n ret_data.update(dict(zip(value_keynames, (logdata[value_key] for value_key in value_keynames))))\\n yield (logdata[\\\"ts\\\"], ret_data)\",\n \"def process_timestamps(self):\\n self.conn = sqlite3.connect(':memory:')\\n self.cursor = self.conn.cursor()\\n self.cursor.execute('CREATE TABLE tracklog(dt PRIMARY KEY, lat REAL, lon REAL, elev REAL)')\\n num_points = 0\\n for d in gps.parse_gpx_iter(self.gpx_file):\\n self.cursor.execute('INSERT INTO tracklog VALUES(?,?,?,?)', d)\\n num_points += 1\\n sys.stderr.write('The GPX file contained %d Points\\\\n' % num_points)\\n self.conn.commit()\",\n \"def flush():\\n global CACHE, STATS_KEYS_COUNT\\n CACHE = {}\\n STATS_KEYS_COUNT = 0\",\n \"def flush(self):\\n # Create the cache path\\n CachedXMLNode.create_cache_path()\\n FindingsCache.create_cache_path()\\n\\n # Create the context\\n context = dotdict({})\\n\\n try:\\n self._add_scan_status_to_context(context)\\n except RuntimeError, rte:\\n # In some very strange scenarios we get this error:\\n #\\n # Can NOT call get_run_time before start()\\n #\\n # Just \\\"ignore\\\" this call to flush and write the XML in the next call\\n msg = 'xml_file.flush() failed to add scan status to context: \\\"%s\\\"'\\n om.out.debug(msg % rte)\\n return\\n\\n self._add_root_info_to_context(context)\\n self._add_scan_info_to_context(context)\\n self._add_findings_to_context(context)\\n self._add_errors_to_context(context)\\n\\n # Write to file\\n self._write_context_to_file(context)\",\n \"def save_state(self):\\n\\t\\tf = open('output.csv', 'a')\\n\\t\\tstate = ';'.join([str(datetime.now()), str(self.thin._actuation_value), str(self.thin.temperature), str(self.thin.presence), str(self.outside.temperature)])\\n\\t\\tprint(state)\\n\\t\\tf.write(state + '\\\\n')\\n\\t\\tf.close()\",\n \"def log_stats(self):\\n while True:\\n for stats in self.stats.values():\\n stats.log_stats()\\n\\n yield from asyncio.sleep(stats_delay)\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n #self.fl,\\n #self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.mem[i], end='')\\n\\n print()\",\n \"def _flush(self):\\n for x in xrange(0,10):\\n self._eng.iterate()\",\n \"def trace(self):\\n\\n print(\\n f\\\"TRACE: {self.pc} | {self.ram_read(self.pc)} {self.ram_read(self.pc + 1)} {self.ram_read(self.pc + 2)} |\\\")\\n\\n for i in range(8):\\n print(f\\\"R[{i}] is {self.reg[i]}\\\")\\n\\n print()\",\n \"def flush_on_term(self):\\n self.influx.flush()\",\n \"def loadts(args):\\n # writing and reading pickle are both about 10x faster than reading csv\\n # hence, simplify repeated execs by providing pickle file\\n time_before = time.time()\\n # timestart = time.time()\\n d = dict() # dictionary of numpy arrays that hold timestamps per IP\\n p = dict() # dictionary of IPs, holding # timestamps per IP\\n offset = dict() # dict to hold tsval offset per IP\\n\\n try:\\n pklfile = open(args.tsfile + \\\".pickle\\\", 'rb')\\n d, p, offset = pickle.load(pklfile)\\n pklfile.close()\\n except:\\n print(\\\"TS pickle loading failed, loading from csv\\\")\\n logging.debug(\\\"TS pickle loading failed, loading from csv\\\")\\n with open(args.tsfile, \\\"r\\\") as csvfile:\\n datareader = csv.reader(csvfile)\\n count = 0\\n for row in datareader:\\n count += 1\\n try:\\n ip = row[0]\\n tcpt = row[1]\\n recvt = row[2]\\n except:\\n print(\\\"Error in line \\\" + str(count) + \\\"of \\\" + str(args.tsfile) + \\\", skipping.\\\")\\n logging.error(\\\"Error in line \\\" + str(count) + \\\"of \\\" + str(args.tsfile) + \\\", skipping.\\\")\\n continue\\n if ip in d:\\n if p[ip] == 9999:\\n d[ip].resize(100 * 1000, 2)\\n if p[ip] > (100 * 1000) - 1: # more than 100k measurements can not be a target host\\n continue\\n if ip in offset:\\n # recv_t is zero-based and scaled to be in seconds precision\\n d[ip][p[ip], :] = \\\\\\n [np.float64(tcpt),\\n np.float64(np.uint64(recvt) - np.uint64(offset[ip])) / np.float64(1000.0 * 1000.0)]\\n p[ip] = p[ip] + 1\\n else:\\n print(\\\"ip not in offset dict (should never happen, exiting): \\\" + str(ip))\\n sys.exit(1)\\n else: # ip is not in d, i.e. has not been seen before\\n d[ip] = np.zeros((10000, 2), dtype=np.float64)\\n p[ip] = 0\\n d[ip][p[ip], :] = [np.float64(tcpt), np.float64(0.0)]\\n p[ip] += 1\\n offset[ip] = recvt\\n logging.debug(\\\"timestamp np structure built after: {}, count: {} {} {}\\\".format(time.time() - time_before, count, len(d), len(p)))\\n # resize all to correct length (removes trailing zeroes)\\n for ip, value in p.items():\\n d[ip].resize((p[ip], 2))\\n\\n pklfile = open(args.tsfile + \\\".pickle\\\", 'wb')\\n pickle.dump([d, p, offset], pklfile)\\n pklfile.close()\\n print(\\\"ts data loaded in {} seconds, # IP addresses: {} \\\".format(round(time.time() - time_before, 2), len(d)))\\n logging.debug(\\\"ts data loaded in {} seconds, # IP addresses: {} \\\".format(round(time.time() - time_before, 2), len(d)))\\n return d, p, offset\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n #self.fl,\\n #self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.register[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n #self.fl,\\n #self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.register[i], end='')\\n\\n print()\",\n \"def read_trace(self, trace):\\n csv_reader = csv.DictReader(self.csv_fd)\\n for row in csv_reader:\\n new_trace = RiscvInstructiontTraceEntry()\\n new_trace.rd = row['rd']\\n new_trace.rd_val = row['rd_val']\\n new_trace.addr = row['addr']\\n new_trace.binary = row['binary']\\n new_trace.instr_str = row['str']\\n trace.append(new_trace)\",\n \"def _push(self):\\n if len(self._stat_now):\\n self._stat_now['epoch_num'] = self.epoch_num\\n self._stat_now['global_step'] = self.global_step\\n\\n self._stats.append(self._stat_now)\\n self._stat_now = {}\\n self._write_stat()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n # self.fl,\\n # self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.register[i], end='')\\n\\n print()\",\n \"def _flush_stats(self, train=True):\\n\\t\\tif train:\\n\\t\\t\\tself.train_accuracy.flush_buffer()\\n\\t\\t\\tself.train_epochs.flush_buffer()\\n\\t\\t\\tself.train_loss.flush_buffer()\\n\\t\\t\\tself.train_confusion_matrix.flush_buffer()\\n\\t\\t\\tself.learning_rate.flush_buffer()\\n\\t\\telse:\\n\\t\\t\\tself.val_accuracy.flush_buffer()\\n\\t\\t\\tself.val_epochs.flush_buffer()\\n\\t\\t\\tself.val_loss.flush_buffer()\\n\\t\\t\\tself.val_confusion_matrix.flush_buffer()\\n\\n\\t\\tif self.plot:\\n\\t\\t\\tself._plot(train=train)\",\n \"def execute(self, args: Namespace):\\n data = {}\\n\\n with open(args.data, 'r') as file:\\n reader = csv.reader(file, delimiter=';')\\n\\n for row in reader:\\n if reader.line_num == 1:\\n if 'Timestamp, Decimal, TriState, State' != ','.join(row):\\n print('Not a valid CSV file!')\\n return\\n\\n else:\\n dt = datetime.strptime(row[0], '%Y-%m-%d %H:%M:%S.%f')\\n value = tri_state_value(row[2])\\n device = data.setdefault(tri_state_device(row[2].strip()), {})\\n device.setdefault(dt.date(),[]).append((dt.strftime('%H:%M'), value))\\n\\n for k in sorted(data.keys()):\\n device = data[k]\\n print('Device {}:'.format(tint_yellow(k)))\\n\\n for d in sorted(device.keys()):\\n device[d].sort(key=lambda x: x[0])\\n print('\\\\t{}:'.format(tint_blue(d)))\\n\\n for (t, v) in device[d]:\\n if v:\\n print('\\\\t\\\\tAt {} the device was turned {}.'.format(tint_blue(t),\\n tint_green('ON')))\\n else:\\n print('\\\\t\\\\tAt {} the device was turned {}.'.format(tint_blue(t),\\n tint_red('OFF')))\",\n \"def preproc_data(base_dir):\\n n_users = 182\\n user_datas = []\\n\\n for user in tqdm(range(n_users)): \\n #iterate through each trace of user \\n user_traces = []\\n if (len(str(user)) == 1): \\n user_id = '00' + str(user)\\n elif (len(str(user)) == 2): \\n user_id = '0' + str(user)\\n else: \\n user_id = str(user)\\n dir_name = base_dir + user_id + '/Trajectory/'\\n for filename in os.listdir(dir_name): \\n #load trajectory\\n trajectory_raw = pd.read_csv(\\n dir_name + filename,\\n delimiter = ',', header = None, skiprows = 6,\\n names = ['lat','lon', '0', 'altitude', 't_1899', 'date', 'time' ])\\n\\n #modify time\\n traj = trajectory_raw.copy()\\n traj.drop(columns = '0', inplace = True)\\n\\n traj['t_1899'] = (trajectory_raw['t_1899'] - trajectory_raw['t_1899'].values[0]) * 24 * 60 * 60\\n traj_newcols = np.array(traj.columns)\\n traj_newcols[traj_newcols == 't_1899'] = 'seconds'\\n traj.columns = traj_newcols\\n\\n #get X_vals: \\n R_earth = 6.371e6\\n deg_to_rad = np.pi / 180\\n traj['X'] = R_earth * np.cos(deg_to_rad * traj['lat'].values) * np.cos(deg_to_rad * traj['lon'].values)\\n traj['Y'] = R_earth * np.cos(deg_to_rad * traj['lat'].values) * np.sin(deg_to_rad * traj['lon'].values)\\n\\n #Normalize to first point: \\n origin_x = traj['X'].values[0]\\n origin_y = traj['Y'].values[0]\\n\\n traj['X'] = traj['X'] - origin_x\\n traj['Y'] = traj['Y'] - origin_y\\n\\n txy = traj.copy()\\n txy = traj[['seconds', 'X', 'Y']]\\n txy.columns = ['T', 'X', 'Y']\\n if not np.isnan(txy.values).any(): \\n user_traces.append(txy.values)\\n\\n user_datas.append(user_traces)\\n return user_datas\",\n \"def save_scopeTraces(fileName, scope, channel, noPulses):\\n scope._get_preamble(channel)\\n results = utils.PickleFile(fileName, 1)\\n results.add_meta_data(\\\"timeform_1\\\", scope.get_timeform(channel))\\n\\n #ct = scope.acquire_time_check()\\n #if ct == False:\\n # print 'No triggers for this data point. Will skip and set data to 0.'\\n # results.save()\\n # results.close()\\n # return False\\n\\n t_start, loopStart = time.time(),time.time()\\n for i in range(noPulses):\\n try:\\n ct = scope.acquire_time_check(timeout=.4)\\n results.add_data(scope.get_waveform(channel), 1)\\n except Exception, e:\\n print \\\"Scope died, acquisition lost.\\\"\\n print e\\n if i % 100 == 0 and i > 0:\\n print \\\"%d traces collected - This loop took : %1.1f s\\\" % (i, time.time()-loopStart)\\n loopStart = time.time()\\n print \\\"%d traces collected TOTAL - took : %1.1f s\\\" % (i, (time.time()-t_start))\\n results.save()\\n results.close()\\n return True\",\n \"def generate_csv(self, context): # pylint: disable=R0912,R0914\\n temp = self.percentage()\\n total_state = self.unique_freq()\\n offline_value = -1\\n ghz_conversion = 1000000\\n mhz_conversion = 1000\\n with open(self.outfile, 'a+') as f:\\n writer = csv.writer(f, delimiter=',')\\n reader = csv.reader(f)\\n # Create the header in the format below\\n # workload name, iteration, state, A7 CPU0,A7 CPU1,A7 CPU2,A7 CPU3,A15 CPU4,A15 CPU5\\n if sum(1 for row in reader) == 0:\\n header_row = ['workload', 'iteration', 'state']\\n count = 0\\n for cluster, states_list in enumerate(self.currentstates_of_clusters):\\n for dummy_index in range(len(states_list)):\\n header_row.append(\\\"{} CPU{}\\\".format(self.corename_of_clusters[cluster], count))\\n count += 1\\n writer.writerow(header_row)\\n if offline_value in total_state:\\n total_state.remove(offline_value) # remove the offline state\\n for i in sorted(total_state):\\n temprow = []\\n temprow.extend([context.result.spec.label, context.result.iteration])\\n if \\\"state{}\\\".format(i) in self.idlestate_description:\\n temprow.append(self.idlestate_description[\\\"state{}\\\".format(i)])\\n else:\\n state_value = float(i)\\n if state_value / ghz_conversion >= 1:\\n temprow.append(\\\"{} Ghz\\\".format(state_value / ghz_conversion))\\n else:\\n temprow.append(\\\"{} Mhz\\\".format(state_value / mhz_conversion))\\n for j in range(self.device.number_of_cores * self.multiply_factor):\\n temprow.append(\\\"{0:.3f}\\\".format(temp[\\\"cpu{}\\\".format(j)][i]))\\n writer.writerow(temprow)\\n check_off = True # Checking whether core is OFFLINE\\n for i in range(self.device.number_of_cores * self.multiply_factor):\\n temp_val = \\\"{0:.3f}\\\".format(temp[\\\"cpu{}\\\".format(i)][offline_value])\\n if float(temp_val) > 1:\\n check_off = False\\n break\\n if check_off is False:\\n temprow = []\\n temprow.extend([context.result.spec.label, context.result.iteration])\\n temprow.append(\\\"OFFLINE\\\")\\n for i in range(self.device.number_of_cores * self.multiply_factor):\\n temprow.append(\\\"{0:.3f}\\\".format(temp[\\\"cpu{}\\\".format(i)][offline_value]))\\n writer.writerow(temprow)\",\n \"def batch_data(data, state_queue):\\n while True:\\n time.sleep(BATCH_SLEEP_TIME)\\n state_queue.put((\\\"device_values\\\", [data]))\",\n \"def run(self):\\n\\t\\tself._data_updater_thread.start()\\n\\t\\tf = open('output.csv', 'w') #TODO: handle output file correctly (cfg)\\n\\t\\tf.write('(datetime;valve;thin_temp;thin_pres;out_temp)\\\\n')\\n\\t\\tf.close()\",\n \"def step1(step1_input, step1_output, map_file):\\n\\n logger.info(\\\"###Step 1:\\\")\\n graf = defaultdict(dict)\\n start = clock()\\n #create brands-website map dictionsry\\n website_map = {}\\n with open(map_file) as csv_file:\\n rdr = csv.DictReader(csv_file)\\n for row in rdr:\\n website_map[re.sub('[.,;:]', '', row['BrandName'])] = row['Website'] \\n check_time(start, \\\"populate website_map\\\")\\n #gather graph data \\n start1 = clock()\\n with open(step1_input, 'rb') as csv_file:\\n rdr = csv.reader(csv_file)\\n check_time(start1, \\\"Reading input file...\\\")\\n header = rdr.next()\\n start_gather = clock()\\n for row in rdr:\\n one_list = [i for i,x in enumerate(row) if x == '1']\\n for pos in one_list:\\n pos_idx = one_list.index(pos)\\n try:\\n site = website_map[header[pos_idx]]\\n except KeyError:\\n site = header[pos_idx]\\n for other_pos in one_list[pos_idx+1:]:\\n other_pos_idx = one_list.index(other_pos)\\n try:\\n other_site = website_map[header[other_pos_idx]]\\n except KeyError:\\n other_site = header[other_pos_idx]\\n try:\\n graf[site][other_site] += 1\\n except KeyError:\\n graf[site][other_site] = 1\\n check_time(start_gather, \\\"Done gathering data...\\\")\\n start_write = clock()\\n write_to_file(step1_output, graf)\\n check_time(start_write, \\\"Done writing output file.\\\")\\n check_time(start1, \\\"Step 1 end...\\\")\\n return 0\",\n \"def parse_trace(self):\\n current = '' # current basic block being parsed\\n previous = '0' # previous basic block beding parsed\\n edge_count = 0\\n uniq_count = 0\\n with open(self._fifo_name, 'r') as fifo:\\n for line in fifo:\\n if line[6] == '4':\\n continue\\n # process traceed tbs\\n current = line.split(':')[0]\\n\\n parse_edge = (previous, current)\\n edge_count += 1\\n if not parse_edge in TRACE_EDGES:\\n TRACE_EDGES.add(parse_edge)\\n uniq_count += 1\\n previous = current\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n #self.fl,\\n #self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n #self.fl,\\n #self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n #self.fl,\\n #self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n #self.fl,\\n #self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n #self.fl,\\n #self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n #self.fl,\\n #self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n #self.fl,\\n #self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n #self.fl,\\n #self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n #self.fl,\\n #self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def _flush(self):\\n self._d = {}\",\n \"def do_tick(self):\\n\\n notifications.clear_received()\\n last_rounds_notifications = notifications.get_last()\\n notifications.clear()\\n self.turn += 1\\n actions = [actor.tick_action(last_rounds_notifications) for actor in self.actors]\\n for action in actions:\\n action()\\n\\n number_notifications = len(last_rounds_notifications.get())\\n active_interventions = len(CityMap.get_interventions())\\n self._csv_log([\\n self.turn,\\n number_notifications,\\n notifications.received,\\n active_interventions,\\n CityMap.moves,\\n len(self.get_ambulances()),\\n len(self.get_policemen()),\\n CityMap.ambulance_moves,\\n CityMap.policeman_moves,\\n len(self.intervening_policemen()),\\n len(self.patroling_policemen()),\\n len(self.assisting_ambulances())\\n ]\\n )\\n\\n CityMap.clear_moves()\",\n \"def start_new_trace(self):\\n fields = [\\\"instr\\\", \\\"rd\\\", \\\"rd_val\\\", \\\"rs1\\\", \\\"rs1_val\\\", \\\"rs2\\\", \\\"rs2_val\\\",\\n \\\"imm\\\", \\\"str\\\", \\\"addr\\\", \\\"binary\\\", \\\"csr\\\", \\\"mode\\\"]\\n self.csv_writer = csv.DictWriter(self.csv_fd, fieldnames=fields)\\n self.csv_writer.writeheader()\",\n \"def processMachineLog(file_name):\\n\\n # labelling of data lists\\n date = []\\n timeDay = []\\n iteration = []\\n iterationTime = [] # time it takes to complete a single cycle\\n timeElapsed = [] # time elapsed since start of test for the day\\n \\n \\\"\\\"\\\" sample of important lines from log\\n ##### Begin Iteration # 1 at Wed Jan 27 16:32:27 EST 2016\\n ##### Completed Iteration # 1 time: 13.643001secs Total time: 13.648001secs at Wed Jan 27 16:32:41 EST 2016\\n \\\"\\\"\\\"\\n\\n # opens csv file and sorts the data into the lists\\n # with open(file_name, 'rb') as csvfile:\\n with open(file_name, 'rb') as logFile:\\n data = logFile.readlines()\\n for line in data:\\n if line.startswith(\\\"##### Completed\\\"):\\n iteration.append(line.split(\\\" \\\")[4])\\n iterationTime.append(line.split(\\\" \\\")[7][:-4]) # remove \\\"secs\\\" from the value\\n # Get the Day of week, month, and date to put into date list\\n dayMoDate = line.split(\\\" \\\")[14] + \\\" \\\" + line.split(\\\" \\\")[15] + \\\" \\\" + line.split(\\\" \\\")[16] + \\\" \\\" + line.split(\\\" \\\")[19].rstrip()\\n date.append(dayMoDate)\\n # get the time in AM/PM format (because Jess can't read 24HR format to save her life)\\n convertTime = time.strftime(\\\"%I:%M:%S %p\\\", (time.strptime(line.split(\\\" \\\")[17] , \\\"%H:%M:%S\\\")))\\n timeDay.append(convertTime)\\n # get the total time (H:M:S format) that has elapsed since the beginning of the test\\n timeSecs = float(line.split(\\\" \\\")[11][:-4]) # remove \\\"secs\\\" from the value\\n timeElapsed.append(datetime.timedelta(seconds=timeSecs))\\n \\n # form the dataframe with all the lists as columns\\n df = pd.DataFrame({'Date': date, 'Time': timeDay, 'Cycle': iteration, 'Cycle Duration': iterationTime, 'Time Elapsed': timeElapsed})\\n return df\",\n \"def _trigger(self):\\n if len(self._stat_now):\\n self._stat_now['epoch_num'] = self.epoch_num\\n self._stat_now['global_step'] = self.global_step\\n\\n self._stats.append(self._stat_now)\\n self._stat_now = {}\\n self._write_stat()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n # self.fl,\\n # self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n # self.fl,\\n # self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n # self.fl,\\n # self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n # self.fl,\\n # self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n # self.fl,\\n # self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n # self.fl,\\n # self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n # self.fl,\\n # self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n # self.fl,\\n # self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n # self.fl,\\n # self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n # self.fl,\\n # self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n # self.fl,\\n # self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def _main_process(hashtags, start_ndx):\\r\\n\\tglobal timekeeper, total_inserted, half_hour_timer\\r\\n\\t\\r\\n\\tlogging.error('Total # of hashtags: {0}'.format(len(hashtags)))\\r\\n\\r\\n\\tndx = 0 + start_ndx\\r\\n\\tfor hashtag in hashtags:\\r\\n\\r\\n\\t\\thashtag = hashtag.hashtag.encode('utf-8')\\r\\n\\r\\n\\t\\tlogging.error('-------#{0}: {1}--------'.format(ndx, hashtag))\\r\\n\\r\\n\\t\\tmax_time = random.randint(10, 100)\\r\\n\\t\\tif time.time() - timekeeper >= max_time:\\r\\n\\t\\t\\tsleep_time = random.randint(7, 15)\\r\\n\\t\\t\\tlogging.error('Sleeping for {0}s. Max time: {1}...'.format(sleep_time, max_time))\\r\\n\\t\\t\\ttime.sleep(sleep_time)\\r\\n\\t\\t\\ttimekeeper = time.time()\\r\\n\\r\\n\\t\\tif time.time() - half_hour_timer >= 1800:\\r\\n\\t\\t\\tsleep_time = 300\\r\\n\\t\\t\\tlogging.error('Sleeping for *5 minutes*....')\\r\\n\\t\\t\\ttime.sleep(sleep_time)\\r\\n\\t\\t\\thalf_hour_timer = time.time()\\r\\n\\r\\n\\t\\ttry:\\r\\n\\t\\t\\t_process_hashtag(hashtag)\\r\\n\\t\\texcept requests.exceptions.SSLError as e:\\r\\n\\t\\t\\tlogging.error(e)\\r\\n\\t\\t\\ttime.sleep(20)\\r\\n\\t\\t\\t_process_hashtag(hashtag)\\r\\n\\t\\texcept Exception as e:\\r\\n\\t\\t\\tlogging.error('******** EXTREME ERROR ********')\\r\\n\\t\\t\\tlogging.error(e)\\r\\n\\t\\t\\tlogging.error('...... skipping hashtag \\\"{0}\\\".....'.format(hashtag))\\r\\n\\t\\t\\ttime.sleep(300)\\r\\n\\t\\t\\tcontinue\\r\\n\\r\\n\\t\\tndx += 1\\r\\n\\r\\n\\tlogging.error('total_inserted = {0}'.format(total_inserted))\",\n \"def trace(self):\\n\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n # self.flag,\\n #self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n # self.fl,\\n # self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def trace(self):\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n # self.fl,\\n #self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\\n\\n print()\",\n \"def run(self):\\n self.timestamp['start'] = datetime.datetime.now().strftime('%Y%m%dT%H%M%S')\\n\\n for point in self._prepare_grid():\\n graph = self._prepare_graph(**point)\\n env = self._prepare_env(graph, **point)\\n log = self._prepare_logger(graph, env, **point)\\n\\n try:\\n env.run(until=self.runtime)\\n except Exception as e:\\n print(e)\\n log.close()\\n\\n # self.timestamp[grid.hash_grid_point(point)].append(datetime.datetime.now().strftime('%Y%m%dT%H%M%S'))\\n\\n self.timestamp['end'] = datetime.datetime.now().strftime('%Y%m%dT%H%M%S')\",\n \"def trace(self):\\n print(f\\\"TRACE: %02X | %02X %02X %02X |\\\" % (\\n self.pc,\\n # self.fl,\\n # self.ie,\\n self.ram_read(self.pc),\\n self.ram_read(self.pc + 1),\\n self.ram_read(self.pc + 2)\\n ), end='')\\n\\n for i in range(8):\\n print(\\\" %02X\\\" % self.reg[i], end='')\",\n \"def tick(self):\\n self.world.tick()\\n # self.world_snapshot = self.world_queue.get(timeout=60.0)\\n # Update data structures for the current frame.\\n current_actors = set(\\n [vehicle.id for vehicle in self.world.get_actors().filter('vehicle.*')])\\n self.spawned_actors = current_actors.difference(self._active_actors)\\n self.destroyed_actors = self._active_actors.difference(current_actors)\\n self._active_actors = current_actors\\n\\n world_snapshot = self.world.get_snapshot()\\n for v in current_actors:\\n line = '{:06},{},{:d}' + ',{:.3f}' * 9\\n tf = world_snapshot.find(v).get_transform()\\n vehicle = self.world.get_actor(v)\\n extent = vehicle.bounding_box.extent\\n type_id = vehicle.type_id\\n line = line.format(world_snapshot.frame, type_id, v,\\n tf.location.x, tf.location.y, tf.location.z,\\n tf.rotation.roll, tf.rotation.pitch, tf.rotation.yaw,\\n extent.x * 2, extent.y * 2, extent.z * 2)\\n self.file_writer.writerow(line.split(','))\\n\\n self.synchronize_sensors()\",\n \"def run(self):\\n lineage_csv_gz = self.input_files_local[0][0]\\n output_db = self.output_files_local()[0]\\n log.write(f\\\"input: {lineage_csv_gz} output: {output_db}\\\")\\n\\n with IdSeqDictForUpdate(output_db, IdSeqDictValue.VALUE_TYPE_ARRAY) as lineage_dict:\\n batch_list = {}\\n with gzip.open(lineage_csv_gz, \\\"rt\\\") as gzf:\\n for line in gzf:\\n fields = line.rstrip().split(\\\",\\\")\\n taxid = fields[0]\\n species, genus, family = fields[-1:-4:-1]\\n batch_list[taxid] = [species, genus, family]\\n if len(batch_list) >= BATCH_INSERT_SIZE:\\n lineage_dict.batch_inserts(batch_list.items())\\n batch_list = {}\\n lineage_dict.batch_inserts(batch_list.items())\",\n \"def save_scopeTraces_Multiple(fileNames, scope, channels, noPulses):\\n results = []\\n for i in range(len(fileNames)):\\n\\t scope._get_preamble(channels[i])\\n\\t results.append(utils.PickleFile(fileNames[i], 1))\\n\\t results[i].add_meta_data(\\\"timeform_1\\\", scope.get_timeform(channels[i]))\\n\\n #ct = scope.acquire_time_check()\\n #if ct == False:\\n # print 'No triggers for this data point. Will skip and set data to 0.'\\n # results.save()\\n # results.close()\\n # return False\\n\\n t_start, loopStart = time.time(),time.time()\\n for i in range(noPulses):\\n try:\\n ct = scope.acquire_time_check(timeout=.4)\\n for j in range(len(results)):\\n\\t\\t results[j].add_data(scope.get_waveform(channels[j]), 1)\\n except Exception, e:\\n print \\\"Scope died, acquisition lost.\\\"\\n print e\\n if i % 100 == 0 and i > 0:\\n print \\\"%d traces collected - This loop took : %1.1f s\\\" % (i, time.time()-loopStart)\\n loopStart = time.time()\\n print \\\"%d traces collected TOTAL - took : %1.1f s\\\" % (i, (time.time()-t_start))\\n for i in range(len(results)):\\n\\t results[i].save()\\n return True\",\n \"def _storePerfStats(self, results):\\n self.state = ZenProcessTask.STATE_STORE_PERF\\n byConf = reverseDict(self._deviceStats._pidToProcess)\\n for procStat, pids in byConf.iteritems():\\n if len(pids) != 1:\\n log.debug(\\\"There are %d pids by the name %s - %s\\\",\\n len(pids), procStat._config.name, procStat._config.originalName)\\n procName = procStat._config.name\\n for pid in pids:\\n if not AS400PLUG in self._device.zCollectorPlugins:\\n cpu = results.get(CPU + str(pid), None)\\n else:\\n cpu = results.get(AS400CPU + str(pid), None) / 10 ## as we get millis vs centis\\n mem = results.get(MEM + str(pid), None)\\n procStat.updateCpu(pid, cpu)\\n procStat.updateMemory(pid, mem)\\n self._save(procName, 'cpu_cpu', procStat.getCpu(),\\n 'DERIVE', min=0)\\n self._save(procName, 'mem_mem',\\n procStat.getMemory() * 1024, 'GAUGE')\\n return results\",\n \"def log(self):\\n f = open(self.log_dir + 'parsed.log', 'a')\\n try:\\n # Write: local time | CurrentCost \\\"time\\\" | id | temp/C | power/W \\n f.write(\\\"%s\\\\t%s\\\\t%s\\\\t%s\\\\t%s\\\\n\\\" \\n % (self.ts('now'), self.ts('cc'), self.id, self.temp, self.watts))\\n finally:\\n f.close()\",\n \"def test_state(self):\\n # blocks [0 3583] [3840 4058]\\n test_file1 = os.path.join(INPUT_HYPM_PATH, 'unit_364-2013-206-2-0.mdd')\\n # blocks [0 1279] [1536 1791] [2048 2303] [2560 2815] [3072 4059]\\n test_file2 = os.path.join(INPUT_HYPM_PATH, 'unit_364-2013-206-3-0.mdd')\\n\\n # parse the two .mdd files into the node and instrument group files\\n mdd.procall([test_file1, test_file2])\\n\\n file_state = self.get_file_state('node58p1.dat')\\n # there is an unprocessed '/n' in between records\\n expected_file_state = {StateKey.UNPROCESSED_DATA: [[4059, 4060]],\\n StateKey.FILE_SIZE: 4060,\\n StateKey.OUTPUT_INDEX: 1}\\n\\n if file_state != expected_file_state:\\n print file_state\\n self.fail(\\\"Expected file state 1 does not match\\\")\\n\\n # blocks [0 2047] [2304 4095] [4096 7451]\\n test_file3 = os.path.join(INPUT_HYPM_PATH, 'unit_364-2013-206-6-0.mdd')\\n\\n # parse another .mdd file adding on to the node file, and making\\n # another sequence of instrument group files\\n mdd.procall([test_file3])\\n\\n file_state = self.get_file_state('node58p1.dat')\\n expected_file_state = {StateKey.UNPROCESSED_DATA: [[4059, 4060]],\\n StateKey.FILE_SIZE: 7452,\\n StateKey.OUTPUT_INDEX: 2}\\n\\n if file_state != expected_file_state:\\n print \\\"file state: '%s'\\\" % file_state\\n self.fail(\\\"Expected file state 2 does not match\\\")\\n\\n data_orig = self.read_full_file('node58p1.dat')\\n\\n # read the data from all generated files into one data string\\n data_out = self.read_full_file('node58p1_0.status_1236801.dat')\\n data_out += self.read_full_file('node58p1_0.wa_wfp_1236820.dat')\\n data_out += self.read_full_file('node58p1_0.wc_wfp_1236820.dat')\\n data_out += self.read_full_file('node58p1_0.we_wfp_1236820.dat')\\n data_out += self.read_full_file('node58p1_1.status_1236801.dat')\\n data_out += self.read_full_file('node58p1_1.wa_wfp_1236822.dat')\\n data_out += self.read_full_file('node58p1_1.wc_wfp_1236822.dat')\\n data_out += self.read_full_file('node58p1_1.we_wfp_1236822.dat')\\n\\n # confirm data in the node file matches those output in the instrument groups\\n if not TestSioUnpack.compare_sio_matches(data_orig, data_out):\\n self.fail(\\\"Failed sio block compare\\\")\",\n \"def save_state(self):\\n\\t\\tself._history['time'].append(self.t)\\n\\t\\tstate = np.array(self.x[np.newaxis,:,:])\\n\\t\\tself._history['state'] = np.vstack([self._history['state'],state])\",\n \"def post_process_renaissance(done_exec, tmp_file):\\n\\n wallclock_times = [-0.0] * done_exec.num_iters\\n with open(tmp_file) as f:\\n rows = iter(csv.reader(f))\\n\\n headers = rows.__next__()\\n assert headers[0] == \\\"benchmark\\\"\\n assert headers[1] == \\\"nanos\\\"\\n\\n for i, row in enumerate(rows):\\n assert row[0] == done_exec.benchmark\\n # nanos -> seconds.\\n wallclock_times[i] = int(row[1]) / 1000000000\\n\\n assert len(wallclock_times) == done_exec.num_iters\\n return wallclock_times\",\n \"def _save_traces(self, blocks):\\n docs = [{\\\"id\\\": block, \\\"name\\\": \\\"traces_extracted\\\", \\\"value\\\": True} for block in blocks]\\n self.client.bulk_index(index=self.indices[\\\"block_flag\\\"], docs=docs)\",\n \"def start(self, train_set, val_set):\\n \\n for epoch in range(self.start_epoch, self.num_epochs+self.start_epoch):\\n _, __, ___, last_itr = self.iterate(epoch, \\\"train\\\", train_set)\\n self.meter.tb_log.add_scalar(f'learning_rate', self.get_current_lr(), last_itr)\\n\\n state = {\\n \\\"epoch\\\": epoch,\\n \\\"best_metric\\\": self.best_metric,\\n \\\"state_dict\\\": self.net.state_dict(),\\n \\\"optimizer\\\": self.optimizer.state_dict(),\\n }\\n \\n with torch.no_grad():\\n val_loss, val_dice, val_iou, __ = self.iterate(epoch, \\\"val\\\", val_set)\\n key_metrics = {\\\"loss\\\": val_loss, \\\"dice\\\": -1.*val_dice, \\\"iou\\\": -1.*val_iou} # -1* for the scheduler\\n self.scheduler.step(val_loss)\\n\\n is_last_epoch = epoch == (self.num_epochs - 1)\\n if key_metrics[self.key_metric] < self.best_metric or is_last_epoch:\\n logging.info(\\\"******** Saving state ********\\\")\\n\\n if self.multi_gpu_flag:\\n # fix parameters names in a state dict. (caused by nn.DataParallel)\\n new_state_dict = {}\\n for k in state[\\\"state_dict\\\"]:\\n if k.startswith(\\\"module.\\\"):\\n new_k = re.sub(\\\"module.\\\", \\\"\\\", k)\\n new_state_dict[new_k] = copy.deepcopy(state[\\\"state_dict\\\"][k])\\n del state[\\\"state_dict\\\"]\\n gc.collect()\\n state[\\\"state_dict\\\"] = new_state_dict\\n\\n state[\\\"val_IoU\\\"] = val_iou\\n state[\\\"val_dice\\\"] = val_dice\\n state[\\\"val_loss\\\"] = val_loss\\n state[\\\"best_metric\\\"] = self.best_metric = key_metrics[self.key_metric]\\n\\n ckpt_name = \\\"best_model\\\"\\n if is_last_epoch:\\n ckpt_name = \\\"last_model\\\"\\n torch.save(state, f\\\"{self.model_path}/{ckpt_name}.pth\\\")\\n \\n # save meta-data into the workdir\\n self.dump_meta()\",\n \"def thread_main(self, sess):\\n for x_h, x_m, y in self.data_iterator():\\n sess.run(self.enqueue_op, feed_dict={self.x_h:x_h, self.x_m:x_m})\",\n \"def do_timestamp_messages(self, messages):\\n timestamp = self.env.now\\n self.reception_records[timestamp] = messages\\n log.debug(\\\"{} recorded {}\\\".format(self, self.reception_records))\",\n \"def collect_data(self):\\n self.lines = []\\n\\n while True:\\n self._process_serial_data()\",\n \"def process_events(cat_data, n_run, cfg, sta_locs):\\n import time\\n import os\\n import shutil\\n import sys\\n import logging\\n from obspy import read\\n from obspy.geodetics.base import gps2dist_azimuth\\n import matplotlib.pyplot as plt\\n\\n if cfg.output.FORCE_RECALC is True:\\n w = open(\\\"refined_events.dat\\\", \\\"w\\\")\\n w.close()\\n if cfg.plotting.DO_PLOT_1 is True or cfg.plotting.DO_PLOT_2 is True:\\n fig = plt.figure(figsize=(18, 10))\\n else:\\n fig = []\\n # Prepare directory\\n if (os.path.exists(\\\"runs/run{:}\\\".format(n_run))\\n and os.path.isdir(\\\"runs/run{:}\\\".format(n_run))):\\n shutil.rmtree(\\\"runs/run{:}\\\".format(n_run))\\n copytree(\\\"NLLOC_run\\\", \\\"runs/run{:}\\\".format(n_run))\\n os.chdir(\\\"runs/run{:}\\\".format(n_run))\\n for n_ev, ev in enumerate(cat_data):\\n start = time.time()\\n ev_id = ev.event_descriptions[0].text\\n sys.stdout.flush()\\n ev_dict = {}\\n ev_dict[\\\"stations\\\"] = {}\\n orig_lat, orig_lon = [ev.origins[0].latitude, ev.origins[0].longitude]\\n logging.debug(\\\"startint logging\\\")\\n st = read(\\\"../../{:}/{:}/MSEED/*.msd\\\".format(\\n cfg.input.DIR_TO_EVENTDIRS, ev_id), format=\\\"MSEED\\\")\\n print(n_run, ev_id)\\n for n_tr, tr in enumerate(st):\\n if st[n_tr].stats.sampling_rate > 40.0:\\n try:\\n st[n_tr].resample(40)\\n except ZeroDivisionError:\\n continue\\n st1, st2, st_mag = [st.copy(), st.copy(), st.copy()]\\n # Append distance to trace\\n stations_data = sorted(set([tr.stats.station for tr in st\\n if tr.stats.station not in\\n cfg.sta_select.STA_BLACKLIST]))\\n stations_dist = {sta_code: gps2dist_azimuth(\\n sta_locs[sta_code][\\\"lat\\\"], sta_locs[sta_code][\\\"lon\\\"],\\n orig_lat, orig_lon)[0] for sta_code in stations_data\\n if gps2dist_azimuth(\\n sta_locs[sta_code][\\\"lat\\\"], sta_locs[sta_code][\\\"lon\\\"],\\n orig_lat, orig_lon)[0]/1000 <= cfg.sta_select.MAX_DIST}\\n path_to_figs = \\\"../../{:}/{:}/figs\\\".format(\\n cfg.input.DIR_TO_EVENTDIRS, ev_id)\\n if not os.path.exists(path_to_figs):\\n os.mkdir(path_to_figs)\\n print(\\\"Doing first refinement\\\")\\n sys.stdout.flush()\\n if (\\\"R\\\" in cfg.picking.CMPS_REFINE_1[\\\"S\\\"] or\\n \\\"T\\\" in cfg.picking.CMPS_REFINE_1[\\\"S\\\"]):\\n rot = True\\n else:\\n rot = False\\n evt_refine_1, rms, found = refine_events(\\n st1, stations_dist, cfg.picking.CMPS_REFINE_1,\\n cfg.picking.MAX_PICK_DIFF_REFINE1, ev,\\n cfg.ploting.DO_PLOT_1, 1, fig, \\\"const\\\", path_to_figs, ev_dict,\\n ev_id, cfg, rot\\n )\\n if found is False:\\n continue\\n print(\\\"RMS = \\\", rms)\\n sys.stdout.flush()\\n prev_rms = rms\\n print(\\\"Doing second refinement\\\")\\n sys.stdout.flush()\\n if (\\\"R\\\" in cfg.picking.CMPS_REFINE_2[\\\"S\\\"] or\\n \\\"T\\\" in cfg.picking.CMPS_REFINE_2[\\\"S\\\"]):\\n rot = True\\n else:\\n rot = False\\n evt_refine_2, rms, found = refine_events(\\n st2, stations_dist, cfg.picking.CMPS_REFINE_2,\\n cfg.picking.MAX_PICK_DIFF_REFINE2, evt_refine_1,\\n cfg.plotting.DO_PLOT_2, 2, fig, \\\"dist\\\", path_to_figs, ev_dict,\\n ev_id, rot\\n )\\n if found is False:\\n continue\\n print(\\\"RMS = \\\", rms)\\n if rms > prev_rms * 1.25:\\n print(\\\"RMS is significantly increasing (*25%) - skipping event\\\")\\n continue\\n prev_rms = rms\\n evt_refine_2 = compute_magnitude(evt_refine_2, st_mag, cfg)\\n write_evt(evt_refine_2, ev_id)\\n end = time.time()\\n print(\\\"Time taken for event: {:3.1f} mins\\\".format((end-start)/60))\",\n \"def analysis_host_sec(self):\\n #calc the date\\n time_now = int(time.time())\\n time_local = time.localtime(time_now)\\n date = time.strftime(\\\"%Y-%m-%d\\\",time_local)\\n sum_cpu_ratio = 0\\n sum_phy_mem_size = 0\\n sum_virt_mem_size = 0\\n\\n key_re_word = \\\"%s qa_work\\\" % self.pid\\n for line in self.file_top.readlines():\\n if re.search(key_re_word, line):\\n #analysis_cpu_rate()\\n sum_cpu_ratio += float(line.split()[8])\\n self.cpu_list_1sec.append(float(line.split()[8]))\\n\\n #analysis_host_phy_mem_size(), the standerd unit is \\\"g\\\"\\n if \\\"m\\\" in line.split()[5]:\\n phy_mem_size = float(line.split()[5].strip(\\\"m\\\")) / 1000\\n elif \\\"g\\\" in line.split()[5]:\\n phy_mem_size = float(line.split()[5].strip(\\\"g\\\"))\\n elif \\\"k\\\" in line.split()[5]:\\n phy_mem_size = float(line.split()[5].strip(\\\"k\\\")) / 1000 / 1000\\n else:\\n phy_mem_size = 0.0\\n self.phy_mem_list_1sec.append(float(phy_mem_size))\\n sum_phy_mem_size += phy_mem_size\\n\\n #analysis_host_virt_mem_size(), the standerd unit is \\\"g\\\"\\n if \\\"m\\\" in line.split()[4]:\\n vir_mem_size = float(line.split()[4].strip(\\\"m\\\")) / 1000\\n elif \\\"g\\\" in line.split()[4]:\\n vir_mem_size = float(line.split()[4].strip(\\\"g\\\"))\\n elif \\\"k\\\" in line.split()[4]:\\n vir_mem_size = float(line.split()[4].strip(\\\"k\\\")) / 1000 / 1000\\n else:\\n vir_mem_size = 0\\n self.virt_mem_list_1sec.append(float(vir_mem_size))\\n sum_virt_mem_size += vir_mem_size\\n\\n elif re.search(\\\"top -\\\", line):\\n final_time = date + \\\" \\\" + line.split()[2]\\n self.top_pertime.append(final_time)\\n top_num = min(len(self.top_pertime), len(self.cpu_list_1sec), len(self.phy_mem_list_1sec), len(self.virt_mem_list_1sec))\\n\\n #cal the average data\\n average_cpu_ratio = round(sum_cpu_ratio/len(self.cpu_list_1sec), 2)\\n average_phy_mem_size = round(sum_phy_mem_size/len(self.phy_mem_list_1sec), 2)\\n average_virt_mem_size = round(sum_virt_mem_size/len(self.virt_mem_list_1sec), 2)\\n #cal the max data\\n max_cpu_ratio = max(self.cpu_list_1sec)\\n max_phy_mem_size = max(self.phy_mem_list_1sec)\\n max_virt_mem_size = max(self.virt_mem_list_1sec)\\n #insert into mysql-top_list_1sec_avg\\n print \\\"average_cpu_ratio: %s\\\" % average_cpu_ratio\\n print \\\"average_phy_mem_size: %s\\\" % average_phy_mem_size\\n print \\\"average_virt_mem_size: %s\\\" % average_virt_mem_size\\n print \\\"max_cpu_ratio: %s\\\" % max_cpu_ratio\\n print \\\"max_phy_mem_size: %s\\\" % max_phy_mem_size\\n print \\\"max_virt_mem_size: %s\\\" % max_virt_mem_size\\n if self.db_onoff == \\\"on\\\":\\n self.mysql.insert_table_sql_top_avg(self.time_sql, max_cpu_ratio, max_phy_mem_size, max_virt_mem_size)\",\n \"def log_stats_thread(root):\\n start = time.time()\\n\\n while True:\\n time.sleep(3)\\n timenow = time.time()\\n elapsed = str(timedelta(seconds = timenow - start))\\n inodesps = inodecount[root] / (timenow - start)\\n logger.info('CRAWL STATS (path {0}, files {1}, dirs {2}, elapsed {3}, perf {4:.3f} inodes/s, {5} paths still scanning {6}, memory usage {7})'.format(\\n root, filecount[root], dircount[root], elapsed, inodesps, len(scan_paths), scan_paths, get_mem_usage()))\\n dps = total_doc_count[root] / (timenow - start)\\n logger.info('ES UPLOAD STATS (path {0}, uploaded {1} docs, elapsed {2}, perf {3:.3f} docs/s)'.format(\\n root, total_doc_count[root], elapsed, dps))\",\n \"def _write_cache(step, event_file_suffix=None, **kwargs):\\n file_suffix = _TT_EVENT_FILE_SUFFIX\\n if event_file_suffix is not None:\\n file_suffix = string_ops.string_join([file_suffix, event_file_suffix],\\n separator='.')\\n # TODO(deveci): Parametrize max_queue, so that flushing op can be called\\n # less frequently.\\n # Setting max_queue to 100 appears to be safe even when the number of\\n # iterations are much lower, as the destructor of the writer flushes it.\\n summary_write_ops = []\\n summary_writer = summary.create_file_writer_v2(\\n self._parameters.trace_dir,\\n filename_suffix=file_suffix,\\n max_queue=_TT_SUMMARY_MAX_QUEUE)\\n graph.add_to_collection(\\n TENSOR_TRACER_SUMMARY_COLLECTION, summary_writer)\\n\\n step_value = step[0]\\n dt = step_value.dtype\\n\\n # The step parameter to a summary write call must be 64-bit.\\n if dt.__ne__(dtypes.int64) and dt.__ne__(\\n dtypes.uint64) and dt.__ne__(dtypes.float64):\\n step_value = math_ops.cast(step_value, dtypes.int64)\\n\\n with summary_writer.as_default():\\n summary_metadata = summary_pb2.SummaryMetadata(\\n plugin_data=summary_pb2.SummaryMetadata.PluginData(\\n plugin_name=_TT_TENSORBOARD_PLUGIN_NAME))\\n for key, value in kwargs.items():\\n # Check whether we need to compute aggregated statistics that merge\\n # all cores statistics.\\n if not self._parameters.collect_summary_per_core:\\n # Merge only statistics tensor, if it is any other tensor we simply,\\n # concatenate them.\\n # Also, if there is only a single core (first dim. is 0), then skip\\n # aggregation.\\n if key == _TT_SUMMARY_TAG and value.shape.as_list()[0] != 1:\\n value = self.aggregate_global_cache(value)\\n with ops.control_dependencies([summary_writer.init()]):\\n summary_write_ops.append(summary.write(\\n _TT_SUMMARY_TAG + '/' + key + '.' + graph_summary_tag,\\n value, metadata=summary_metadata,\\n step=step_value))\\n return control_flow_ops.group(summary_write_ops)\",\n \"def process_iteration_result(self, result, context):\\n self.infile = os.path.join(context.output_directory, 'trace.txt')\\n if os.path.isfile(self.infile):\\n self.logger.debug('Running result_processor \\\"dvfs\\\"')\\n self.outfile = os.path.join(settings.output_directory, 'dvfs.csv')\\n self.flush_parse_initialize()\\n self.calculate()\\n self.percentage()\\n self.generate_csv(context)\\n self.logger.debug('Completed result_processor \\\"dvfs\\\"')\\n else:\\n self.logger.debug('trace.txt not found.')\",\n \"def flush(self):\\n with self._lock:\\n batch = self._batch\\n timestamps = self._timestamps\\n\\n items = []\\n for identity, value in batch.items():\\n metric = {}\\n typ, name, tags = identity\\n metric[\\\"name\\\"] = name\\n if typ:\\n metric[\\\"type\\\"] = typ\\n else:\\n metric[\\\"timestamp\\\"] = timestamps[identity]\\n\\n if tags:\\n metric[\\\"attributes\\\"] = dict(tags)\\n\\n metric[\\\"value\\\"] = value\\n items.append(metric)\\n\\n items = tuple(items)\\n\\n batch.clear()\\n timestamps.clear()\\n\\n common = self._common.copy()\\n common[\\\"timestamp\\\"] = self._interval_start\\n now = int(time.time() * 1000.0)\\n interval = now - self._interval_start\\n common[\\\"interval.ms\\\"] = interval\\n\\n self._interval_start = now\\n\\n return items, common\",\n \"def _log_file_processing_stats(self, known_file_paths):\\n # File Path: Path to the file containing the DAG definition\\n # PID: PID associated with the process that's processing the file. May\\n # be empty.\\n # Runtime: If the process is currently running, how long it's been\\n # running for in seconds.\\n # Last Runtime: If the process ran before, how long did it take to\\n # finish in seconds\\n # Last Run: When the file finished processing in the previous run.\\n headers = [\\\"File Path\\\", \\\"PID\\\", \\\"Runtime\\\", \\\"# DAGs\\\", \\\"# Errors\\\", \\\"Last Runtime\\\", \\\"Last Run\\\"]\\n\\n rows = []\\n now = timezone.utcnow()\\n for file_path in known_file_paths:\\n last_runtime = self.get_last_runtime(file_path)\\n num_dags = self.get_last_dag_count(file_path)\\n num_errors = self.get_last_error_count(file_path)\\n file_name = os.path.basename(file_path)\\n file_name = os.path.splitext(file_name)[0].replace(os.sep, \\\".\\\")\\n\\n processor_pid = self.get_pid(file_path)\\n processor_start_time = self.get_start_time(file_path)\\n runtime = (now - processor_start_time) if processor_start_time else None\\n last_run = self.get_last_finish_time(file_path)\\n if last_run:\\n seconds_ago = (now - last_run).total_seconds()\\n Stats.gauge(f\\\"dag_processing.last_run.seconds_ago.{file_name}\\\", seconds_ago)\\n\\n rows.append((file_path, processor_pid, runtime, num_dags, num_errors, last_runtime, last_run))\\n\\n # Sort by longest last runtime. (Can't sort None values in python3)\\n rows.sort(key=lambda x: x[3] or 0.0)\\n\\n formatted_rows = []\\n for file_path, pid, runtime, num_dags, num_errors, last_runtime, last_run in rows:\\n formatted_rows.append(\\n (\\n file_path,\\n pid,\\n f\\\"{runtime.total_seconds():.2f}s\\\" if runtime else None,\\n num_dags,\\n num_errors,\\n f\\\"{last_runtime:.2f}s\\\" if last_runtime else None,\\n last_run.strftime(\\\"%Y-%m-%dT%H:%M:%S\\\") if last_run else None,\\n )\\n )\\n log_str = (\\n \\\"\\\\n\\\"\\n + \\\"=\\\" * 80\\n + \\\"\\\\n\\\"\\n + \\\"DAG File Processing Stats\\\\n\\\\n\\\"\\n + tabulate(formatted_rows, headers=headers)\\n + \\\"\\\\n\\\"\\n + \\\"=\\\" * 80\\n )\\n\\n self.log.info(log_str)\",\n \"def after_epoch(self):\\n line = ' '.join([str(k) + ': ' + str(v) for k, v in self.trainer.status.items()])\\n with open(os.path.join(self.root_path, 'log.txt'), 'a+') as fout:\\n fout.write(line + '\\\\n')\",\n \"def analysis_dev_sec(self):\\n #calc the date\\n time_now = int(time.time())\\n time_local = time.localtime(time_now)\\n date = time.strftime(\\\"%Y-%m-%d\\\",time_local)\\n sum_cpu_ratio = 0\\n sum_gpu_mem_size = 0\\n # key: time key\\n key_re_time = \\\"[0-9]+ [0-9]+:[0-9]+:[0-9]+ 20[12][][0-9]\\\"\\n # key: temperature key\\n key_re_temper = \\\"[0-9]+C\\\"\\n # key: gpu percent key\\n key_re_percent = \\\"[0-9]+%\\\"\\n # key: gpu mem key\\n key_re_mem = \\\"%s\\\" % self.pid\\n key_re_mem_null = \\\"No running processes found\\\"\\n # key: line ending key\\n key_ending = \\\"====ending====\\\"\\n\\n new_gpu_data_count = 0\\n sum_gpu_usage_percent_all = 0\\n for line in self.file_gpu.readlines():\\n if re.search(key_re_time, line):\\n # time own unit\\n # 1. colect the gpu time info\\n final_time = date + \\\" \\\" + line.split()[3]\\n self.gpu_pertime.append(final_time)\\n elif re.search(key_re_temper, line) and re.search(key_re_percent, line):\\n #print \\\"2222, data_line: %s\\\" % line\\n # 2. colect the gpu temperature info\\n # 3. colect the gpu usage percentage info\\n temper = float(line.split()[2].rstrip(\\\"C\\\"))\\n gpu_usage = float(line.split()[12].rstrip(\\\"%\\\"))\\n if new_gpu_data_count == 0:\\n self.gpu_temper_1.append(temper)\\n self.gpu_usage_percent_1.append(gpu_usage)\\n elif new_gpu_data_count == 1:\\n self.gpu_temper_2.append(temper)\\n self.gpu_usage_percent_2.append(gpu_usage)\\n elif new_gpu_data_count == 2:\\n self.gpu_temper_3.append(temper)\\n self.gpu_usage_percent_3.append(gpu_usage)\\n elif new_gpu_data_count == 3:\\n self.gpu_temper_4.append(temper)\\n self.gpu_usage_percent_4.append(gpu_usage)\\n new_gpu_data_count += 1\\n elif re.search(key_re_mem, line) or re.search(key_re_mem_null, line):\\n # 4. colect the gpu mem info\\n this_gpu_num = line.split()[1]\\n if \\\"MiB\\\" in line.split()[5]:\\n this_gpu_mem = float(line.split()[5].strip(\\\"MiB\\\"))\\n # TODO_this: if there have other unit\\n\\n if this_gpu_num == \\\"0\\\":\\n self.gpu_mem_1.append(this_gpu_mem)\\n elif this_gpu_num == \\\"1\\\":\\n self.gpu_mem_2.append(this_gpu_mem)\\n elif this_gpu_num == \\\"2\\\":\\n self.gpu_mem_3.append(this_gpu_mem)\\n elif this_gpu_num == \\\"3\\\":\\n self.gpu_mem_4.append(this_gpu_mem)\\n elif this_gpu_num == \\\"No\\\":\\n self.gpu_mem_1.append(0)\\n self.gpu_mem_2.append(0)\\n self.gpu_mem_3.append(0)\\n self.gpu_mem_4.append(0)\\n \\n elif re.search(key_ending, line):\\n # control unit\\n # 1.complete the gpu_mem list\\n max_len_gpu_mem = max(len(self.gpu_mem_4), len(self.gpu_mem_3), len(self.gpu_mem_2), len(self.gpu_mem_1))\\n min_len_gpu_mem = min(len(self.gpu_mem_4), len(self.gpu_mem_3), len(self.gpu_mem_2), len(self.gpu_mem_1))\\n if max_len_gpu_mem != min_len_gpu_mem:\\n if len(self.gpu_mem_1) != max_len_gpu_mem:\\n self.gpu_mem_1.append(0)\\n if len(self.gpu_mem_2) != max_len_gpu_mem:\\n self.gpu_mem_2.append(0)\\n if len(self.gpu_mem_3) != max_len_gpu_mem:\\n self.gpu_mem_3.append(0)\\n if len(self.gpu_mem_4) != max_len_gpu_mem:\\n self.gpu_mem_4.append(0)\\n new_gpu_data_count = 0\\n\\n # ! because all the list is equal\\n for i in range(len(self.gpu_mem_1)):\\n self.gpu_usage_percent_all.append(self.gpu_usage_percent_1[i] + self.gpu_usage_percent_2[i] + self.gpu_usage_percent_3[i] + self.gpu_usage_percent_4[i])\\n\\n #self.gpu_mem_all.append(self.gpu_mem_1[i] + self.gpu_mem_2[i] + self.gpu_mem_3[i] + self.gpu_mem_4[i])\\n self.gpu_mem_all.append(self.gpu_mem_1[i] + self.gpu_mem_2[i] + self.gpu_mem_3[i] + self.gpu_mem_4[i])\\n sum_gpu_mem_size += max(self.gpu_mem_1[i], self.gpu_mem_2[i], self.gpu_mem_3[i], self.gpu_mem_4[i])\\n\\n self.gpu_temper_max.append(max(self.gpu_temper_1[i] ,self.gpu_temper_2[i] ,self.gpu_temper_3[i] ,self.gpu_temper_4[i]))\\n\\n version_gpu_usage_percent_all = max(self.gpu_usage_percent_all)\\n\\n version_gpu_mem_all = max(self.gpu_mem_all)\\n version_gpu_mem_avg = round(sum_gpu_mem_size/len(self.gpu_mem_all), 2)\\n\\n version_gpu_temper_max = max(self.gpu_temper_max)\\n\\n print \\\"version_gpu_usage_percent_all: %s\\\" % version_gpu_usage_percent_all\\n print \\\"version_gpu_mem_all: %s\\\" % version_gpu_mem_all\\n print \\\"version_gpu_mem_avg: %s\\\" % version_gpu_mem_avg\\n print \\\"version_gpu_temper_max: %s\\\" % version_gpu_temper_max\\n\\n # insert into database: nvidia_list_1sec\\n if self.db_onoff == \\\"on\\\":\\n # insert into database: nvidia_list_1sec_avg\\n self.mysql.insert_table_sql_nvidia_version(self.time_sql, version_gpu_usage_percent_all, version_gpu_mem_avg, version_gpu_temper_max)\\n # insert into database: nvidia_list_1sec_max\\n #self.mysql.insert_table_sql_nvidia_version(self.time_sql, version_gpu_usage_percent_all, version_gpu_mem_all, version_gpu_temper_max)\",\n \"def flush(self):\\n logger.debug('Flushing session state to file %s', self.file_path)\\n\\n with open(self.file_path, 'wb') as f:\\n pickle.dump(self.data, f)\",\n \"def step(self):\\n with paddle.no_grad():\\n for index, tensors in self.trace:\\n grad_trace = self.create_trace(index, tensors)\\n if self._async_q is not None:\\n self._async_q.put(grad_trace)\\n self._async_e.wait()\\n self._async_e.clear()\\n else:\\n index, grads = grad_trace\\n self._update(index, grads)\\n self.trace = []\",\n \"def _flush(self):\\n old_pumps = self._pumps\\n new_pumps = self._pumps = set()\\n for p in old_pumps:\\n p.flush()\\n if p.clientIO.disconnected and p.serverIO.disconnected:\\n continue\\n new_pumps.add(p)\",\n \"def _process_raw_data(self):\\n sysfs_per_line = self._raw_sysfs_data.splitlines()\\n del sysfs_per_line[0] #throw away the first line, it's just the counts, we don't care...\\n\\n self.levels = dict()\\n\\n for level in range(0, len(sysfs_per_line)):\\n line = sysfs_per_line[level]\\n cts = list()\\n cts_strings = re.findall('\\\\[(.+?)\\\\]', line)\\n for ct_string in cts_strings:\\n new_ct = CastleSysfsComponentTreeState(ct_string)\\n new_ct.raw_sysfs_string = ct_string\\n cts.append(new_ct)\\n self.levels[level]=cts\",\n \"def data_process():\\n global localtime\\n global value_dict\\n sensor_types = sEtting.sensor_types\\n sensor_values = []\\n msg = None\\n value_dict = collections.OrderedDict.fromkeys(sEtting.payload_header)\\n value_dict[\\\"ver_format\\\"] = sEtting.ver_format\\n value_dict[\\\"FAKE_GPS\\\"] = sEtting.fake_gps\\n value_dict[\\\"app\\\"] = sEtting.app\\n value_dict[\\\"ver_app\\\"] = sEtting.ver_app\\n value_dict[\\\"device_id\\\"] = sEtting.device_id\\n value_dict[\\\"date\\\"] = localtime.strftime(\\\"%Y-%m-%d\\\")\\n value_dict[\\\"time\\\"] = localtime.strftime(\\\"%H:%M:%S\\\")\\n value_dict[\\\"device\\\"] = sEtting.device\\n\\n for sensor in sensor_types:\\n if sensor == 'pm25-at':\\n value_dict[\\\"s_d0\\\"] = get_reading_csv(sensor)\\n elif sensor == 'temperature':\\n value_dict[\\\"s_t0\\\"] = get_reading_csv(sensor)\\n elif sensor == 'humidity':\\n value_dict[\\\"s_h0\\\"] = get_reading_csv(sensor)\\n elif sensor == 'pm10-at':\\n value_dict[\\\"s_d1\\\"] = get_reading_csv(sensor)\\n else:\\n print 'Not support sensor type.'\\n if sEtting.fake_gps == 1:\\n value_dict[\\\"gps_lat\\\"] = sEtting.fgps_lat\\n value_dict[\\\"gps_lon\\\"] = sEtting.fgps_lon\\n value_dict[\\\"gps_alt\\\"] = sEtting.fgps_alt\\n value_dict[\\\"gps_fix\\\"] = 0\\n else:\\n value_dict[\\\"gps_lat\\\"] = get_gps()[0]\\n value_dict[\\\"gps_lon\\\"] = get_gps()[1]\\n value_dict[\\\"gps_alt\\\"] = get_gps()[2]\\n value_dict[\\\"gps_fix\\\"] = gpsd.fix.mode\\n value_dict[\\\"gps_num\\\"] = 0\\n #if debug_enable == '0':\\n msg = \\\"|\\\" + \\\"|\\\".join([\\\"=\\\".join([key, str(val)])\\n for key, val in value_dict.items()])\\n return msg\\n #elif debug_enable == '1':\\n # msg_debug = \\\",\\\".join([\\\"=\\\".join([key, str(val)]) for key, val in value_dict.items()])\\n # return msg_debug\",\n \"def flush(self):\\n for k, l in self.logs.items():\\n self.full_logs[k].extend(l)\\n self.logs = dict()\",\n \"def _read_log(self):\\n\\n line_regex = compile(r\\\"\\\\[I\\\\]\\\\s*\\\\(\\\\d+ms\\\\)[^\\\\d]+(?P<counter>\\\\d+)\\\"\\n r\\\"[^\\\\d]+(?P<timestamp>\\\\d+(\\\\.\\\\d+)?)[^\\\\d]+\\\"\\n r\\\"(?P<acceleration>\\\\d+);\\\")\\n values = []\\n with open(self.filepath) as file:\\n for line in file:\\n match = line_regex.match(line)\\n if match:\\n values.append({\\n 'counter':\\n int(match['counter']),\\n 'timestamp':\\n int(float(match['timestamp']) * 1000),\\n 'acceleration':\\n int(match['acceleration'])\\n })\\n\\n self.values = values\",\n \"def _read_traces(self, unpack_headers=False, headonly=False,\\n yield_each_trace=False):\\n self.traces = []\\n # Determine the filesize once.\\n if isinstance(self.file, io.BytesIO):\\n pos = self.file.tell()\\n self.file.seek(0, 2) # go t end of file\\n filesize = self.file.tell()\\n self.file.seek(pos, 0)\\n else:\\n filesize = os.fstat(self.file.fileno())[6]\\n # Big loop to read all data traces.\\n i = -1\\n while True:\\n # Read and as soon as the trace header is too small abort.\\n try:\\n trace = SEGYTrace(self.file, self.data_encoding, self.endian,\\n unpack_headers=unpack_headers,\\n filesize=filesize, headonly=headonly)\\n i += 1\\n if yield_each_trace:\\n yield trace\\n else:\\n if self.hdf_writer == 0:\\n self.traces.append(trace)\\n else:\\n if headonly and not self.hdf_writer.need_writing:\\n self.hdf_writer.count_of_traces += 1\\n elif self.hdf_writer.need_writing:\\n self.hdf_writer.add_trace(trace, i)\\n else:\\n self.traces.append(trace)\\n\\n except SEGYTraceHeaderTooSmallError:\\n break\",\n \"def run(self):\\n LOG.debug(\\\"ReaderThread up and running\\\")\\n\\n lastevictTime = 0\\n while ALIVE:\\n for col in allLivingCollectors():\\n for line in col.collect():\\n self.processLine(col, line)\\n now = int(time.time())\\n if now - lastevictTime > self.evictinterval:\\n lastevictTime = now\\n now -= self.evictinterval\\n for col in allCollectors():\\n col.evictOldkeys(now)\\n # BUGBUG : not good\\n time.sleep(1)\",\n \"def queryTCS():\\n timestamp = datetime.datetime.now().isoformat()\\n values = []\\n for statusPiece in statusPieces:\\n TN.write(statusPiece+\\\"\\\\r\\\\n\\\")\\n value = TN.read_until(\\\"\\\\n\\\", 0.5)\\n value = value.strip()\\n if not value:\\n value = \\\"?\\\"\\n values.append(value)\\n if values[2] == \\\"?\\\" or int(values[2]) != 2:\\n return # only record if in tracking state\\n with open(filename, \\\"a\\\") as f:\\n f.write(\\\"%s %s %s %s %s %s\\\\n\\\"%tuple([timestamp]+values))\",\n \"def thread_main(self, sess):\\n for x_h, x_m, y in self.data_iterator():\\n sess.run(self.enqueue_op, feed_dict={self.x_h:x_h, self.x_m:x_m, self.y:y})\",\n \"def run(self):\\n\\n # driver=\\\"H5FD_CORE\\\" another driver for Solid State devs?\\n theFile = tables.open_file(self.hdfFileName, \\\"w\\\")\\n theFile.create_group(\\\"/\\\", \\\"transitionLogs\\\")\\n theLog = theFile.create_earray(where=theFile.root,\\n name=\\\"log\\\",\\n atom=tables.StringAtom(itemsize=120),\\n shape=(0,),\\n title=\\\"log messages\\\",\\n filters=tables.Filters(complevel=9,\\n complib='zlib'))\\n speciesTables = {}\\n\\n try:\\n # do a loop!\\n while True:\\n try:\\n msg = self.transitionsPipe.recv()\\n # msg=messagequeue.get()\\n except EOFError:\\n break\\n cmd = msg[0]\\n if cmd == \\\"parameters\\\":\\n # expect two dictionaries\\n parameters, runParameters = msg[1], msg[2]\\n\\n if type(parameters) is dict:\\n if \\\"/parameters\\\" in theFile:\\n parameterTable = theFile.root.parameters\\n else:\\n parameterTable = theFile.create_table(\\n \\\"/\\\",\\n \\\"parameters\\\",\\n HDFLoggingProcess.parameterTableFormat)\\n parameterRow = parameterTable.row\\n varTypeEnum = parameterTable.coldescrs[\\\"varType\\\"].enum\\n varTypeDict = {int: varTypeEnum[\\\"INT\\\"],\\n str: varTypeEnum[\\\"STR\\\"],\\n float: varTypeEnum[\\\"FLOAT\\\"],\\n bool: varTypeEnum[\\\"BOOL\\\"]}\\n runType = varTypeEnum[\\\"RUN\\\"]\\n\\n for k, v in parameters.items():\\n varType = varTypeDict[type(v)]\\n parameterRow[\\\"varName\\\"] = str(k)\\n parameterRow[\\\"varType\\\"] = varType\\n parameterRow[\\\"varValue\\\"] = str(v)\\n parameterRow.append()\\n\\n for k, v in runParameters.items():\\n parameterRow[\\\"varName\\\"] = str(k)\\n parameterRow[\\\"varType\\\"] = runType\\n parameterRow[\\\"varValue\\\"] = str(v)\\n parameterRow.append()\\n\\n parameterTable.close()\\n del parameterRow, parameterTable\\n elif type(parameters) is scenario:\\n print(\\\"writing scenarios\\\")\\n parameters.writeToHDF(theFile.root, 'scenario')\\n else:\\n print(\\\"unsupported type: {}\\\".format(type(parameters)))\\n\\n # need a table def and a transition log\\n elif cmd == \\\"registerTransitionType\\\":\\n # change lists to enumerations!\\n # expect list of extra columns as msg[2]\\n theColumns = {}\\n for name, col in msg[2].items():\\n if type(col) is dict:\\n # this is an enumeration type used\\n # for the from/to state\\n col = tables.EnumCol(tables.Enum(col),\\n \\\"start\\\",\\n \\\"uint16\\\")\\n elif type(col) is str:\\n # column of type defined by string\\n col = eval(col) # ToDo: remove eval\\n theColumns[name] = col\\n\\n # gets species name and table format as dict\\n transitions = type(\\\"transitions\\\",\\n (tables.IsDescription,),\\n theColumns)\\n speciesTables[msg[1]] = theFile.create_table(\\n \\\"/transitionLogs\\\",\\n msg[1],\\n transitions,\\n filters=tables.Filters(\\n complevel=9,\\n complib=\\\"lzo\\\",\\n least_significant_digit=3))\\n\\n elif cmd == \\\"changeFile\\\":\\n # close tables and file\\n for t in speciesTables.values():\\n t.close()\\n del t\\n del speciesTables\\n theLog.close()\\n del theLog\\n theFile.close()\\n del theFile\\n\\n # set new file name\\n self.hdfFileName = msg[1]\\n # open new one\\n # potentially a driver=\\\"H5FD_CORE\\\" ?\\n theFile = tables.open_file(self.hdfFileName, \\\"w\\\")\\n theFile.create_group(\\\"/\\\", \\\"transitionLogs\\\")\\n theLog = theFile.create_earray(\\n where=theFile.root,\\n name=\\\"log\\\",\\n atom=tables.StringAtom(itemsize=120),\\n shape=(0,),\\n title=\\\"log messages\\\",\\n filters=tables.Filters(complevel=9,\\n complib='zlib'))\\n speciesTables = {}\\n # expecting replay of species tables\\n\\n elif cmd == \\\"logTransition\\\":\\n # gets species name and values in order as defined by the\\n # table format\\n # todo: check the format!\\n table = speciesTables[msg[1]]\\n row = table.row\\n agentId, t1, t2, fromState, toState, effort = msg[2]\\n row[\\\"agentId\\\"] = agentId\\n row[\\\"timeStamp\\\"] = t2\\n row[\\\"fromState\\\"] = fromState\\n row[\\\"toState\\\"] = toState\\n row[\\\"dwellTime\\\"] = t2-t1\\n row[\\\"effort\\\"] = effort\\n\\n if len(msg) > 2:\\n # are there any extra parameters?\\n for name, value in msg[3].items():\\n if type(value) is str:\\n row[name] = numpy.array(value.encode(),\\n dtype=\\\"S\\\")\\n else:\\n row[name] = value\\n row.append()\\n del table, row\\n\\n # also a progress table\\n elif cmd == \\\"progress\\\":\\n # if not there, create new table\\n if \\\"/progress\\\" not in theFile:\\n theFile.create_table(\\n '/',\\n 'progress',\\n HDFLoggingProcess.hdfProgressTable)\\n # add values as they are...\\n theFile.root.progress.append([msg[1]])\\n\\n elif cmd == \\\"message\\\":\\n theLog.append(numpy.array([str(msg[1])], dtype=\\\"S120\\\"))\\n\\n elif cmd == \\\"end\\\":\\n break\\n\\n else:\\n print(\\\"unknown type {}\\\".format(msg[0]))\\n except:\\n raise\\n finally:\\n # messagequeue.close()\\n self.transitionsPipe.close()\\n del self.transitionsPipe\\n # print(\\\"finished \\\", messagepipe)\\n # done, be pedantic about closing all resources\\n for t in speciesTables.values():\\n t.close()\\n del t\\n del speciesTables\\n theLog.close()\\n del theLog\\n theFile.close()\\n del theFile\",\n \"def _store_rows(self):\\n\\n for value in self.values:\\n self.counters.append(value['counter'])\\n self.timestamps.append(value['timestamp'])\\n self.acceleration.append(value['acceleration'])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5487987","0.5408423","0.5171812","0.5149306","0.5137264","0.51059526","0.5044956","0.50032514","0.50026226","0.49774602","0.4974482","0.49592197","0.49436066","0.49434984","0.49397263","0.49303812","0.4918796","0.4905129","0.49025974","0.48947987","0.488864","0.488864","0.4879639","0.4874165","0.4865397","0.48638934","0.4845926","0.48286045","0.48223844","0.4821507","0.4812037","0.48090133","0.48002288","0.47965255","0.4791397","0.4791397","0.4791397","0.4791397","0.4791397","0.4791397","0.4791397","0.4791397","0.4791397","0.47823223","0.4780249","0.47724512","0.47714013","0.47706753","0.4766995","0.4766995","0.4766995","0.4766995","0.4766995","0.4766995","0.4766995","0.4766995","0.4766995","0.4766995","0.4766995","0.47661695","0.47590265","0.4753511","0.47509974","0.47377872","0.47327828","0.47218993","0.47152743","0.47034013","0.4699153","0.46961913","0.46941367","0.46891275","0.4685344","0.46776593","0.46747294","0.4670112","0.4666734","0.46563646","0.46523374","0.46486813","0.46452582","0.46373963","0.46366957","0.4633548","0.4632891","0.46284783","0.46281368","0.46264628","0.46211222","0.46079963","0.46012393","0.46011877","0.45995116","0.4598014","0.45945725","0.45942447","0.45917177","0.45911402","0.4582629","0.4581316"],"string":"[\n \"0.5487987\",\n \"0.5408423\",\n \"0.5171812\",\n \"0.5149306\",\n \"0.5137264\",\n \"0.51059526\",\n \"0.5044956\",\n \"0.50032514\",\n \"0.50026226\",\n \"0.49774602\",\n \"0.4974482\",\n \"0.49592197\",\n \"0.49436066\",\n \"0.49434984\",\n \"0.49397263\",\n \"0.49303812\",\n \"0.4918796\",\n \"0.4905129\",\n \"0.49025974\",\n \"0.48947987\",\n \"0.488864\",\n \"0.488864\",\n \"0.4879639\",\n \"0.4874165\",\n \"0.4865397\",\n \"0.48638934\",\n \"0.4845926\",\n \"0.48286045\",\n \"0.48223844\",\n \"0.4821507\",\n \"0.4812037\",\n \"0.48090133\",\n \"0.48002288\",\n \"0.47965255\",\n \"0.4791397\",\n \"0.4791397\",\n \"0.4791397\",\n \"0.4791397\",\n \"0.4791397\",\n \"0.4791397\",\n \"0.4791397\",\n \"0.4791397\",\n \"0.4791397\",\n \"0.47823223\",\n \"0.4780249\",\n \"0.47724512\",\n \"0.47714013\",\n \"0.47706753\",\n \"0.4766995\",\n \"0.4766995\",\n \"0.4766995\",\n \"0.4766995\",\n \"0.4766995\",\n \"0.4766995\",\n \"0.4766995\",\n \"0.4766995\",\n \"0.4766995\",\n \"0.4766995\",\n \"0.4766995\",\n \"0.47661695\",\n \"0.47590265\",\n \"0.4753511\",\n \"0.47509974\",\n \"0.47377872\",\n \"0.47327828\",\n \"0.47218993\",\n \"0.47152743\",\n \"0.47034013\",\n \"0.4699153\",\n \"0.46961913\",\n \"0.46941367\",\n \"0.46891275\",\n \"0.4685344\",\n \"0.46776593\",\n \"0.46747294\",\n \"0.4670112\",\n \"0.4666734\",\n \"0.46563646\",\n \"0.46523374\",\n \"0.46486813\",\n \"0.46452582\",\n \"0.46373963\",\n \"0.46366957\",\n \"0.4633548\",\n \"0.4632891\",\n \"0.46284783\",\n \"0.46281368\",\n \"0.46264628\",\n \"0.46211222\",\n \"0.46079963\",\n \"0.46012393\",\n \"0.46011877\",\n \"0.45995116\",\n \"0.4598014\",\n \"0.45945725\",\n \"0.45942447\",\n \"0.45917177\",\n \"0.45911402\",\n \"0.4582629\",\n \"0.4581316\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.64534724"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84790,"cells":{"query":{"kind":"string","value":"Update the cluster frequency and current cluster"},"document":{"kind":"string","value":"def update_cluster_freq(self, state, cpu_id):\n # For IKS devices cluster changes only possible when\n # freq changes, for other it is determine by cpu_id.\n if self.device.scheduler != 'iks':\n self.current_cluster = self.get_cluster(cpu_id, state)\n if self.get_state_name(state) == \"freqstate\":\n self.current_cluster = self.get_cluster(cpu_id, state)\n self.current_frequency_of_clusters[self.current_cluster] = state"},"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 updateClusterInfo(self):\n self.nPoints = len(self.labels)\n self.n = len(np.unique(self.labels))\n self.centers = [ [0.0 for j in range(3)] for i in range(self.n)]","def update_cluster(self, cluster, params, *args, **kwargs):\n raise NotImplementedError","def add_update_cluster(self, label, cluster):\n self._clusters[label] = cluster","def cluster_cal(self):\n self.Cluster = []\n for i in range(self.nodenum):\n neighborhood_node = self.neighbor_node(i)\n Node_num = len(neighborhood_node)\n Count = self.neighbor_edge(neighborhood_node)\n if(Node_num == 0 or Node_num == 1):\n self.Cluster.append(0.5)\n else:\n self.Cluster.append(Count/(Node_num*(Node_num - 1)))\n \n self.cluster_coeff = np.average(self.Cluster)","def compute_cluster_metrics_helper(self, event_index: int, timestamp: datetime, cp_count: int,\n cluster: Cluster, cluster_type: str) -> None:\n self.cluster_metrics.append([event_index, timestamp, cp_count, cluster.id, cluster.centroid[0],\n cluster.centroid[1], cluster.radius, cluster.weight, cluster_type])","def _recalculate_centroids(self):\n\n self._prev_centroids = dict(self.centroids)\n for cluster in self.clusters:\n self.centroids[cluster] = np.average(self.clusters[cluster], axis=0)","def update_frequencies():\n pass","def cluster(self, cluster):\n\n self._cluster = cluster","def cluster(self, cluster):\n\n self._cluster = cluster","def cluster(self, cluster):\n\n self._cluster = cluster","def cluster(self, cluster):\n\n self._cluster = cluster","def cluster(self, cluster):\n\n self._cluster = cluster","def cluster(self, cluster):\n\n self._cluster = cluster","def add_to_cluster_dictionary(self, cluster):\n\n self.clusters[self.cluster_idx] = cluster\n update_cluster_array(self, cluster, cluster.cluster_idx)\n\n return","def update_centroid(self):\n\n total_docs = len(self.documents)\n\n if total_docs == 0:\n return\n\n new_centroid = self.centroid.copy()\n for document in self.documents:\n new_centroid = new_centroid + document.vector\n\n self.centroid = new_centroid / float(total_docs)","def update(self, clusters):\n centroids = {}\n for cluster, coordinates in clusters.iteritems():\n sumLat = 0\n sumLong = 0\n for coordinate in coordinates:\n sumLat += float(coordinate[0])\n sumLong += float(coordinate[1])\n centroids[cluster] = (sumLat/float(len(coordinates)), sumLong/float(len(coordinates)))\n return centroids","def __initCluster(self):\n data_size, cluster_center = self.data_size, self.cluster_center\n self.cluster_temp = np.zeros(data_size, dtype=int)\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\n for center in cluster_center:\n self.cluster_temp[center] = center","def cluster_counter(self):\n return Counter(self.model.labels_.tolist())","def assign_labels_to_centroids(self):\n labelled_centroids = []\n for i in range(len(self.final_clusters)):\n labels = map(lambda x: x[0], self.final_clusters[i])\n # pick the most common label\n most_common = Counter(labels).most_common(1)[0][0]\n c = np.round(len([item for item in self.final_clusters[i] if item[0]==1])/len(self.final_clusters[i]),2)\n if c>=0.46:\n most_common = 1.0\n centroid = (most_common, self.final_centroids[i])\n labelled_centroids.append(centroid)\n\n self.labelled_centroids = labelled_centroids\n print(\"cluster_0: \", np.round(len([item for item in self.final_clusters[0] if item[0]==1])/len(self.final_clusters[0]),2), \"size_0: \", len(self.final_clusters[0]))\n print(\"cluster_1: \", np.round(len([item for item in self.final_clusters[1] if item[0]==1])/len(self.final_clusters[1]),2), \"size_1: \", len(self.final_clusters[1]))\n #print(\"cluster_2: \", np.round(len([item for item in self.final_clusters[2] if item[0]==1])/len(self.final_clusters[2]),2), \"size_2: \", len(self.final_clusters[2]))\n #print(\"cluster_3: \", np.round(len([item for item in self.final_clusters[3] if item[0]==1])/len(self.final_clusters[3]),2), \"size_2: \", len(self.final_clusters[3]))","def UpdateFrequency(self, newfreq):\n\n if self.strategy:\n setattr(self.strategy, managers.UTICK, newfreq)","def setBestCluster(cluster):\r\n global bestCluster\r\n bestCluster = cluster","def run(self):\n for i,p in enumerate(self.pairs):\n self.forPointPair(i)\n if i % 100000 == 0:\n print('Percentage Processed: ' + str(round(i * 100 / len(self.pairs), 3)) + '. Existing Cluster Labels: ', len(np.unique(self.labels)))","def compute_cluster_metrics(self, event_index: int, timestamp: datetime, cp_count: int,\n normal_clusters: Tuple[List[List], List[List]], o_clusters: List[Cluster]) -> None:\n c_clusters, p_clusters = normal_clusters[0], normal_clusters[1]\n for group in c_clusters:\n for cluster in group:\n self.compute_cluster_metrics_helper(event_index, timestamp, cp_count, cluster, 'core micro-cluster')\n\n for group in p_clusters:\n for cluster in group:\n self.compute_cluster_metrics_helper(event_index, timestamp, cp_count, cluster, 'potential micro-cluster')\n\n for cluster in o_clusters:\n self.compute_cluster_metrics_helper(event_index, timestamp, cp_count, cluster, 'outlier micro-cluster')","def _relocate_clusters(self, cluster_labels):\n for cluster_label in range(self.k):\n if cluster_labels[cluster_label] is not None:\n # mean of the pixels assigned to cluster\n p_sum, p_count = np.asarray(\n cluster_labels[\n cluster_label\n ]).sum(axis=0), len(cluster_labels[cluster_label])\n self._clusters[cluster_label] = p_sum / p_count","def diffusion(self, initval, clusterList, coalescenceList, smeasure):\n partServ = ParticleService()\n for pl in coalescenceList.GET():\n partServ.ClusterDiffusion(self.initVal, pl)","def disaggregate_by_cluster(self):\n # wt = np.zeros((1, self.ds.shape[1]))\n # total = np.zeros((self.n_ahead, self.ds.shape[1]))\n \n agg_cluster_ds = np.zeros((self.n_ahead+1, self.n_clusters))\n agg_cluster_ds[0] = self.ds_agg_by_c[-1]\n agg_cluster_ds[1:] = self.ds_c_for\n cluster_perc_change = np.diff(agg_cluster_ds, axis = 0) / agg_cluster_ds[:-1]\n\n cluster_scaling_vector = np.zeros((2, self.ds.shape[1]))\n\n # break down proportionally -> don't work well\n # for c in range(self.n_clusters):\n # c_m = self.ds.iloc[-self.cluster_n_period:, np.where(self.ds_c == c)[0]]\n # c_sum = sum(c_m)\n # indiv_sum = np.sum(c_m, axis = 0)\n # wt[:,np.where(self.ds_c == c)[0]] = (indiv_sum/c_sum)\n # total[:,np.where(self.ds_c == c)[0]] = np.reshape(\n # np.repeat(self.ds_c_for[:,c], c_m.shape[1]), (self.n_ahead, c_m.shape[1]))\n \n # multiply by the perc change\n \n for i in range(self.ds_c.shape[0]):\n cluster_scaling_vector[:,i] = cluster_perc_change[:,self.ds_c[i]]\n cluster_scaling_vector = cluster_scaling_vector+1\n cluster_scaling_vector = np.array(cluster_scaling_vector)\n \n self.ds_for = self.ds.copy()\n\n for yr in range(self.n_ahead)[::-1]:\n # forecast on foretasted number\n yr_ind = self.ds_for.index[-(yr+1)]\n self.ds_for.ix[yr_ind] = self.ds_for.iloc[-(yr+2),:].values * cluster_scaling_vector[-(yr+1)]\n\n # self.ds_for.iloc[-(self.n_ahead):,:] = self.ds_for.iloc[-(self.n_ahead+1):-1,:].values * np.array(cluster_scaling_vector)\n\n # if negative -> 0\n self.ds_for[self.ds_for < 0] = 0","def _update_centroid_location(self):\n previous_centroid_info = copy.deepcopy(self.centroid_info)\n for centroid, belongings in self.cluster_result.items():\n if not self.centroid_stable_flag.get(centroid):\n temp_list = list()\n temp_list.append(self.centroid_info.get(centroid))\n temp_list.extend(belongings)\n\n self.centroid_info[centroid] = float(sum(temp_list) / len(temp_list))\n\n return previous_centroid_info, self.centroid_info","def clusters(self, clusters):\n\n self._clusters = clusters","def clusters(self, clusters):\n\n self._clusters = clusters","def clusters(self, clusters):\n\n self._clusters = clusters","def eval_cluster_contingency(clustering_alg: List, labels_true, sdist):\n for (alg_name, alg_dict) in clustering_alg:\n if \"alg\" in alg_dict:\n clustering = alg_dict[\"alg\"].fit(sdist)\n labels_pred = clustering.labels_\n alg_dict[\"labels\"] = labels_pred\n else:\n labels_pred = alg_dict[\"labels\"]\n\n pred_label_dict, new_labels = normalize_labels(labels_pred)\n\n alg_dict[\"cm\"] = contingency_matrix(labels_true, new_labels)","def clustering_and_visulization(self):\n try:\n centroids, _ = kmeans(self.data_mat, self.k)\n except ValueError:\n print(\"The number of clusters is more than the data points\")\n self.idx, _ = vq(self.data_mat, centroids)\n for i in range(self.k):\n\n self.plot_list.append(self.data_mat[self.idx == i, 0])\n self.plot_list1.append(self.data_mat[self.idx == i, 1])\n\n for j in range(self.k):\n plot(self.plot_list[j], self.plot_list1[j], self.color_code[j])\n plot(centroids[:, 0], centroids[:, 1], 'sg', markersize=8)\n show()\n\n for i in range(self.k):\n self.cluster = self.data_mat[self.idx == i]\n self.clusterlist.append(self.cluster)\n print(self.clusterlist)\n for i in range(len(self.clusterlist)):\n self.clusterdict[i] = self.clusterlist[i]\n print(self.clusterdict)\n\n index_dict ={}\n for i in self.clusterdict:\n index_dict[i] = []\n for i in range(len(self.data_mat)):\n for j in range(len(self.clusterdict)):\n if (self.clusterdict[j][:] == self.data_mat[i]).any():\n index_dict[j].append(i)\n print(\"drugs cluster dict\", index_dict)\n\n self.drugsdict = {}\n for i in index_dict:\n self.drugsdict[i] = []\n drugslist = list(self.df.columns.values)\n print(\"drugs list from dataframe\", drugslist)\n\n for i in index_dict:\n self.drugsdict[i] = [drugslist[index] for index in index_dict[i]]\n\n print(\"drugs cluster dict\", self.drugsdict)\n########################################################################################################################\n clusterdict_from_df_as_drug_frequency = {}\n clusterdict_from_df_as_drug_non_O_frequency = {}\n\n print('\\n')\n\n for i in range(len(self.df)):\n clusterdict_from_df_as_drug_frequency[i] = []\n\n for i in range(len(self.df)):\n clusterdict_from_df_as_drug_frequency[i].append(self.df.iloc[i].to_dict()) #\n print(\"packs in dict form of drugs frequency\", clusterdict_from_df_as_drug_frequency)\n\n for i in range(len(self.df)):\n clusterdict_from_df_as_drug_non_O_frequency[i] = []\n\n for i in range(len(self.df)):\n for j in clusterdict_from_df_as_drug_frequency[i]:\n clusterdict_from_df_as_drug_non_O_frequency[i].append({x: y for x, y in j.items() if y != 0})\n print(\"clusterdict_from_df_as_drug_non_O_frequency\", clusterdict_from_df_as_drug_non_O_frequency)\n print('\\n')\n clusterdict_from_as_drugs_only_as_list = {}\n clusterdict_of_non_repeated_drugs = {}\n for i in range(len(self.df)):\n clusterdict_from_as_drugs_only_as_list[i] = []\n\n for i in range(len(self.df)):\n for j in clusterdict_from_df_as_drug_non_O_frequency[i]:\n clusterdict_from_as_drugs_only_as_list[i].append(j.keys())\n\n print(\"only keys drugs with drugs name\", clusterdict_from_as_drugs_only_as_list)\n print('\\n')\n\n for i in range(len(self.df)):\n clusterdict_of_non_repeated_drugs[i] = list(more_itertools.collapse(\n [list(x) for x in set([tuple(x) for x in clusterdict_from_as_drugs_only_as_list[i]])]))\n\n print(\"only drugs only\", clusterdict_of_non_repeated_drugs)\n\n########################################################################################################################\n robot_for_packs_dict = {}\n for i in range(len(self.df)):\n robot_for_packs_dict[i] = []\n\n # for i in range(len(self.df)):\n for i in range(len(self.df)):\n for j in clusterdict_of_non_repeated_drugs[i]:\n if j in self.drugsdict[0]:\n robot_for_packs_dict[i].append(0)\n elif j in self.drugsdict[1]:\n robot_for_packs_dict[i].append(1)\n for i in range(len(self.df)):\n robot_for_packs_dict[i] = set(robot_for_packs_dict[i])\n\n for i in range(len(self.df)):\n robot_for_packs_dict[i] = list(more_itertools.collapse(robot_for_packs_dict[i]))\n print('\\n')\n print(\"clusterdict_of_non_repeated_drugs\", robot_for_packs_dict)","def start(self):\n\t\tself.distributedVarPart()\n\t\twhile self.t < self.T:\n\t\t\tself.t += 1\n\t\t\tfor cluster in self.clusterList:\n\t\t\t\tprint(\"cluster: \")\n\t\t\t\tprint(cluster)\n\t\t\t\tprint(self.clusterList[cluster])\n\t\t\t\tself.C[cluster] = self.average_consensus(self.clusterList[cluster])\n\t\t\tprint(self.C)\n\t\t\tprint(\"turn t=%s: Centroids%s\"% (self.t, self.C), flush=True)\n\t\t\ttime.sleep(1)","def initClusters(self):\n if len(self.labelList) != len(self.pointList):\n \traise ValueError(\"Label List and Point List not the same length!\")\n for i in range(len(self.labelList)):\n self.centroids[self.labelList[i]] = self.pointList[i]\n self.pointcounts[self.labelList[i]] = 1","def update_count(self):\n count_metrics = self._fetch_count_metrics_and_clear()\n self._logger.info('update_count. count_metrics = %s',\n build_metrics_counter_data(count_metrics))","def execute(self, docs, clusters=None):\n if clusters == None:\n # Find k random docs to start as our centroids.\n indices = range(len(docs))\n random.shuffle(indices)\n \n # Initialize clusters.\n i = 0\n for index in indices[:self.k]:\n cluster = self.clusters[i]\n docs[index].cluster = cluster\n cluster.docs.append(docs[index]) \n cluster.centroid = self.centroid(self.clusters[i].docs)\n i += 1\n else:\n self.clusters = clusters\n \n change = True\n while change:\n # Check if any of the centroids changed.\n change = False\n \n for doc in docs:\n # Remove this doc from it's original cluster.\n if doc.cluster != None:\n doc.cluster.docs.remove(doc)\n doc.cluster = None\n \n max_cluster = None\n max_cos = float(\"-inf\")\n \n # Find the closest cluster for this document.\n for cluster in self.clusters:\n cos = self.cosine(doc.tfidf, cluster.centroid)\n if cos > max_cos: \n max_cluster = cluster\n max_cos = cos\n \n old_centroid = max_cluster.centroid\n \n # Re-assign this doc the new cluster and find the centroid.\n doc.cluster = max_cluster\n max_cluster.docs.append(doc) \n max_cluster.centroid = self.centroid(max_cluster.docs)\n \n # Check if the centroid has changed.\n for index in old_centroid:\n if old_centroid[index] - max_cluster.centroid[index] > (1 ** -15):\n change = True","def cluster_dist(self):\n clusters = self.all_clusters()\n lengths = [len(cluster) for cluster in clusters]\n d = Dist(lengths)\n d.plot_ccdf(loglog)\n show()","def _compute_centroids(self):\n\n for i in range(0, self.k):\n cluster = np.argwhere(self.assigned_clusters == i)\n cluster_points = self.data[cluster].squeeze()\n self.centroids[i] = np.mean(cluster_points, axis=0)","def print_cluster(self, cluster, value):\n total = 0\n ham = 0\n spam = 0\n for message in cluster:\n if self.spamorham[self.ids[message]] == 'ham':\n ham += 1\n elif self.spamorham[self.ids[message]] == 'spam':\n spam += 1\n else:\n print(\"ERROR!\")\n total += 1\n\n print(\"Total number of messages in the {0} cluster: {1}\\n\"\n \"Percentage of SPAM messages in the {2} cluster: {3}\\n\"\n \"Percentage of HAM messages in the {4} cluster: {5}\".format(value, total, value,\n str((float(spam) / total) * 100), value,\n str((float(ham) / total) * 100)))","def cluster(self, documents, iters=10):\n ###TODO\n self.means = documents[0:self.k]\n self.cluster = defaultdict(lambda : int)\n self.docs = documents\n \n for val in range(iters):\n self.norms = []\n for x in self.means:\n self.norms.append(self.sqnorm(x))\n \n self.compute_clusters(documents)\n \n self.fin_clust = defaultdict(lambda:[])\n for z in self.cluster:\n self.fin_clust[self.cluster[z]].append(z)\n \n self.means = self.compute_means()\n \n to_print_array = []\n for k in self.fin_clust:\n to_print_array.append(len(self.fin_clust[k]))\n \n print (to_print_array)\n print (self.error(documents))","def update_clusters(examples, cluster_averages):\n # find the closest cluster and move the example to that one\n for example in examples:\n example.type = closest_cluster(cluster_averages, example)","def progressUpdate(clusterid):\n progress_update.updateProgress(clusterid)","def cluster_num(self, cluster_num):\n\n self._cluster_num = cluster_num","def _init_centroid(self, seed: int):\n random.seed(seed)\n self.centroid_info = dict()\n self.cluster_result = dict()\n self.centroid_stable_flag = dict()\n for key_index, chosen_value in enumerate(\n random.sample(self.list_data, self.n_cluster)):\n self.centroid_info.setdefault(\"c\" + str(key_index), float(chosen_value))\n self.cluster_result.setdefault(\"c\" + str(key_index), list())\n self.centroid_stable_flag.setdefault(\"c\" + str(key_index), False)","def K_Means(self, n_clusters: int=150):\n start_time = datetime.datetime.now()\n self.func_log(\"\\n\\tIn K-Measn()\")\n \n kmeans = KMeans(n_clusters = n_clusters)\n kmeans.fit(self.descriptor_list)\n self.visual_words = kmeans.cluster_centers_ \n \n end_time = datetime.datetime.now() \n self.func_log(\"\\n\\t\\tTime Cost: {}\\n\".format(end_time-start_time))","def clustering_and_visulization(self):\n centroids, _ = kmeans(self.data_mat, self.k)\n idx, _ = vq(self.data_mat, centroids)\n for i in range(self.k):\n\n self.plot_list.append(self.data_mat[idx == i, 0])\n self.plot_list1.append(self.data_mat[idx == i, 1])\n\n for j in range(self.k):\n plot(self.plot_list[j], self.plot_list1[j], self.color_code[j])\n plot(centroids[:, 0], centroids[:, 1], 'sg', markersize=8)\n show()\n for i in range(self.k):\n self.cluster = self.data_mat[idx == i]\n self.clusterlist.append(self.cluster)\n\n for i in range(len(self.clusterlist)):\n self.clusterdict[i] = self.clusterlist[i]\n print(self.clusterdict)\n\n\n self.indexdict = {}\n for i in self.clusterdict:\n self.indexdict[i] = []\n print(len(self.clusterdict))\n for i in range(len(idx)):\n for j in range(len(self.clusterdict)):\n if (self.clusterdict[j][:] == self.data_mat[i]).any():\n self.indexdict[j].append(i)\n print(\"cluster dict of packs\",self.indexdict)\n\n self.drugdict = {}\n for i in self.clusterdict:\n self.drugdict[i] = []\n self.drug=[]\n for i in range(len(self.indexdict.keys())):\n for j in range(len(self.indexdict[i])):\n self.drugdict[i].append(self.df.iloc[self.indexdict[i][j]].to_dict())\n print(\"drugs dict with their frequencies\",self.drugdict)\n clusterdict_from_df_as_drug_non_O_frequency = {}\n clusterdict_from_as_drugs_only_as_list = {}\n clusterdict_of_non_repeated_drugs ={}\n for i in self.drugdict:\n clusterdict_from_df_as_drug_non_O_frequency[i] = []\n for i in self.drugdict:\n for j in self.drugdict[i]:\n clusterdict_from_df_as_drug_non_O_frequency[i].append({x: y for x, y in j.items() if y != 0})\n print(\"clusterdict_from_df_as_drug_non_O_frequency\", clusterdict_from_df_as_drug_non_O_frequency)\n print('\\n')\n\n for i in self.drugdict:\n clusterdict_from_as_drugs_only_as_list[i] = []\n\n for i in self.drugdict:\n for j in clusterdict_from_df_as_drug_non_O_frequency[i]:\n clusterdict_from_as_drugs_only_as_list[i].append(j.keys())\n\n print(\"only keys drugs with drugs name\", clusterdict_from_as_drugs_only_as_list)\n print('\\n')\n\n\n for i in self.drugdict:\n clusterdict_of_non_repeated_drugs[i]=list(more_itertools.collapse([list(x) for x in set([tuple(x) for x in clusterdict_from_as_drugs_only_as_list[i]])]))\n\n\n print(\"only drugs only\", clusterdict_of_non_repeated_drugs)\n\n########################################################################################################################\n try:\n common_drug_list = [x for x in clusterdict_of_non_repeated_drugs[0] if x in clusterdict_of_non_repeated_drugs[1]]\n print('\\n')\n print(\"common drug list\", common_drug_list)\n total_frequency_of_drugs_dict = {}\n for i in self.drugdict:\n total_frequency_of_drugs_dict[i] = []\n\n for drug in common_drug_list:\n\n for cluster_keys in clusterdict_from_df_as_drug_non_O_frequency.keys():\n temp_list = []\n for cluster_values_as_list in clusterdict_from_df_as_drug_non_O_frequency[cluster_keys]:\n try:\n temp_list.append(cluster_values_as_list[str(drug)])\n except KeyError:\n print(\"\\t\")\n total_frequency_of_drugs_dict[cluster_keys].append(np.sum(temp_list))\n print(\"total drugs frequency\",total_frequency_of_drugs_dict)\n total_frequency_of_drugs_dict_with_drugs = {}\n for i in self.drugdict:\n total_frequency_of_drugs_dict_with_drugs[i] = []\n temp_list1 = []\n temp_list2 = []\n for keys in self.drugdict.keys():\n temp_list1.append(clusterdict_of_non_repeated_drugs[keys])\n for keys in self.drugdict.keys():\n temp_list2.append(total_frequency_of_drugs_dict[keys])\n temp_list3 = []\n for i in temp_list1:\n for j in temp_list2:\n temp_list3.append(dict(zip(i,j)))\n temp_list4 = temp_list3[:2]\n print('\\n')\n for keys in self.drugdict:\n total_frequency_of_drugs_dict_with_drugs[keys].append(temp_list4[keys])\n print(\"total frequency with drugs dict\",total_frequency_of_drugs_dict_with_drugs)\n\n final_drugs_in_clusters_dict = {}\n for i in self.drugdict:\n final_drugs_in_clusters_dict[i] = []\n compare_list = []\n for drug in common_drug_list:\n compare_list.append(min(total_frequency_of_drugs_dict_with_drugs[0][0][drug], total_frequency_of_drugs_dict_with_drugs[1][0][drug]))\n print(\"compare list\",compare_list)\n for values in total_frequency_of_drugs_dict_with_drugs.values():\n for key1, value1 in values[0].items():\n if value1 in compare_list:\n\n key2 =values[0].keys()[values[0].values().index(value1)]\n values[0].pop(key2, None)\n\n\n print('final dict with deleted keys', total_frequency_of_drugs_dict_with_drugs)\n\n clusterdict_from_as_drugs_only_as_list = {}\n clusterdict_of_non_repeated_drugs = {}\n\n for i in self.drugdict:\n clusterdict_from_as_drugs_only_as_list[i] = []\n\n for i in self.drugdict:\n for j in total_frequency_of_drugs_dict_with_drugs[i]:\n clusterdict_from_as_drugs_only_as_list[i].append(j.keys())\n print(\"only keys drugs with drugs name\", clusterdict_from_as_drugs_only_as_list)\n print('\\n')\n\n for i in self.drugdict:\n clusterdict_of_non_repeated_drugs[i] = list(more_itertools.collapse([list(x) for x in set([tuple(x) for x in clusterdict_from_as_drugs_only_as_list[i]])]))\n print(\"only drugs\",clusterdict_of_non_repeated_drugs)\n\n final_robot_packs_dict = {}\n for i in self.drugdict:\n final_robot_packs_dict[i] = []\n\n winner_drug_dict = {}\n for i in common_drug_list:\n winner_drug_dict[i] = []\n for drug in common_drug_list:\n if drug in clusterdict_of_non_repeated_drugs[0]:\n winner_drug_dict[str(drug)].append(0)\n if drug in clusterdict_of_non_repeated_drugs[1]:\n winner_drug_dict[str(drug)].append(1)\n print(\"winner drug dict\",winner_drug_dict)\n\n for i in self.indexdict:\n print(i)\n for pack in self.indexdict[i]:\n packdict = self.df.iloc[pack].to_dict()\n packdict_non_0 = {x: y for x, y in packdict.items() if y != 0}\n packdict_non_0_key = packdict_non_0.keys()\n for drug in packdict_non_0_key:\n if drug in clusterdict_of_non_repeated_drugs[0]:\n final_robot_packs_dict[0].append(pack)\n elif drug in clusterdict_of_non_repeated_drugs[1]:\n final_robot_packs_dict[1].append(pack)\n\n final_robot_packs_dict[i].append(pack)\n for commondrugs in winner_drug_dict:\n for winnercluster in winner_drug_dict[commondrugs]:\n if winnercluster==0:\n loosercluster =1\n if winnercluster == 1:\n loosercluster = 0\n if commondrugs in packdict_non_0_key and i==loosercluster:\n try:\n final_robot_packs_dict[i].remove(pack)\n final_robot_packs_dict[winnercluster].append(pack)\n except ValueError:\n print('\\t')\n\n for i in self.indexdict:\n final_robot_packs_dict[i] = set(final_robot_packs_dict[i])\n\n print(\"final which pack which robot dict\",final_robot_packs_dict)\n\n except IndexError:\n print(\"No common drugs\")","def cluster(self):\n logger.debug(\"Beginning feature based clustering on %d clusters.\" % len(self.c2b))\n # Merge the two nearest clusters until we can't.\n #\n while self.mergeNearestClusters():\n pass\n logger.debug(\"After clustering, there are now %d clusters remaining.\" % len(self.c2b))\n return self.c2b.values()","def cluster(self):\r\n\t\tself.clusterer.fit(self.koopman_feature_array)\r\n\t\tself.labels = self.clusterer.labels_\r\n\t\tfor j in range(max(self.labels)+1):\r\n\t\t\tself.koop_cluster_list.append([self.koop_list[i] for i in range(len(self.labels)) if self.labels[i] == j])\r\n\t\t\tself.koop_cluster_memb_prob_list.append([self.clusterer.probabilities_[i] for i in range(len(self.labels)) if self.labels[i] == j])","def update_distribution(self):\n for m in range(0, self.document_number, 1):\n for k in range(0, self.topic_number, 1):\n self.document_distribution_over_topic[m][k]+=((self.document_topic_count_matrix[m][k] + self.alpha[k])\n / (self.sum_document_by_topic_count[m] + self.sum_alpha))\n for k in range(0, self.topic_number, 1):\n for v in range(0, self.term_number,1):\n self.topic_distribution_over_term[k][v] += ((self.topic_term_count_matrix[k][v] + self.beta[v]) / \\\n (self.sum_topic_by_term_count[k] + self.sum_beta))\n # the number of times that the distributions are updated.\n self.update_number += 1","def cluster_bal_iter(self):\n # moving\n for j,cluster in enumerate(self.clusters):\n cluster.move()\n self.clusters_allocate_cells()\n for j,cluster in enumerate(self.clusters):\n cluster.calc()\n #print j, '\\t', cluster.center, '\\t', cluster.np, '\\t', cluster.size\n \n # resizing\n for j,cluster in enumerate(self.clusters):\n cluster.resize()\n self.clusters_allocate_cells()\n for j,cluster in enumerate(self.clusters):\n cluster.calc()\n #print j, '\\t', cluster.center, '\\t', cluster.np, '\\t', cluster.size\n \n self.calc()","def compute_clusters(self, documents):\n ###TODO\n for d in range(0, len(documents)):\n maxi = 999999999\n for cid in range(0, len(self.means)):\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\n if dist < maxi:\n maxi = dist\n clust = cid \n self.cluster[d] = clust","def clusterMonitor():\n node = os.environ['DIM_DNS_NODE']\n xml = XMLTaskList.TransformXmlToObjects()\n xml.load('../xml/TaskInventory.xml') # loads the Task Inventory\n xml.load('../xml/HLTD01.xml') # loads the Node List\n xml.load('../xml/HLTD02.xml') # loads the Node List\n xml.load('../xml/HLTD03.xml') # loads the Node List\n xml.load('../xml/HLTD04.xml') # loads the Node List\n xml.load('../xml/HLTD06.xml') # loads the Node List\n xml.load('../xml/HLTD07.xml') # loads the Node List\n xml.load('../xml/HLTD08.xml') # loads the Node List\n xml.load('../xml/HLTD09.xml') # loads the Node List\n xml.load('../xml/HLTD10.xml') # loads the Node List\n xml.load('../xml/HLTD11.xml') # loads the Node List\n xml.load('../xml/HLTE04.xml') # loads the Node List\n xml.load('../xml/HLTE06.xml') # loads the Node List\n xml.load('../xml/'+node.upper()+'.xml') # loads the Node List\n collector = ClusterCollector(xml)\n collector.startx()\n collector.run()","def test_refresh_cluster(self):\n # Save original cluster wrapper for later comparison\n orig_clust_wrap = pvm_clust.Cluster.wrap(self.clust_resp)\n # Prime _clust_wrap\n ssp_stor = self._get_ssp_stor()\n # Verify baseline call counts\n self.assertEqual(1, self.mock_search.call_count)\n self.assertEqual(0, self.mock_clust_refresh.call_count)\n clust_wrap = ssp_stor._refresh_cluster()\n # This should call refresh\n self.assertEqual(1, self.mock_search.call_count)\n self.assertEqual(0, self.apt.read.call_count)\n self.assertEqual(1, self.mock_clust_refresh.call_count)\n self.assertEqual(clust_wrap.name, orig_clust_wrap.name)","def set_nb_clusters(self):\n \n print(\"Finding the optimal number of clusters...\")\n \n sample = ro.r.matrix(self.df[self.df[\"filename\"].between(1, 4)][\"active_power\"].to_numpy())\n \n r=ro.r(\"\"\"\n check = function(matrix) {\n n_clust = fviz_nbclust(matrix, kmeans, k.max = 15)\n\n n_clust = n_clust$data\n\n max_cluster = as.numeric(n_clust$clusters[which.max(n_clust$y)])\n return(max_cluster)\n }\n \"\"\")\n\n result = r(sample)\n self.conf[\"nb_clust\"] = int(result[0])\n \n print(f\"Optimal number of clusters is {self.conf['nb_clust']}\\n\")","def update(self, predictions, real_vals):\n for pred, actual in zip(predictions, real_vals):\n self.cm.loc[actual, pred] += 1","def multiClusterAlgorithm(values):\n clusterMap = dict()\n # Lowest unixtime in the values list\n startUnixtime = values[0][0]\n # Separate values into separate clusters in the map, clusterMap\n for value in values:\n if value[2] not in clusterMap.keys():\n clusterMap[value[2]] = []\n clusterMap[value[2]].append(value)\n \n # An array of the predicted values per cluster\n clusterPredicted = []\n # An array of unixtime averages per cluster\n unixtimeAverage = []\n \n # Generate predicted value for each cluster using a weighted average\n # Adds predicted value for each cluster to clusterPredicted and adds\n # the unixtime average for each cluster to unixtimeAverage\n for key in clusterMap.keys():\n clusterLength = len(clusterMap[key]) \n totalUnixtime = sum([elem[0] for elem in clusterMap[key]])\n unixtimeAverage.append(float(totalUnixtime) / float(clusterLength))\n \n clusterLight = [elem[1] for elem in clusterMap[key]]\n\n totalDistanceFromStart = sum([elem[0] - startUnixtime for elem in clusterMap[key]])\n clusterWeightValues = [float(elem[0] - startUnixtime) / float(totalDistanceFromStart) for elem in clusterMap[key]]\n \n predicted = np.average(clusterLight, weights = clusterWeightValues)\n clusterPredicted.append(predicted)\n \n print clusterPredicted\n total = sum([elem - startUnixtime for elem in unixtimeAverage])\n # Create weighted values based on unixtime average per cluster\n weightValues = [float(elem - startUnixtime) / float(total) for elem in unixtimeAverage]\n print weightValues\n # Return a weighted average across clusters\n return np.average(clusterPredicted, weights = weightValues)","def _cmeans0_kth_lfreq(data, u_old, c, m, *para):\n\t# parameters\n\tk = para[0]\n\tlocation_frequency = para[1]\n\n\t# Normalizing, then eliminating any potential zero values.\n\tu_old /= np.ones((c, 1)).dot(np.atleast_2d(u_old.sum(axis=0)))\n\tu_old = np.fmax(u_old, np.finfo(np.float64).eps)\n\n\tum = u_old ** m\n\n\t# calculating u_c\n\t#u_c = u_old / u_old.sum(axis=1)[:,None]\n\n\t# remain the belonging rate >= the k-th max location of each cluster in um_c\n\tfilter_k = lambda row:row < sorted(row, reverse=True)[k-1]\n\tfail_indices = np.apply_along_axis(filter_k, axis=1, arr=u_old)\n\tum[fail_indices] = 0\n\tum_f = um * (np.ones((um.shape[0], 1)).dot(np.atleast_2d(location_frequency)))\n\n\t# cluster freqeuncy\n\ttrue_indices = np.invert(fail_indices)\n\tcluster_frequency = true_indices.dot(np.atleast_2d(location_frequency).T)\n\tcluster_frequency = cluster_frequency / np.amax(cluster_frequency)\n\n\t# Calculate cluster centers\n\tdata = data.T\n\t# data1:2861,2; um:30,2861\n\tcntr = um_f.dot(data) / (np.ones((data.shape[1],1)).dot(np.atleast_2d(um_f.sum(axis=1))).T)\n\t#d = _distance(data, cntr) * 100 # euclidean distance\n\td = cdistance.get_center_distance(data, cntr)\n\n\tjm = (um * d ** 2).sum()\n\n\tu = (d ** (- 2. / (m - 1))) * cluster_frequency.dot(np.ones((1, d.shape[1])))\n\tu /= np.ones((c, 1)).dot(np.atleast_2d(u.sum(axis=0)))\n\t#print(\" - d:\", d[0:5, 0:3], \"\\n - u:\", u[0:5, 0:3])\n\treturn cntr, u, jm, d","def media(self):\n self.kmeans = [[] for i in range(0,self.cluster_number)]\n for i in range(self.cluster_number):\n for j in range(0,len(self.cluster[i][0])):\n self.kmeans[i].append(np.sum(self.cluster[i][::,j:j+1:])/len(self.cluster[i][::,j:j+1:]))","def update_cluster_config(self, clusterid, config, **kwargs):\n pass","def patch_cluster(self, cluster, *args, **kwargs):\n raise NotImplementedError","def update_cluster_hosts(self, hosts):\n self._hosts = hosts\n self._collect_hosts_d = True","def cpu_freq(self):\n self.monitoring_object['cpu_freq'] = \\\n psutil.cpu_freq(percpu=True)","def automerge_clusters(self):\n all_clusters = self.get_clusters().copy()\n\n if not self._single: # if not in single mode mode\n # initialize the variable to check if some change has happened \n changed = False\n for cl_1 in all_clusters: # cycle over clusters\n c_c1 = all_clusters[cl_1]\n for cl_2 in all_clusters: # inner cycle over clusters\n c_c2 = all_clusters[cl_2]\n # if two clusters have the same speaker and have different \n # cluster identifiers\n if cl_1 != cl_2 and c_c1.get_speaker() != 'unknown' and c_c1.get_speaker() == c_c2.get_speaker() and self._clusters.has_key(cl_1) and self._clusters.has_key(cl_2):\n changed = True\n # merge the clusters an record that something changed\n self._merge_clusters(cl_1, cl_2)\n if changed: # if something has changed\n # rename all the clusters starting from S0\n self._rename_clusters()\n # remove also the old waves and seg files of the old clusters\n shutil.rmtree(self.get_file_basename())\n # rebuild all seg files\n self.generate_seg_file(set_speakers=False)\n # resplit the original wave file according to the new clusters\n self._to_trim()","def test_update_hyperflex_cluster(self):\n pass","def update_count(self):\n pass","def version_recluster(self, serial, cluster,\n update_statistics_ancestors_depth=None):\n\n props = self.version_get_properties(serial)\n if not props:\n return\n node = props[NODE]\n size = props[SIZE]\n oldcluster = props[CLUSTER]\n if cluster == oldcluster:\n return\n\n mtime = time()\n self.statistics_update_ancestors(node, -1, -size, mtime, oldcluster,\n update_statistics_ancestors_depth)\n self.statistics_update_ancestors(node, 1, size, mtime, cluster,\n update_statistics_ancestors_depth)\n\n q = \"update versions set cluster = ? where serial = ?\"\n self.execute(q, (cluster, serial))","def update_clusters(self, data):\n\n self.unassigned_data_updated = [None]\n cluster_list = []\n cluster_indices = []\n bud_list = []\n bud_indices = []\n\n # First of all, seperate buds and clusters\n for cluster_index, cluster in self.clusters.items():\n if cluster.number_of_members < self.minnpix_cluster:\n bud_list.append(cluster)\n bud_indices.append(cluster_index)\n else:\n cluster_list.append(cluster)\n cluster_indices.append(cluster_index)\n\n # Take all of the bud data and put it back into an unassigned list\n unassigned_data_updated = []\n for i in range(len(bud_indices)):\n self.clusters.pop(bud_indices[i])\n idx = np.squeeze(np.where(self.cluster_arr[1,:] == bud_indices[i]))\n self.cluster_arr[1,idx] = -1.0\n unassigned_data_updated.extend(data[:,bud_list[i].cluster_members].T)\n\n # Turn that into an array and transpose\n unassigned_data_updated = np.asarray(unassigned_data_updated)\n unassigned_data_updated = unassigned_data_updated.T\n\n # There shouldn't be any in theory, but just check there are no duplicates\n try:\n unassigned_data_updated = np.unique(unassigned_data_updated, axis=1)\n except ValueError:\n pass\n\n # Sort the unassigned data according to peak intensity and send it back\n if np.size(unassigned_data_updated) != 0.0:\n sortidx = argsort(unassigned_data_updated[2,:], reversed=True)\n self.unassigned_data_updated = unassigned_data_updated[:,sortidx]\n else:\n pass\n\n return cluster_list, cluster_indices","def adjust_n_clusters(self, n_clusters):\n\t\tself.estimator = KMeans(init='k-means++', n_clusters=n_clusters)","def save_cluster_metrics_on_check_point(self) -> None:\n pd.read_csv(f'{self.path_to_cluster_metrics}/{self.file_name}.csv')\\\n .append(pd.DataFrame(self.cluster_metrics,\n columns=['stream_index', 'timestamp', 'check point', 'cluster id',\n 'x', 'y', 'radius', 'weight', 'cluster type']))\\\n .to_csv(f'{self.path_to_cluster_metrics}/{self.file_name}.csv', index=False)\n self.cluster_metrics = []","def cluster(self, k=3, max_iter=10):\n\n # create a set of k random clusters as seeds\n old_clusters = [None] * k # just a placeholder\n clusters = self.random_clusters(k)\n\n iter = 0\n while (iter < max_iter) and not (old_clusters == clusters):\n print \"iteration %d...\" % iter\n # assign new clusters to old clusters\n for i in xrange(0, k):\n old_clusters[i] = copy(clusters[i])\n clusters[i].documents = []\n\n # for each document\n for document in self.documents:\n\n # determine the cluster with the highest similarity\n similarities = [cosine_similarity(document, cluster) for cluster in old_clusters]\n max_index = array(similarities).argmax()\n\n # assign document to that cluster\n clusters[max_index].add(document)\n\n # update cluster means\n for cluster in clusters:\n cluster.update_centroid()\n \n iter += 1\n \n return clusters","def update_freq_dist(filename):\r\n pass","def update(self, x):\n self.time_since_update = 0\n self.hits += 1\n self.continuing_hits += 1\n self.kf.update(x)","def update(self, kf, detection):\n self.mean, self.covariance = kf.update(\n self.mean, self.covariance, detection.to_xyah())\n self.features.append(detection.feature)\n\n self.hits += 1\n self.time_since_update = 0\n if self.state == TrackState.Tentative and self.hits >= self._n_init:\n self.state = TrackState.Confirmed","def cluster(self):\n print(\"Calculating distances\")\n self.all_distances()\n\n print(\"Start making sets\")\n clusters = self.clusters\n\n # Generates a set with neighbours for each point\n for row in self.distances:\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\n\n print(\"Merging sets\")\n for cluster1 in range(self.point_count):\n for cluster2 in range(self.point_count):\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\n clusters[cluster1].update(clusters[cluster2])\n clusters[cluster2] = None\n # Deletes empty clusters\n clusters = [points for points in clusters if points is not None]\n # Sorts clusters by their size\n clusters.sort(key=len, reverse=True)\n # Builds main set\n for point_set in clusters[0:self.cluster_count_threshold]:\n self.main_cluster.update(point_set)\n\n self.main_cluster = list(self.main_cluster)\n self.clusters = clusters","def assignLabels(self):\n clusters = np.arange(0, len(self.V))[self.V < self.V1] #indexes self.V, volumes_sorted, and oldOrder\n self.clusterV = self.volumes_sorted[clusters]\n clusters = self.oldOrder[clusters] #indexes volumes\n self.clusters = self.nonBI[clusters] #indexes self.vor and self.data\n self.easyLabel = np.zeros(len(self.data))\n self.easyLabel[self.clusters] = 1\n print('Out of ' + str(len(self.data)) + ' particles, ' + str(len(self.clusters)) + ' (' + str(round(len(self.clusters)*100/len(self.data), 3)) +' %) are labelled as cluster particles.')","def _init_cluster(self):\n self._Init_Cluster()","def ConfigureCluster(messages, args, cluster):\n cluster.labels = labels_util.ParseCreateArgs(args,\n messages.Cluster.LabelsValue)","def clusters_every(self, clusters_every):\n\n self._clusters_every = clusters_every","def _setup_cluster(self):\n raise NotImplementedError('Must be implemented in subclasses.')","def clusterAlgorithm(values):\n clusterMap = dict()\n for value in values:\n if value[2] not in clusterMap.keys():\n clusterMap[value[2]] = []\n clusterMap[value[2]].append(value)\n frequency = [float(len(clusterMap[value[2]])) for value in values]\n total = sum(frequency)\n weightValues = [freq / total for freq in frequency]\n print sum(weightValues)\n lightValues = [value[1] for value in values]\n return np.average(lightValues, weights = weightValues)","def fit(self):\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\n self.merge_clusters([[6,33,52],[17,14]])\n self.sub_clustering(n_clusters=2, index_cluster=[0], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[2], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[85], linkage='average')\n self.sub_clustering(n_clusters=2, index_cluster=[14], linkage='complete')\n self.sub_clustering(n_clusters=2, index_cluster=[16], linkage='average')\n self.sub_clustering(n_clusters=3, index_cluster=[22], linkage='average')\n self.sub_clustering(n_clusters=2, index_cluster=[24], linkage='complete')\n self.sub_clustering(n_clusters=2, index_cluster=[26], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[28], linkage='ward')\n self.merge_clusters([[6,98,99]])\n self.merge_clusters([[35,80]])\n self.sub_clustering(n_clusters=4, index_cluster=[35], linkage='complete')\n self.merge_clusters([[76,98]])\n self.sub_clustering(n_clusters=3, index_cluster=[35], linkage='complete')\n self.merge_clusters([[39,42]])\n self.sub_clustering(n_clusters=3, index_cluster=[47], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='average')\n self.merge_clusters([[70,101]])\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='complete')\n self.sub_clustering(n_clusters=3, index_cluster=[61], linkage='ward')\n self.merge_clusters()\n return","def compute_clusters(self, p: float):\n pass","def recluster(cluster, min_size, guard, func):\r\n if cluster.get_length() == 0:\r\n return\r\n if cluster.get_length() <= min_size:\r\n return cluster\r\n sim = func(cluster.get_tweets())\r\n if sim < guard:\r\n kmeans = TweetKMeans(2)\r\n kmeans.set_data(cluster.get_tweets())\r\n return kmeans.start_algorithm()\r\n return cluster","def cluster_center_update_dataset(spn, dataset):\n\n if isinstance(spn, Categorical):\n\n insert_into_categorical_leaf(spn, np.array([dataset]), np.array([1.0]))\n\n return spn\n elif isinstance(spn, IdentityNumericLeaf):\n\n insert_into_identity_numeric_leaf(spn, np.array([dataset]), np.array([1.0]))\n\n return spn\n elif isinstance(spn, Sum):\n cc = spn.cluster_centers\n\n node_idx = 0\n\n min_dist = np.inf\n min_idx = -1\n for n in spn.children:\n # distance calculation between the dataset and the different clusters\n # (there exist a much faster version on scipy)\n # this? https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html\n #\n proj = projection(dataset, n.scope)\n dist = distance.euclidean(cc[node_idx], proj)\n if dist < min_dist:\n min_dist = dist\n min_idx = node_idx\n\n node_idx += 1\n assert min_idx > -1\n assert min_idx < len(spn.children)\n adapt_weights(spn, min_idx)\n cluster_center_update_dataset(spn.children[min_idx], dataset)\n elif isinstance(spn, Product):\n\n for n in spn.children:\n cluster_center_update_dataset(n, dataset)\n else:\n raise Exception(\"Invalid node type \" + str(type(spn)))\n spn.cardinality += 1","def newCluster(color_cluster):\n r = 0\n g = 0\n b = 0\n count = 0\n for cc in color_cluster:\n count += cc[0]\n r += cc[1][0] * cc[0]\n g += cc[1][1] * cc[0]\n b += cc[1][2] * cc[0]\n\n # print(\"r: \" + str(r))\n # print(\"g: \" + str(g))\n # print(\"b: \" + str(b))\n # print(\"count: \" + str(count))\n r_mean = int(r / count)\n g_mean = int(g / count)\n b_mean = int(b / count)\n cluster = (r_mean, g_mean, b_mean)\n # print(cluster)\n return cluster","def analyzeClusterPerformance(self, cluster):\n def calcOverlap(playlist, group):\n urls = set(group[\"uri\"].values)\n playlist = set(playlist)\n return len(urls & playlist)\n\n groupedDF = self.audioDF.groupby(cluster)\n playlists = list(self.playlists)\n\n clusters = [group for _, group in groupedDF]\n numSongs = sum([len(p) for p in playlists])\n\n numOverlap, maxOverlap = 0, 1\n while len(playlists) > 0 and len(clusters) > 0 and maxOverlap > 0:\n maxOverlap, pIDX, gIDX = 0, None, None\n for i, playlist in enumerate(playlists):\n for j, c in enumerate(clusters):\n overlap = calcOverlap(playlist, c)\n if overlap > maxOverlap:\n maxOverlap, pIDX, gIDX = overlap, i, j\n \n if maxOverlap > 0:\n playlists.pop(pIDX)\n clusters.pop(gIDX)\n numOverlap += maxOverlap\n\n performance = float(numOverlap) / float(numSongs)\n performancePercentage = round(performance, 4) * 100\n\n return {\n \"Clustering Algorithm\": cluster,\n \"Performance\": performance\n }","def update_cluster_results(session: Session, project: MasteringProject) -> Operation:\n op = _update_cluster_results_async(session, project)\n return operation.wait(session, op)","def update(self, kf, detection, detection_noise):\n self.mean, self.covariance = kf.update(\n self.mean, self.covariance, detection, detection_noise)\n\n self.hits += 1\n self.time_since_update = 0\n if self.state == TrackState.Tentative and self.hits >= self._n_init:\n self.state = TrackState.Confirmed","def setFreq(self,newfreq):\n\t\tself.freq = newfreq;","def updateCounter(self):\n self.counter = self.counter + 1\n self.syncDataStructure[\"+\"][str(self.instanceID)] = self.counter","def update_counts(self, new_alpha, new_beta, decay):\n\n self._alpha = self._alpha / decay + new_alpha\n self._beta = self._beta / decay + new_beta\n self._n_updates += 1","def update_avg_f1(ccs, gold_clusters, pred_clusters):\n gold_clusters, mention_to_gold = ccs.get_gold_clusters(gold_clusters)\n pred_clusters, mention_to_pred = ccs.get_gold_clusters(pred_clusters)\n\n # update scores\n scorers = ccs.scorers\n\n for scorer in scorers:\n scorer.update(pred_clusters, gold_clusters,\n mention_to_pred, mention_to_gold)","def reload(self):\n cluster_kubeconfig = self.ocp.cluster_kubeconfig\n self.data = self.get()\n self.__init__(**self.data)\n self.ocp.cluster_kubeconfig = cluster_kubeconfig","def train(self):\n freq_dist = self.getFreqDist()\n\n self.freq_dist = freq_dist","def update(self):\n old_centroid = self.centroid\n self.centroid = self.calc_centroid()\n return old_centroid.distance(self.centroid)","def update(self, labels, preds):\n labels, preds = check_label_shapes(labels, preds, True)\n\n for label, pred in zip(labels, preds):\n self.metrics.update_binary_stats(label, pred)\n\n if self.average == \"macro\":\n self.sum_metric += self.metrics.fscore\n self.num_inst += 1\n self.metrics.reset_stats()\n else:\n self.sum_metric = self.metrics.fscore * self.metrics.total_examples\n self.num_inst = self.metrics.total_examples","def cluster_density(self, cluster_density):\n\n self._cluster_density = cluster_density","def plot_events_cluster(self, cluster, distrib=True, dataname='', timeres=None):\n\n def plot_notimeres():\n \"\"\"\n All time colapsed\n @return:\n \"\"\"\n cont = np.zeros(cluster.num_clusters())\n for i in range(self.dataset.shape[0]):\n posy = self.dataset[i][0]\n posx = self.dataset[i][1]\n ejem = np.array([[posy, posx]]).reshape(1,-1)\n ncl = cluster.predict(ejem)\n ncl = ncl[0]\n\n if distrib:\n cont[ncl] += 1\n else:\n cont[ncl] = 1\n\n if distrib:\n cont = cont / np.max(cont)\n for i in range(cont.shape[0]):\n if cont[i] > 0.01:\n cx = cluster.cluster_centers_[i][0]\n cy = cluster.cluster_centers_[i][1]\n mymap.circle_marker(location=[cx, cy],\n radius=cont[i] * circlesize,\n line_color='#000000',\n fill_color='#110000',\n popup=str(cont[i]), fill_opacity=0.4)\n else:\n for i in range(cont.shape[0]):\n if cont[i] > 0.01:\n cx = cluster.cluster_centers_[i][0]\n cy = cluster.cluster_centers_[i][1]\n\n mymap.circle_marker(location=[cx, cy],\n radius=30,\n line_color='#000000',\n fill_color='#110000',\n popup=str(cont[i]), fill_opacity=0.4)\n\n def plot_timeres(timeres):\n \"\"\"\n Geo points separated by the time resolution zones\n @return:\n \"\"\"\n tint = 24 / len(timeres.intervals)\n step = 255 / (tint + 1)\n\n cont = np.zeros(cluster.num_clusters())\n for i in range(self.dataset.shape[0]):\n posy = self.dataset[i][0]\n posx = self.dataset[i][1]\n ejem = np.array([[posy, posx]]).reshape(1,-1)\n ncl = cluster.predict(ejem)\n ncl = ncl[0]\n\n if distrib:\n cont[ncl] += 1\n else:\n cont[ncl] = 1\n\n # if distrib:\n # cont = cont / np.max(cont)\n # for i in range(cont.shape[0]):\n # if cont[i] > 0.01:\n # cx = cluster.cluster_centers_[i][0]\n # cy = cluster.cluster_centers_[i][1]\n # mymap.circle_marker(location=[cx, cy],\n # radius=cont[i] * circlesize,\n # line_color='#FF0000',\n # fill_color='#110000')\n # else:\n # for i in range(cont.shape[0]):\n # if cont[i] > 0.01:\n # cx = cluster.cluster_centers_[i][0]\n # cy = cluster.cluster_centers_[i][1]\n # mymap.circle_marker(location=[cx, cy],\n # radius=30,\n # line_color='#FF0000',\n # fill_color='#110000')\n for t in range(tint):\n color = '#' + (str(hex((t + 1) * step))[2:]) + \\\n (str(hex((t + 1) * step))[2:]) + 'FF' # (str(hex((t+1)*step))[2:])\n cont = np.zeros(cluster.num_clusters())\n for i in range(self.dataset.shape[0]):\n posy = self.dataset[i][0]\n posx = self.dataset[i][1]\n ejem = np.array([[posy, posx]]).reshape(1,-1)\n ncl = cluster.predict(ejem)\n ncl = ncl[0]\n\n _, evtime = timeres.discretize(self.dataset[i][2])\n\n if evtime == t:\n if distrib:\n cont[ncl] += 1\n else:\n cont[ncl] = 1\n if distrib:\n cont = cont / np.max(cont)\n for i in range(cont.shape[0]):\n if cont[i] > 0.01:\n cx = cluster.cluster_centers_[i][0]\n cy = cluster.cluster_centers_[i][1]\n mymap.circle_marker(location=[cx, cy],\n radius=cont[i] * circlesize,\n line_color=pltcolors[t],\n fill_color=pltcolors[t], #'#110000',\n popup=str(t) + '-' + str(cont[i]), fill_opacity=0.2)\n else:\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i] > 0.01:\n cx = cluster.cluster_centers_[i][0]\n cy = cluster.cluster_centers_[i][1]\n mymap.circle_marker(location=[cx, cy],\n radius=30,\n line_color=pltcolors[t],\n fill_color=pltcolors[t], #'#110000',\n popup=str(t) + '-' + str(cont[i]), fill_opacity=0.2)\n\n print 'Generating the events plot ...'\n circlesize = 60000 * cluster.radius\n\n # if timeres == 0:\n # fig = plt.figure()\n # ax = fig.add_subplot(111)\n\n minLat, maxLat, minLon, maxLon = self.city[1]\n # normLat = scale / (maxLat - minLat)\n # normLon = scale / (maxLon - minLon)\n mymap = folium.Map(location=[(minLat + maxLat) / 2.0, (minLon + maxLon) / 2.0], zoom_start=12, width=1200,\n height=1000)\n\n if timeres is None:\n plot_notimeres()\n else:\n plot_timeres(timeres)\n\n #today = time.strftime('%Y%m%d%H%M%S', time.localtime())\n nfile = self.application + '-' + dataname + '-Clust'\n if self.mnhh is not None and self.mnhh is not None:\n nfile += '-nusr' + str(self.mxhh) + '#' + str(self.mnhh)\n\n if timeres is not None:\n nfile += '-tr' + str(timeres.intervals)\n nfile += '-s' + str(cluster.radius)\n\n # if timeres == 0:\n # fig.savefig(homepath + 'Results/' + self.city[2] + '-' +\n # nfile + '.pdf', orientation='landscape', format='pdf')\n # plt.close()\n mymap.create_map(path=homepath + 'Results/clusters/' + self.city[2] + nfile + '.html')","def add_new_cluster(self):\n self.result.append(Cluster.Cluster())\n return len(self.result) - 1","def cluster(self):\n\t\tself.index[\"cluster\"] = {}\n\n\t\tfor item in self.index[\"items\"]:\n\t\t\tself.index[\"cluster\"][item] = [{\"weight\" : float(len(set(self.index[\"items\"][item]).intersection( set(self.index[\"items\"][id]))))/float(len(self.index[\"items\"][item])) , \"name\" : id, \"authority\" : set(self.index[\"items\"][item]).intersection( set(self.index[\"items\"][id])) } for id in self.index[\"items\"] if id != item and len(set(self.index[\"items\"][item]).intersection( set(self.index[\"items\"][id]))) >= 1]\n\n\t\treturn self.index"],"string":"[\n \"def updateClusterInfo(self):\\n self.nPoints = len(self.labels)\\n self.n = len(np.unique(self.labels))\\n self.centers = [ [0.0 for j in range(3)] for i in range(self.n)]\",\n \"def update_cluster(self, cluster, params, *args, **kwargs):\\n raise NotImplementedError\",\n \"def add_update_cluster(self, label, cluster):\\n self._clusters[label] = cluster\",\n \"def cluster_cal(self):\\n self.Cluster = []\\n for i in range(self.nodenum):\\n neighborhood_node = self.neighbor_node(i)\\n Node_num = len(neighborhood_node)\\n Count = self.neighbor_edge(neighborhood_node)\\n if(Node_num == 0 or Node_num == 1):\\n self.Cluster.append(0.5)\\n else:\\n self.Cluster.append(Count/(Node_num*(Node_num - 1)))\\n \\n self.cluster_coeff = np.average(self.Cluster)\",\n \"def compute_cluster_metrics_helper(self, event_index: int, timestamp: datetime, cp_count: int,\\n cluster: Cluster, cluster_type: str) -> None:\\n self.cluster_metrics.append([event_index, timestamp, cp_count, cluster.id, cluster.centroid[0],\\n cluster.centroid[1], cluster.radius, cluster.weight, cluster_type])\",\n \"def _recalculate_centroids(self):\\n\\n self._prev_centroids = dict(self.centroids)\\n for cluster in self.clusters:\\n self.centroids[cluster] = np.average(self.clusters[cluster], axis=0)\",\n \"def update_frequencies():\\n pass\",\n \"def cluster(self, cluster):\\n\\n self._cluster = cluster\",\n \"def cluster(self, cluster):\\n\\n self._cluster = cluster\",\n \"def cluster(self, cluster):\\n\\n self._cluster = cluster\",\n \"def cluster(self, cluster):\\n\\n self._cluster = cluster\",\n \"def cluster(self, cluster):\\n\\n self._cluster = cluster\",\n \"def cluster(self, cluster):\\n\\n self._cluster = cluster\",\n \"def add_to_cluster_dictionary(self, cluster):\\n\\n self.clusters[self.cluster_idx] = cluster\\n update_cluster_array(self, cluster, cluster.cluster_idx)\\n\\n return\",\n \"def update_centroid(self):\\n\\n total_docs = len(self.documents)\\n\\n if total_docs == 0:\\n return\\n\\n new_centroid = self.centroid.copy()\\n for document in self.documents:\\n new_centroid = new_centroid + document.vector\\n\\n self.centroid = new_centroid / float(total_docs)\",\n \"def update(self, clusters):\\n centroids = {}\\n for cluster, coordinates in clusters.iteritems():\\n sumLat = 0\\n sumLong = 0\\n for coordinate in coordinates:\\n sumLat += float(coordinate[0])\\n sumLong += float(coordinate[1])\\n centroids[cluster] = (sumLat/float(len(coordinates)), sumLong/float(len(coordinates)))\\n return centroids\",\n \"def __initCluster(self):\\n data_size, cluster_center = self.data_size, self.cluster_center\\n self.cluster_temp = np.zeros(data_size, dtype=int)\\n self.cluster_upper_bound = np.full(len(cluster_center), float('inf'), dtype=float)\\n for center in cluster_center:\\n self.cluster_temp[center] = center\",\n \"def cluster_counter(self):\\n return Counter(self.model.labels_.tolist())\",\n \"def assign_labels_to_centroids(self):\\n labelled_centroids = []\\n for i in range(len(self.final_clusters)):\\n labels = map(lambda x: x[0], self.final_clusters[i])\\n # pick the most common label\\n most_common = Counter(labels).most_common(1)[0][0]\\n c = np.round(len([item for item in self.final_clusters[i] if item[0]==1])/len(self.final_clusters[i]),2)\\n if c>=0.46:\\n most_common = 1.0\\n centroid = (most_common, self.final_centroids[i])\\n labelled_centroids.append(centroid)\\n\\n self.labelled_centroids = labelled_centroids\\n print(\\\"cluster_0: \\\", np.round(len([item for item in self.final_clusters[0] if item[0]==1])/len(self.final_clusters[0]),2), \\\"size_0: \\\", len(self.final_clusters[0]))\\n print(\\\"cluster_1: \\\", np.round(len([item for item in self.final_clusters[1] if item[0]==1])/len(self.final_clusters[1]),2), \\\"size_1: \\\", len(self.final_clusters[1]))\\n #print(\\\"cluster_2: \\\", np.round(len([item for item in self.final_clusters[2] if item[0]==1])/len(self.final_clusters[2]),2), \\\"size_2: \\\", len(self.final_clusters[2]))\\n #print(\\\"cluster_3: \\\", np.round(len([item for item in self.final_clusters[3] if item[0]==1])/len(self.final_clusters[3]),2), \\\"size_2: \\\", len(self.final_clusters[3]))\",\n \"def UpdateFrequency(self, newfreq):\\n\\n if self.strategy:\\n setattr(self.strategy, managers.UTICK, newfreq)\",\n \"def setBestCluster(cluster):\\r\\n global bestCluster\\r\\n bestCluster = cluster\",\n \"def run(self):\\n for i,p in enumerate(self.pairs):\\n self.forPointPair(i)\\n if i % 100000 == 0:\\n print('Percentage Processed: ' + str(round(i * 100 / len(self.pairs), 3)) + '. Existing Cluster Labels: ', len(np.unique(self.labels)))\",\n \"def compute_cluster_metrics(self, event_index: int, timestamp: datetime, cp_count: int,\\n normal_clusters: Tuple[List[List], List[List]], o_clusters: List[Cluster]) -> None:\\n c_clusters, p_clusters = normal_clusters[0], normal_clusters[1]\\n for group in c_clusters:\\n for cluster in group:\\n self.compute_cluster_metrics_helper(event_index, timestamp, cp_count, cluster, 'core micro-cluster')\\n\\n for group in p_clusters:\\n for cluster in group:\\n self.compute_cluster_metrics_helper(event_index, timestamp, cp_count, cluster, 'potential micro-cluster')\\n\\n for cluster in o_clusters:\\n self.compute_cluster_metrics_helper(event_index, timestamp, cp_count, cluster, 'outlier micro-cluster')\",\n \"def _relocate_clusters(self, cluster_labels):\\n for cluster_label in range(self.k):\\n if cluster_labels[cluster_label] is not None:\\n # mean of the pixels assigned to cluster\\n p_sum, p_count = np.asarray(\\n cluster_labels[\\n cluster_label\\n ]).sum(axis=0), len(cluster_labels[cluster_label])\\n self._clusters[cluster_label] = p_sum / p_count\",\n \"def diffusion(self, initval, clusterList, coalescenceList, smeasure):\\n partServ = ParticleService()\\n for pl in coalescenceList.GET():\\n partServ.ClusterDiffusion(self.initVal, pl)\",\n \"def disaggregate_by_cluster(self):\\n # wt = np.zeros((1, self.ds.shape[1]))\\n # total = np.zeros((self.n_ahead, self.ds.shape[1]))\\n \\n agg_cluster_ds = np.zeros((self.n_ahead+1, self.n_clusters))\\n agg_cluster_ds[0] = self.ds_agg_by_c[-1]\\n agg_cluster_ds[1:] = self.ds_c_for\\n cluster_perc_change = np.diff(agg_cluster_ds, axis = 0) / agg_cluster_ds[:-1]\\n\\n cluster_scaling_vector = np.zeros((2, self.ds.shape[1]))\\n\\n # break down proportionally -> don't work well\\n # for c in range(self.n_clusters):\\n # c_m = self.ds.iloc[-self.cluster_n_period:, np.where(self.ds_c == c)[0]]\\n # c_sum = sum(c_m)\\n # indiv_sum = np.sum(c_m, axis = 0)\\n # wt[:,np.where(self.ds_c == c)[0]] = (indiv_sum/c_sum)\\n # total[:,np.where(self.ds_c == c)[0]] = np.reshape(\\n # np.repeat(self.ds_c_for[:,c], c_m.shape[1]), (self.n_ahead, c_m.shape[1]))\\n \\n # multiply by the perc change\\n \\n for i in range(self.ds_c.shape[0]):\\n cluster_scaling_vector[:,i] = cluster_perc_change[:,self.ds_c[i]]\\n cluster_scaling_vector = cluster_scaling_vector+1\\n cluster_scaling_vector = np.array(cluster_scaling_vector)\\n \\n self.ds_for = self.ds.copy()\\n\\n for yr in range(self.n_ahead)[::-1]:\\n # forecast on foretasted number\\n yr_ind = self.ds_for.index[-(yr+1)]\\n self.ds_for.ix[yr_ind] = self.ds_for.iloc[-(yr+2),:].values * cluster_scaling_vector[-(yr+1)]\\n\\n # self.ds_for.iloc[-(self.n_ahead):,:] = self.ds_for.iloc[-(self.n_ahead+1):-1,:].values * np.array(cluster_scaling_vector)\\n\\n # if negative -> 0\\n self.ds_for[self.ds_for < 0] = 0\",\n \"def _update_centroid_location(self):\\n previous_centroid_info = copy.deepcopy(self.centroid_info)\\n for centroid, belongings in self.cluster_result.items():\\n if not self.centroid_stable_flag.get(centroid):\\n temp_list = list()\\n temp_list.append(self.centroid_info.get(centroid))\\n temp_list.extend(belongings)\\n\\n self.centroid_info[centroid] = float(sum(temp_list) / len(temp_list))\\n\\n return previous_centroid_info, self.centroid_info\",\n \"def clusters(self, clusters):\\n\\n self._clusters = clusters\",\n \"def clusters(self, clusters):\\n\\n self._clusters = clusters\",\n \"def clusters(self, clusters):\\n\\n self._clusters = clusters\",\n \"def eval_cluster_contingency(clustering_alg: List, labels_true, sdist):\\n for (alg_name, alg_dict) in clustering_alg:\\n if \\\"alg\\\" in alg_dict:\\n clustering = alg_dict[\\\"alg\\\"].fit(sdist)\\n labels_pred = clustering.labels_\\n alg_dict[\\\"labels\\\"] = labels_pred\\n else:\\n labels_pred = alg_dict[\\\"labels\\\"]\\n\\n pred_label_dict, new_labels = normalize_labels(labels_pred)\\n\\n alg_dict[\\\"cm\\\"] = contingency_matrix(labels_true, new_labels)\",\n \"def clustering_and_visulization(self):\\n try:\\n centroids, _ = kmeans(self.data_mat, self.k)\\n except ValueError:\\n print(\\\"The number of clusters is more than the data points\\\")\\n self.idx, _ = vq(self.data_mat, centroids)\\n for i in range(self.k):\\n\\n self.plot_list.append(self.data_mat[self.idx == i, 0])\\n self.plot_list1.append(self.data_mat[self.idx == i, 1])\\n\\n for j in range(self.k):\\n plot(self.plot_list[j], self.plot_list1[j], self.color_code[j])\\n plot(centroids[:, 0], centroids[:, 1], 'sg', markersize=8)\\n show()\\n\\n for i in range(self.k):\\n self.cluster = self.data_mat[self.idx == i]\\n self.clusterlist.append(self.cluster)\\n print(self.clusterlist)\\n for i in range(len(self.clusterlist)):\\n self.clusterdict[i] = self.clusterlist[i]\\n print(self.clusterdict)\\n\\n index_dict ={}\\n for i in self.clusterdict:\\n index_dict[i] = []\\n for i in range(len(self.data_mat)):\\n for j in range(len(self.clusterdict)):\\n if (self.clusterdict[j][:] == self.data_mat[i]).any():\\n index_dict[j].append(i)\\n print(\\\"drugs cluster dict\\\", index_dict)\\n\\n self.drugsdict = {}\\n for i in index_dict:\\n self.drugsdict[i] = []\\n drugslist = list(self.df.columns.values)\\n print(\\\"drugs list from dataframe\\\", drugslist)\\n\\n for i in index_dict:\\n self.drugsdict[i] = [drugslist[index] for index in index_dict[i]]\\n\\n print(\\\"drugs cluster dict\\\", self.drugsdict)\\n########################################################################################################################\\n clusterdict_from_df_as_drug_frequency = {}\\n clusterdict_from_df_as_drug_non_O_frequency = {}\\n\\n print('\\\\n')\\n\\n for i in range(len(self.df)):\\n clusterdict_from_df_as_drug_frequency[i] = []\\n\\n for i in range(len(self.df)):\\n clusterdict_from_df_as_drug_frequency[i].append(self.df.iloc[i].to_dict()) #\\n print(\\\"packs in dict form of drugs frequency\\\", clusterdict_from_df_as_drug_frequency)\\n\\n for i in range(len(self.df)):\\n clusterdict_from_df_as_drug_non_O_frequency[i] = []\\n\\n for i in range(len(self.df)):\\n for j in clusterdict_from_df_as_drug_frequency[i]:\\n clusterdict_from_df_as_drug_non_O_frequency[i].append({x: y for x, y in j.items() if y != 0})\\n print(\\\"clusterdict_from_df_as_drug_non_O_frequency\\\", clusterdict_from_df_as_drug_non_O_frequency)\\n print('\\\\n')\\n clusterdict_from_as_drugs_only_as_list = {}\\n clusterdict_of_non_repeated_drugs = {}\\n for i in range(len(self.df)):\\n clusterdict_from_as_drugs_only_as_list[i] = []\\n\\n for i in range(len(self.df)):\\n for j in clusterdict_from_df_as_drug_non_O_frequency[i]:\\n clusterdict_from_as_drugs_only_as_list[i].append(j.keys())\\n\\n print(\\\"only keys drugs with drugs name\\\", clusterdict_from_as_drugs_only_as_list)\\n print('\\\\n')\\n\\n for i in range(len(self.df)):\\n clusterdict_of_non_repeated_drugs[i] = list(more_itertools.collapse(\\n [list(x) for x in set([tuple(x) for x in clusterdict_from_as_drugs_only_as_list[i]])]))\\n\\n print(\\\"only drugs only\\\", clusterdict_of_non_repeated_drugs)\\n\\n########################################################################################################################\\n robot_for_packs_dict = {}\\n for i in range(len(self.df)):\\n robot_for_packs_dict[i] = []\\n\\n # for i in range(len(self.df)):\\n for i in range(len(self.df)):\\n for j in clusterdict_of_non_repeated_drugs[i]:\\n if j in self.drugsdict[0]:\\n robot_for_packs_dict[i].append(0)\\n elif j in self.drugsdict[1]:\\n robot_for_packs_dict[i].append(1)\\n for i in range(len(self.df)):\\n robot_for_packs_dict[i] = set(robot_for_packs_dict[i])\\n\\n for i in range(len(self.df)):\\n robot_for_packs_dict[i] = list(more_itertools.collapse(robot_for_packs_dict[i]))\\n print('\\\\n')\\n print(\\\"clusterdict_of_non_repeated_drugs\\\", robot_for_packs_dict)\",\n \"def start(self):\\n\\t\\tself.distributedVarPart()\\n\\t\\twhile self.t < self.T:\\n\\t\\t\\tself.t += 1\\n\\t\\t\\tfor cluster in self.clusterList:\\n\\t\\t\\t\\tprint(\\\"cluster: \\\")\\n\\t\\t\\t\\tprint(cluster)\\n\\t\\t\\t\\tprint(self.clusterList[cluster])\\n\\t\\t\\t\\tself.C[cluster] = self.average_consensus(self.clusterList[cluster])\\n\\t\\t\\tprint(self.C)\\n\\t\\t\\tprint(\\\"turn t=%s: Centroids%s\\\"% (self.t, self.C), flush=True)\\n\\t\\t\\ttime.sleep(1)\",\n \"def initClusters(self):\\n if len(self.labelList) != len(self.pointList):\\n \\traise ValueError(\\\"Label List and Point List not the same length!\\\")\\n for i in range(len(self.labelList)):\\n self.centroids[self.labelList[i]] = self.pointList[i]\\n self.pointcounts[self.labelList[i]] = 1\",\n \"def update_count(self):\\n count_metrics = self._fetch_count_metrics_and_clear()\\n self._logger.info('update_count. count_metrics = %s',\\n build_metrics_counter_data(count_metrics))\",\n \"def execute(self, docs, clusters=None):\\n if clusters == None:\\n # Find k random docs to start as our centroids.\\n indices = range(len(docs))\\n random.shuffle(indices)\\n \\n # Initialize clusters.\\n i = 0\\n for index in indices[:self.k]:\\n cluster = self.clusters[i]\\n docs[index].cluster = cluster\\n cluster.docs.append(docs[index]) \\n cluster.centroid = self.centroid(self.clusters[i].docs)\\n i += 1\\n else:\\n self.clusters = clusters\\n \\n change = True\\n while change:\\n # Check if any of the centroids changed.\\n change = False\\n \\n for doc in docs:\\n # Remove this doc from it's original cluster.\\n if doc.cluster != None:\\n doc.cluster.docs.remove(doc)\\n doc.cluster = None\\n \\n max_cluster = None\\n max_cos = float(\\\"-inf\\\")\\n \\n # Find the closest cluster for this document.\\n for cluster in self.clusters:\\n cos = self.cosine(doc.tfidf, cluster.centroid)\\n if cos > max_cos: \\n max_cluster = cluster\\n max_cos = cos\\n \\n old_centroid = max_cluster.centroid\\n \\n # Re-assign this doc the new cluster and find the centroid.\\n doc.cluster = max_cluster\\n max_cluster.docs.append(doc) \\n max_cluster.centroid = self.centroid(max_cluster.docs)\\n \\n # Check if the centroid has changed.\\n for index in old_centroid:\\n if old_centroid[index] - max_cluster.centroid[index] > (1 ** -15):\\n change = True\",\n \"def cluster_dist(self):\\n clusters = self.all_clusters()\\n lengths = [len(cluster) for cluster in clusters]\\n d = Dist(lengths)\\n d.plot_ccdf(loglog)\\n show()\",\n \"def _compute_centroids(self):\\n\\n for i in range(0, self.k):\\n cluster = np.argwhere(self.assigned_clusters == i)\\n cluster_points = self.data[cluster].squeeze()\\n self.centroids[i] = np.mean(cluster_points, axis=0)\",\n \"def print_cluster(self, cluster, value):\\n total = 0\\n ham = 0\\n spam = 0\\n for message in cluster:\\n if self.spamorham[self.ids[message]] == 'ham':\\n ham += 1\\n elif self.spamorham[self.ids[message]] == 'spam':\\n spam += 1\\n else:\\n print(\\\"ERROR!\\\")\\n total += 1\\n\\n print(\\\"Total number of messages in the {0} cluster: {1}\\\\n\\\"\\n \\\"Percentage of SPAM messages in the {2} cluster: {3}\\\\n\\\"\\n \\\"Percentage of HAM messages in the {4} cluster: {5}\\\".format(value, total, value,\\n str((float(spam) / total) * 100), value,\\n str((float(ham) / total) * 100)))\",\n \"def cluster(self, documents, iters=10):\\n ###TODO\\n self.means = documents[0:self.k]\\n self.cluster = defaultdict(lambda : int)\\n self.docs = documents\\n \\n for val in range(iters):\\n self.norms = []\\n for x in self.means:\\n self.norms.append(self.sqnorm(x))\\n \\n self.compute_clusters(documents)\\n \\n self.fin_clust = defaultdict(lambda:[])\\n for z in self.cluster:\\n self.fin_clust[self.cluster[z]].append(z)\\n \\n self.means = self.compute_means()\\n \\n to_print_array = []\\n for k in self.fin_clust:\\n to_print_array.append(len(self.fin_clust[k]))\\n \\n print (to_print_array)\\n print (self.error(documents))\",\n \"def update_clusters(examples, cluster_averages):\\n # find the closest cluster and move the example to that one\\n for example in examples:\\n example.type = closest_cluster(cluster_averages, example)\",\n \"def progressUpdate(clusterid):\\n progress_update.updateProgress(clusterid)\",\n \"def cluster_num(self, cluster_num):\\n\\n self._cluster_num = cluster_num\",\n \"def _init_centroid(self, seed: int):\\n random.seed(seed)\\n self.centroid_info = dict()\\n self.cluster_result = dict()\\n self.centroid_stable_flag = dict()\\n for key_index, chosen_value in enumerate(\\n random.sample(self.list_data, self.n_cluster)):\\n self.centroid_info.setdefault(\\\"c\\\" + str(key_index), float(chosen_value))\\n self.cluster_result.setdefault(\\\"c\\\" + str(key_index), list())\\n self.centroid_stable_flag.setdefault(\\\"c\\\" + str(key_index), False)\",\n \"def K_Means(self, n_clusters: int=150):\\n start_time = datetime.datetime.now()\\n self.func_log(\\\"\\\\n\\\\tIn K-Measn()\\\")\\n \\n kmeans = KMeans(n_clusters = n_clusters)\\n kmeans.fit(self.descriptor_list)\\n self.visual_words = kmeans.cluster_centers_ \\n \\n end_time = datetime.datetime.now() \\n self.func_log(\\\"\\\\n\\\\t\\\\tTime Cost: {}\\\\n\\\".format(end_time-start_time))\",\n \"def clustering_and_visulization(self):\\n centroids, _ = kmeans(self.data_mat, self.k)\\n idx, _ = vq(self.data_mat, centroids)\\n for i in range(self.k):\\n\\n self.plot_list.append(self.data_mat[idx == i, 0])\\n self.plot_list1.append(self.data_mat[idx == i, 1])\\n\\n for j in range(self.k):\\n plot(self.plot_list[j], self.plot_list1[j], self.color_code[j])\\n plot(centroids[:, 0], centroids[:, 1], 'sg', markersize=8)\\n show()\\n for i in range(self.k):\\n self.cluster = self.data_mat[idx == i]\\n self.clusterlist.append(self.cluster)\\n\\n for i in range(len(self.clusterlist)):\\n self.clusterdict[i] = self.clusterlist[i]\\n print(self.clusterdict)\\n\\n\\n self.indexdict = {}\\n for i in self.clusterdict:\\n self.indexdict[i] = []\\n print(len(self.clusterdict))\\n for i in range(len(idx)):\\n for j in range(len(self.clusterdict)):\\n if (self.clusterdict[j][:] == self.data_mat[i]).any():\\n self.indexdict[j].append(i)\\n print(\\\"cluster dict of packs\\\",self.indexdict)\\n\\n self.drugdict = {}\\n for i in self.clusterdict:\\n self.drugdict[i] = []\\n self.drug=[]\\n for i in range(len(self.indexdict.keys())):\\n for j in range(len(self.indexdict[i])):\\n self.drugdict[i].append(self.df.iloc[self.indexdict[i][j]].to_dict())\\n print(\\\"drugs dict with their frequencies\\\",self.drugdict)\\n clusterdict_from_df_as_drug_non_O_frequency = {}\\n clusterdict_from_as_drugs_only_as_list = {}\\n clusterdict_of_non_repeated_drugs ={}\\n for i in self.drugdict:\\n clusterdict_from_df_as_drug_non_O_frequency[i] = []\\n for i in self.drugdict:\\n for j in self.drugdict[i]:\\n clusterdict_from_df_as_drug_non_O_frequency[i].append({x: y for x, y in j.items() if y != 0})\\n print(\\\"clusterdict_from_df_as_drug_non_O_frequency\\\", clusterdict_from_df_as_drug_non_O_frequency)\\n print('\\\\n')\\n\\n for i in self.drugdict:\\n clusterdict_from_as_drugs_only_as_list[i] = []\\n\\n for i in self.drugdict:\\n for j in clusterdict_from_df_as_drug_non_O_frequency[i]:\\n clusterdict_from_as_drugs_only_as_list[i].append(j.keys())\\n\\n print(\\\"only keys drugs with drugs name\\\", clusterdict_from_as_drugs_only_as_list)\\n print('\\\\n')\\n\\n\\n for i in self.drugdict:\\n clusterdict_of_non_repeated_drugs[i]=list(more_itertools.collapse([list(x) for x in set([tuple(x) for x in clusterdict_from_as_drugs_only_as_list[i]])]))\\n\\n\\n print(\\\"only drugs only\\\", clusterdict_of_non_repeated_drugs)\\n\\n########################################################################################################################\\n try:\\n common_drug_list = [x for x in clusterdict_of_non_repeated_drugs[0] if x in clusterdict_of_non_repeated_drugs[1]]\\n print('\\\\n')\\n print(\\\"common drug list\\\", common_drug_list)\\n total_frequency_of_drugs_dict = {}\\n for i in self.drugdict:\\n total_frequency_of_drugs_dict[i] = []\\n\\n for drug in common_drug_list:\\n\\n for cluster_keys in clusterdict_from_df_as_drug_non_O_frequency.keys():\\n temp_list = []\\n for cluster_values_as_list in clusterdict_from_df_as_drug_non_O_frequency[cluster_keys]:\\n try:\\n temp_list.append(cluster_values_as_list[str(drug)])\\n except KeyError:\\n print(\\\"\\\\t\\\")\\n total_frequency_of_drugs_dict[cluster_keys].append(np.sum(temp_list))\\n print(\\\"total drugs frequency\\\",total_frequency_of_drugs_dict)\\n total_frequency_of_drugs_dict_with_drugs = {}\\n for i in self.drugdict:\\n total_frequency_of_drugs_dict_with_drugs[i] = []\\n temp_list1 = []\\n temp_list2 = []\\n for keys in self.drugdict.keys():\\n temp_list1.append(clusterdict_of_non_repeated_drugs[keys])\\n for keys in self.drugdict.keys():\\n temp_list2.append(total_frequency_of_drugs_dict[keys])\\n temp_list3 = []\\n for i in temp_list1:\\n for j in temp_list2:\\n temp_list3.append(dict(zip(i,j)))\\n temp_list4 = temp_list3[:2]\\n print('\\\\n')\\n for keys in self.drugdict:\\n total_frequency_of_drugs_dict_with_drugs[keys].append(temp_list4[keys])\\n print(\\\"total frequency with drugs dict\\\",total_frequency_of_drugs_dict_with_drugs)\\n\\n final_drugs_in_clusters_dict = {}\\n for i in self.drugdict:\\n final_drugs_in_clusters_dict[i] = []\\n compare_list = []\\n for drug in common_drug_list:\\n compare_list.append(min(total_frequency_of_drugs_dict_with_drugs[0][0][drug], total_frequency_of_drugs_dict_with_drugs[1][0][drug]))\\n print(\\\"compare list\\\",compare_list)\\n for values in total_frequency_of_drugs_dict_with_drugs.values():\\n for key1, value1 in values[0].items():\\n if value1 in compare_list:\\n\\n key2 =values[0].keys()[values[0].values().index(value1)]\\n values[0].pop(key2, None)\\n\\n\\n print('final dict with deleted keys', total_frequency_of_drugs_dict_with_drugs)\\n\\n clusterdict_from_as_drugs_only_as_list = {}\\n clusterdict_of_non_repeated_drugs = {}\\n\\n for i in self.drugdict:\\n clusterdict_from_as_drugs_only_as_list[i] = []\\n\\n for i in self.drugdict:\\n for j in total_frequency_of_drugs_dict_with_drugs[i]:\\n clusterdict_from_as_drugs_only_as_list[i].append(j.keys())\\n print(\\\"only keys drugs with drugs name\\\", clusterdict_from_as_drugs_only_as_list)\\n print('\\\\n')\\n\\n for i in self.drugdict:\\n clusterdict_of_non_repeated_drugs[i] = list(more_itertools.collapse([list(x) for x in set([tuple(x) for x in clusterdict_from_as_drugs_only_as_list[i]])]))\\n print(\\\"only drugs\\\",clusterdict_of_non_repeated_drugs)\\n\\n final_robot_packs_dict = {}\\n for i in self.drugdict:\\n final_robot_packs_dict[i] = []\\n\\n winner_drug_dict = {}\\n for i in common_drug_list:\\n winner_drug_dict[i] = []\\n for drug in common_drug_list:\\n if drug in clusterdict_of_non_repeated_drugs[0]:\\n winner_drug_dict[str(drug)].append(0)\\n if drug in clusterdict_of_non_repeated_drugs[1]:\\n winner_drug_dict[str(drug)].append(1)\\n print(\\\"winner drug dict\\\",winner_drug_dict)\\n\\n for i in self.indexdict:\\n print(i)\\n for pack in self.indexdict[i]:\\n packdict = self.df.iloc[pack].to_dict()\\n packdict_non_0 = {x: y for x, y in packdict.items() if y != 0}\\n packdict_non_0_key = packdict_non_0.keys()\\n for drug in packdict_non_0_key:\\n if drug in clusterdict_of_non_repeated_drugs[0]:\\n final_robot_packs_dict[0].append(pack)\\n elif drug in clusterdict_of_non_repeated_drugs[1]:\\n final_robot_packs_dict[1].append(pack)\\n\\n final_robot_packs_dict[i].append(pack)\\n for commondrugs in winner_drug_dict:\\n for winnercluster in winner_drug_dict[commondrugs]:\\n if winnercluster==0:\\n loosercluster =1\\n if winnercluster == 1:\\n loosercluster = 0\\n if commondrugs in packdict_non_0_key and i==loosercluster:\\n try:\\n final_robot_packs_dict[i].remove(pack)\\n final_robot_packs_dict[winnercluster].append(pack)\\n except ValueError:\\n print('\\\\t')\\n\\n for i in self.indexdict:\\n final_robot_packs_dict[i] = set(final_robot_packs_dict[i])\\n\\n print(\\\"final which pack which robot dict\\\",final_robot_packs_dict)\\n\\n except IndexError:\\n print(\\\"No common drugs\\\")\",\n \"def cluster(self):\\n logger.debug(\\\"Beginning feature based clustering on %d clusters.\\\" % len(self.c2b))\\n # Merge the two nearest clusters until we can't.\\n #\\n while self.mergeNearestClusters():\\n pass\\n logger.debug(\\\"After clustering, there are now %d clusters remaining.\\\" % len(self.c2b))\\n return self.c2b.values()\",\n \"def cluster(self):\\r\\n\\t\\tself.clusterer.fit(self.koopman_feature_array)\\r\\n\\t\\tself.labels = self.clusterer.labels_\\r\\n\\t\\tfor j in range(max(self.labels)+1):\\r\\n\\t\\t\\tself.koop_cluster_list.append([self.koop_list[i] for i in range(len(self.labels)) if self.labels[i] == j])\\r\\n\\t\\t\\tself.koop_cluster_memb_prob_list.append([self.clusterer.probabilities_[i] for i in range(len(self.labels)) if self.labels[i] == j])\",\n \"def update_distribution(self):\\n for m in range(0, self.document_number, 1):\\n for k in range(0, self.topic_number, 1):\\n self.document_distribution_over_topic[m][k]+=((self.document_topic_count_matrix[m][k] + self.alpha[k])\\n / (self.sum_document_by_topic_count[m] + self.sum_alpha))\\n for k in range(0, self.topic_number, 1):\\n for v in range(0, self.term_number,1):\\n self.topic_distribution_over_term[k][v] += ((self.topic_term_count_matrix[k][v] + self.beta[v]) / \\\\\\n (self.sum_topic_by_term_count[k] + self.sum_beta))\\n # the number of times that the distributions are updated.\\n self.update_number += 1\",\n \"def cluster_bal_iter(self):\\n # moving\\n for j,cluster in enumerate(self.clusters):\\n cluster.move()\\n self.clusters_allocate_cells()\\n for j,cluster in enumerate(self.clusters):\\n cluster.calc()\\n #print j, '\\\\t', cluster.center, '\\\\t', cluster.np, '\\\\t', cluster.size\\n \\n # resizing\\n for j,cluster in enumerate(self.clusters):\\n cluster.resize()\\n self.clusters_allocate_cells()\\n for j,cluster in enumerate(self.clusters):\\n cluster.calc()\\n #print j, '\\\\t', cluster.center, '\\\\t', cluster.np, '\\\\t', cluster.size\\n \\n self.calc()\",\n \"def compute_clusters(self, documents):\\n ###TODO\\n for d in range(0, len(documents)):\\n maxi = 999999999\\n for cid in range(0, len(self.means)):\\n dist = self.distance(documents[d], self.means[cid], self.norms[cid])\\n if dist < maxi:\\n maxi = dist\\n clust = cid \\n self.cluster[d] = clust\",\n \"def clusterMonitor():\\n node = os.environ['DIM_DNS_NODE']\\n xml = XMLTaskList.TransformXmlToObjects()\\n xml.load('../xml/TaskInventory.xml') # loads the Task Inventory\\n xml.load('../xml/HLTD01.xml') # loads the Node List\\n xml.load('../xml/HLTD02.xml') # loads the Node List\\n xml.load('../xml/HLTD03.xml') # loads the Node List\\n xml.load('../xml/HLTD04.xml') # loads the Node List\\n xml.load('../xml/HLTD06.xml') # loads the Node List\\n xml.load('../xml/HLTD07.xml') # loads the Node List\\n xml.load('../xml/HLTD08.xml') # loads the Node List\\n xml.load('../xml/HLTD09.xml') # loads the Node List\\n xml.load('../xml/HLTD10.xml') # loads the Node List\\n xml.load('../xml/HLTD11.xml') # loads the Node List\\n xml.load('../xml/HLTE04.xml') # loads the Node List\\n xml.load('../xml/HLTE06.xml') # loads the Node List\\n xml.load('../xml/'+node.upper()+'.xml') # loads the Node List\\n collector = ClusterCollector(xml)\\n collector.startx()\\n collector.run()\",\n \"def test_refresh_cluster(self):\\n # Save original cluster wrapper for later comparison\\n orig_clust_wrap = pvm_clust.Cluster.wrap(self.clust_resp)\\n # Prime _clust_wrap\\n ssp_stor = self._get_ssp_stor()\\n # Verify baseline call counts\\n self.assertEqual(1, self.mock_search.call_count)\\n self.assertEqual(0, self.mock_clust_refresh.call_count)\\n clust_wrap = ssp_stor._refresh_cluster()\\n # This should call refresh\\n self.assertEqual(1, self.mock_search.call_count)\\n self.assertEqual(0, self.apt.read.call_count)\\n self.assertEqual(1, self.mock_clust_refresh.call_count)\\n self.assertEqual(clust_wrap.name, orig_clust_wrap.name)\",\n \"def set_nb_clusters(self):\\n \\n print(\\\"Finding the optimal number of clusters...\\\")\\n \\n sample = ro.r.matrix(self.df[self.df[\\\"filename\\\"].between(1, 4)][\\\"active_power\\\"].to_numpy())\\n \\n r=ro.r(\\\"\\\"\\\"\\n check = function(matrix) {\\n n_clust = fviz_nbclust(matrix, kmeans, k.max = 15)\\n\\n n_clust = n_clust$data\\n\\n max_cluster = as.numeric(n_clust$clusters[which.max(n_clust$y)])\\n return(max_cluster)\\n }\\n \\\"\\\"\\\")\\n\\n result = r(sample)\\n self.conf[\\\"nb_clust\\\"] = int(result[0])\\n \\n print(f\\\"Optimal number of clusters is {self.conf['nb_clust']}\\\\n\\\")\",\n \"def update(self, predictions, real_vals):\\n for pred, actual in zip(predictions, real_vals):\\n self.cm.loc[actual, pred] += 1\",\n \"def multiClusterAlgorithm(values):\\n clusterMap = dict()\\n # Lowest unixtime in the values list\\n startUnixtime = values[0][0]\\n # Separate values into separate clusters in the map, clusterMap\\n for value in values:\\n if value[2] not in clusterMap.keys():\\n clusterMap[value[2]] = []\\n clusterMap[value[2]].append(value)\\n \\n # An array of the predicted values per cluster\\n clusterPredicted = []\\n # An array of unixtime averages per cluster\\n unixtimeAverage = []\\n \\n # Generate predicted value for each cluster using a weighted average\\n # Adds predicted value for each cluster to clusterPredicted and adds\\n # the unixtime average for each cluster to unixtimeAverage\\n for key in clusterMap.keys():\\n clusterLength = len(clusterMap[key]) \\n totalUnixtime = sum([elem[0] for elem in clusterMap[key]])\\n unixtimeAverage.append(float(totalUnixtime) / float(clusterLength))\\n \\n clusterLight = [elem[1] for elem in clusterMap[key]]\\n\\n totalDistanceFromStart = sum([elem[0] - startUnixtime for elem in clusterMap[key]])\\n clusterWeightValues = [float(elem[0] - startUnixtime) / float(totalDistanceFromStart) for elem in clusterMap[key]]\\n \\n predicted = np.average(clusterLight, weights = clusterWeightValues)\\n clusterPredicted.append(predicted)\\n \\n print clusterPredicted\\n total = sum([elem - startUnixtime for elem in unixtimeAverage])\\n # Create weighted values based on unixtime average per cluster\\n weightValues = [float(elem - startUnixtime) / float(total) for elem in unixtimeAverage]\\n print weightValues\\n # Return a weighted average across clusters\\n return np.average(clusterPredicted, weights = weightValues)\",\n \"def _cmeans0_kth_lfreq(data, u_old, c, m, *para):\\n\\t# parameters\\n\\tk = para[0]\\n\\tlocation_frequency = para[1]\\n\\n\\t# Normalizing, then eliminating any potential zero values.\\n\\tu_old /= np.ones((c, 1)).dot(np.atleast_2d(u_old.sum(axis=0)))\\n\\tu_old = np.fmax(u_old, np.finfo(np.float64).eps)\\n\\n\\tum = u_old ** m\\n\\n\\t# calculating u_c\\n\\t#u_c = u_old / u_old.sum(axis=1)[:,None]\\n\\n\\t# remain the belonging rate >= the k-th max location of each cluster in um_c\\n\\tfilter_k = lambda row:row < sorted(row, reverse=True)[k-1]\\n\\tfail_indices = np.apply_along_axis(filter_k, axis=1, arr=u_old)\\n\\tum[fail_indices] = 0\\n\\tum_f = um * (np.ones((um.shape[0], 1)).dot(np.atleast_2d(location_frequency)))\\n\\n\\t# cluster freqeuncy\\n\\ttrue_indices = np.invert(fail_indices)\\n\\tcluster_frequency = true_indices.dot(np.atleast_2d(location_frequency).T)\\n\\tcluster_frequency = cluster_frequency / np.amax(cluster_frequency)\\n\\n\\t# Calculate cluster centers\\n\\tdata = data.T\\n\\t# data1:2861,2; um:30,2861\\n\\tcntr = um_f.dot(data) / (np.ones((data.shape[1],1)).dot(np.atleast_2d(um_f.sum(axis=1))).T)\\n\\t#d = _distance(data, cntr) * 100 # euclidean distance\\n\\td = cdistance.get_center_distance(data, cntr)\\n\\n\\tjm = (um * d ** 2).sum()\\n\\n\\tu = (d ** (- 2. / (m - 1))) * cluster_frequency.dot(np.ones((1, d.shape[1])))\\n\\tu /= np.ones((c, 1)).dot(np.atleast_2d(u.sum(axis=0)))\\n\\t#print(\\\" - d:\\\", d[0:5, 0:3], \\\"\\\\n - u:\\\", u[0:5, 0:3])\\n\\treturn cntr, u, jm, d\",\n \"def media(self):\\n self.kmeans = [[] for i in range(0,self.cluster_number)]\\n for i in range(self.cluster_number):\\n for j in range(0,len(self.cluster[i][0])):\\n self.kmeans[i].append(np.sum(self.cluster[i][::,j:j+1:])/len(self.cluster[i][::,j:j+1:]))\",\n \"def update_cluster_config(self, clusterid, config, **kwargs):\\n pass\",\n \"def patch_cluster(self, cluster, *args, **kwargs):\\n raise NotImplementedError\",\n \"def update_cluster_hosts(self, hosts):\\n self._hosts = hosts\\n self._collect_hosts_d = True\",\n \"def cpu_freq(self):\\n self.monitoring_object['cpu_freq'] = \\\\\\n psutil.cpu_freq(percpu=True)\",\n \"def automerge_clusters(self):\\n all_clusters = self.get_clusters().copy()\\n\\n if not self._single: # if not in single mode mode\\n # initialize the variable to check if some change has happened \\n changed = False\\n for cl_1 in all_clusters: # cycle over clusters\\n c_c1 = all_clusters[cl_1]\\n for cl_2 in all_clusters: # inner cycle over clusters\\n c_c2 = all_clusters[cl_2]\\n # if two clusters have the same speaker and have different \\n # cluster identifiers\\n if cl_1 != cl_2 and c_c1.get_speaker() != 'unknown' and c_c1.get_speaker() == c_c2.get_speaker() and self._clusters.has_key(cl_1) and self._clusters.has_key(cl_2):\\n changed = True\\n # merge the clusters an record that something changed\\n self._merge_clusters(cl_1, cl_2)\\n if changed: # if something has changed\\n # rename all the clusters starting from S0\\n self._rename_clusters()\\n # remove also the old waves and seg files of the old clusters\\n shutil.rmtree(self.get_file_basename())\\n # rebuild all seg files\\n self.generate_seg_file(set_speakers=False)\\n # resplit the original wave file according to the new clusters\\n self._to_trim()\",\n \"def test_update_hyperflex_cluster(self):\\n pass\",\n \"def update_count(self):\\n pass\",\n \"def version_recluster(self, serial, cluster,\\n update_statistics_ancestors_depth=None):\\n\\n props = self.version_get_properties(serial)\\n if not props:\\n return\\n node = props[NODE]\\n size = props[SIZE]\\n oldcluster = props[CLUSTER]\\n if cluster == oldcluster:\\n return\\n\\n mtime = time()\\n self.statistics_update_ancestors(node, -1, -size, mtime, oldcluster,\\n update_statistics_ancestors_depth)\\n self.statistics_update_ancestors(node, 1, size, mtime, cluster,\\n update_statistics_ancestors_depth)\\n\\n q = \\\"update versions set cluster = ? where serial = ?\\\"\\n self.execute(q, (cluster, serial))\",\n \"def update_clusters(self, data):\\n\\n self.unassigned_data_updated = [None]\\n cluster_list = []\\n cluster_indices = []\\n bud_list = []\\n bud_indices = []\\n\\n # First of all, seperate buds and clusters\\n for cluster_index, cluster in self.clusters.items():\\n if cluster.number_of_members < self.minnpix_cluster:\\n bud_list.append(cluster)\\n bud_indices.append(cluster_index)\\n else:\\n cluster_list.append(cluster)\\n cluster_indices.append(cluster_index)\\n\\n # Take all of the bud data and put it back into an unassigned list\\n unassigned_data_updated = []\\n for i in range(len(bud_indices)):\\n self.clusters.pop(bud_indices[i])\\n idx = np.squeeze(np.where(self.cluster_arr[1,:] == bud_indices[i]))\\n self.cluster_arr[1,idx] = -1.0\\n unassigned_data_updated.extend(data[:,bud_list[i].cluster_members].T)\\n\\n # Turn that into an array and transpose\\n unassigned_data_updated = np.asarray(unassigned_data_updated)\\n unassigned_data_updated = unassigned_data_updated.T\\n\\n # There shouldn't be any in theory, but just check there are no duplicates\\n try:\\n unassigned_data_updated = np.unique(unassigned_data_updated, axis=1)\\n except ValueError:\\n pass\\n\\n # Sort the unassigned data according to peak intensity and send it back\\n if np.size(unassigned_data_updated) != 0.0:\\n sortidx = argsort(unassigned_data_updated[2,:], reversed=True)\\n self.unassigned_data_updated = unassigned_data_updated[:,sortidx]\\n else:\\n pass\\n\\n return cluster_list, cluster_indices\",\n \"def adjust_n_clusters(self, n_clusters):\\n\\t\\tself.estimator = KMeans(init='k-means++', n_clusters=n_clusters)\",\n \"def save_cluster_metrics_on_check_point(self) -> None:\\n pd.read_csv(f'{self.path_to_cluster_metrics}/{self.file_name}.csv')\\\\\\n .append(pd.DataFrame(self.cluster_metrics,\\n columns=['stream_index', 'timestamp', 'check point', 'cluster id',\\n 'x', 'y', 'radius', 'weight', 'cluster type']))\\\\\\n .to_csv(f'{self.path_to_cluster_metrics}/{self.file_name}.csv', index=False)\\n self.cluster_metrics = []\",\n \"def cluster(self, k=3, max_iter=10):\\n\\n # create a set of k random clusters as seeds\\n old_clusters = [None] * k # just a placeholder\\n clusters = self.random_clusters(k)\\n\\n iter = 0\\n while (iter < max_iter) and not (old_clusters == clusters):\\n print \\\"iteration %d...\\\" % iter\\n # assign new clusters to old clusters\\n for i in xrange(0, k):\\n old_clusters[i] = copy(clusters[i])\\n clusters[i].documents = []\\n\\n # for each document\\n for document in self.documents:\\n\\n # determine the cluster with the highest similarity\\n similarities = [cosine_similarity(document, cluster) for cluster in old_clusters]\\n max_index = array(similarities).argmax()\\n\\n # assign document to that cluster\\n clusters[max_index].add(document)\\n\\n # update cluster means\\n for cluster in clusters:\\n cluster.update_centroid()\\n \\n iter += 1\\n \\n return clusters\",\n \"def update_freq_dist(filename):\\r\\n pass\",\n \"def update(self, x):\\n self.time_since_update = 0\\n self.hits += 1\\n self.continuing_hits += 1\\n self.kf.update(x)\",\n \"def update(self, kf, detection):\\n self.mean, self.covariance = kf.update(\\n self.mean, self.covariance, detection.to_xyah())\\n self.features.append(detection.feature)\\n\\n self.hits += 1\\n self.time_since_update = 0\\n if self.state == TrackState.Tentative and self.hits >= self._n_init:\\n self.state = TrackState.Confirmed\",\n \"def cluster(self):\\n print(\\\"Calculating distances\\\")\\n self.all_distances()\\n\\n print(\\\"Start making sets\\\")\\n clusters = self.clusters\\n\\n # Generates a set with neighbours for each point\\n for row in self.distances:\\n clusters.append(set(np.where(row < self.distance_threshold)[0].tolist()))\\n\\n print(\\\"Merging sets\\\")\\n for cluster1 in range(self.point_count):\\n for cluster2 in range(self.point_count):\\n if clusters[cluster2] is not None and clusters[cluster1] is not None:\\n if not clusters[cluster1].isdisjoint(clusters[cluster2]) and cluster1 != cluster2:\\n clusters[cluster1].update(clusters[cluster2])\\n clusters[cluster2] = None\\n # Deletes empty clusters\\n clusters = [points for points in clusters if points is not None]\\n # Sorts clusters by their size\\n clusters.sort(key=len, reverse=True)\\n # Builds main set\\n for point_set in clusters[0:self.cluster_count_threshold]:\\n self.main_cluster.update(point_set)\\n\\n self.main_cluster = list(self.main_cluster)\\n self.clusters = clusters\",\n \"def assignLabels(self):\\n clusters = np.arange(0, len(self.V))[self.V < self.V1] #indexes self.V, volumes_sorted, and oldOrder\\n self.clusterV = self.volumes_sorted[clusters]\\n clusters = self.oldOrder[clusters] #indexes volumes\\n self.clusters = self.nonBI[clusters] #indexes self.vor and self.data\\n self.easyLabel = np.zeros(len(self.data))\\n self.easyLabel[self.clusters] = 1\\n print('Out of ' + str(len(self.data)) + ' particles, ' + str(len(self.clusters)) + ' (' + str(round(len(self.clusters)*100/len(self.data), 3)) +' %) are labelled as cluster particles.')\",\n \"def _init_cluster(self):\\n self._Init_Cluster()\",\n \"def ConfigureCluster(messages, args, cluster):\\n cluster.labels = labels_util.ParseCreateArgs(args,\\n messages.Cluster.LabelsValue)\",\n \"def clusters_every(self, clusters_every):\\n\\n self._clusters_every = clusters_every\",\n \"def _setup_cluster(self):\\n raise NotImplementedError('Must be implemented in subclasses.')\",\n \"def clusterAlgorithm(values):\\n clusterMap = dict()\\n for value in values:\\n if value[2] not in clusterMap.keys():\\n clusterMap[value[2]] = []\\n clusterMap[value[2]].append(value)\\n frequency = [float(len(clusterMap[value[2]])) for value in values]\\n total = sum(frequency)\\n weightValues = [freq / total for freq in frequency]\\n print sum(weightValues)\\n lightValues = [value[1] for value in values]\\n return np.average(lightValues, weights = weightValues)\",\n \"def fit(self):\\n self.cluseter_agglomerative(n_clusters=20, linkage='average', iterate=5)\\n self.sub_clustering(n_clusters=3, index_cluster=[79], linkage='complete')\\n self.merge_clusters([[0,9,53],[1,83],[46,35,67],[88,23],[6,68]])\\n self.merge_clusters([[6,33,52],[17,14]])\\n self.sub_clustering(n_clusters=2, index_cluster=[0], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[2], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[85], linkage='average')\\n self.sub_clustering(n_clusters=2, index_cluster=[14], linkage='complete')\\n self.sub_clustering(n_clusters=2, index_cluster=[16], linkage='average')\\n self.sub_clustering(n_clusters=3, index_cluster=[22], linkage='average')\\n self.sub_clustering(n_clusters=2, index_cluster=[24], linkage='complete')\\n self.sub_clustering(n_clusters=2, index_cluster=[26], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[28], linkage='ward')\\n self.merge_clusters([[6,98,99]])\\n self.merge_clusters([[35,80]])\\n self.sub_clustering(n_clusters=4, index_cluster=[35], linkage='complete')\\n self.merge_clusters([[76,98]])\\n self.sub_clustering(n_clusters=3, index_cluster=[35], linkage='complete')\\n self.merge_clusters([[39,42]])\\n self.sub_clustering(n_clusters=3, index_cluster=[47], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='average')\\n self.merge_clusters([[70,101]])\\n self.sub_clustering(n_clusters=3, index_cluster=[51], linkage='complete')\\n self.sub_clustering(n_clusters=3, index_cluster=[61], linkage='ward')\\n self.merge_clusters()\\n return\",\n \"def compute_clusters(self, p: float):\\n pass\",\n \"def recluster(cluster, min_size, guard, func):\\r\\n if cluster.get_length() == 0:\\r\\n return\\r\\n if cluster.get_length() <= min_size:\\r\\n return cluster\\r\\n sim = func(cluster.get_tweets())\\r\\n if sim < guard:\\r\\n kmeans = TweetKMeans(2)\\r\\n kmeans.set_data(cluster.get_tweets())\\r\\n return kmeans.start_algorithm()\\r\\n return cluster\",\n \"def cluster_center_update_dataset(spn, dataset):\\n\\n if isinstance(spn, Categorical):\\n\\n insert_into_categorical_leaf(spn, np.array([dataset]), np.array([1.0]))\\n\\n return spn\\n elif isinstance(spn, IdentityNumericLeaf):\\n\\n insert_into_identity_numeric_leaf(spn, np.array([dataset]), np.array([1.0]))\\n\\n return spn\\n elif isinstance(spn, Sum):\\n cc = spn.cluster_centers\\n\\n node_idx = 0\\n\\n min_dist = np.inf\\n min_idx = -1\\n for n in spn.children:\\n # distance calculation between the dataset and the different clusters\\n # (there exist a much faster version on scipy)\\n # this? https://scikit-learn.org/stable/modules/generated/sklearn.metrics.pairwise_distances.html\\n #\\n proj = projection(dataset, n.scope)\\n dist = distance.euclidean(cc[node_idx], proj)\\n if dist < min_dist:\\n min_dist = dist\\n min_idx = node_idx\\n\\n node_idx += 1\\n assert min_idx > -1\\n assert min_idx < len(spn.children)\\n adapt_weights(spn, min_idx)\\n cluster_center_update_dataset(spn.children[min_idx], dataset)\\n elif isinstance(spn, Product):\\n\\n for n in spn.children:\\n cluster_center_update_dataset(n, dataset)\\n else:\\n raise Exception(\\\"Invalid node type \\\" + str(type(spn)))\\n spn.cardinality += 1\",\n \"def newCluster(color_cluster):\\n r = 0\\n g = 0\\n b = 0\\n count = 0\\n for cc in color_cluster:\\n count += cc[0]\\n r += cc[1][0] * cc[0]\\n g += cc[1][1] * cc[0]\\n b += cc[1][2] * cc[0]\\n\\n # print(\\\"r: \\\" + str(r))\\n # print(\\\"g: \\\" + str(g))\\n # print(\\\"b: \\\" + str(b))\\n # print(\\\"count: \\\" + str(count))\\n r_mean = int(r / count)\\n g_mean = int(g / count)\\n b_mean = int(b / count)\\n cluster = (r_mean, g_mean, b_mean)\\n # print(cluster)\\n return cluster\",\n \"def analyzeClusterPerformance(self, cluster):\\n def calcOverlap(playlist, group):\\n urls = set(group[\\\"uri\\\"].values)\\n playlist = set(playlist)\\n return len(urls & playlist)\\n\\n groupedDF = self.audioDF.groupby(cluster)\\n playlists = list(self.playlists)\\n\\n clusters = [group for _, group in groupedDF]\\n numSongs = sum([len(p) for p in playlists])\\n\\n numOverlap, maxOverlap = 0, 1\\n while len(playlists) > 0 and len(clusters) > 0 and maxOverlap > 0:\\n maxOverlap, pIDX, gIDX = 0, None, None\\n for i, playlist in enumerate(playlists):\\n for j, c in enumerate(clusters):\\n overlap = calcOverlap(playlist, c)\\n if overlap > maxOverlap:\\n maxOverlap, pIDX, gIDX = overlap, i, j\\n \\n if maxOverlap > 0:\\n playlists.pop(pIDX)\\n clusters.pop(gIDX)\\n numOverlap += maxOverlap\\n\\n performance = float(numOverlap) / float(numSongs)\\n performancePercentage = round(performance, 4) * 100\\n\\n return {\\n \\\"Clustering Algorithm\\\": cluster,\\n \\\"Performance\\\": performance\\n }\",\n \"def update_cluster_results(session: Session, project: MasteringProject) -> Operation:\\n op = _update_cluster_results_async(session, project)\\n return operation.wait(session, op)\",\n \"def update(self, kf, detection, detection_noise):\\n self.mean, self.covariance = kf.update(\\n self.mean, self.covariance, detection, detection_noise)\\n\\n self.hits += 1\\n self.time_since_update = 0\\n if self.state == TrackState.Tentative and self.hits >= self._n_init:\\n self.state = TrackState.Confirmed\",\n \"def setFreq(self,newfreq):\\n\\t\\tself.freq = newfreq;\",\n \"def updateCounter(self):\\n self.counter = self.counter + 1\\n self.syncDataStructure[\\\"+\\\"][str(self.instanceID)] = self.counter\",\n \"def update_counts(self, new_alpha, new_beta, decay):\\n\\n self._alpha = self._alpha / decay + new_alpha\\n self._beta = self._beta / decay + new_beta\\n self._n_updates += 1\",\n \"def update_avg_f1(ccs, gold_clusters, pred_clusters):\\n gold_clusters, mention_to_gold = ccs.get_gold_clusters(gold_clusters)\\n pred_clusters, mention_to_pred = ccs.get_gold_clusters(pred_clusters)\\n\\n # update scores\\n scorers = ccs.scorers\\n\\n for scorer in scorers:\\n scorer.update(pred_clusters, gold_clusters,\\n mention_to_pred, mention_to_gold)\",\n \"def reload(self):\\n cluster_kubeconfig = self.ocp.cluster_kubeconfig\\n self.data = self.get()\\n self.__init__(**self.data)\\n self.ocp.cluster_kubeconfig = cluster_kubeconfig\",\n \"def train(self):\\n freq_dist = self.getFreqDist()\\n\\n self.freq_dist = freq_dist\",\n \"def update(self):\\n old_centroid = self.centroid\\n self.centroid = self.calc_centroid()\\n return old_centroid.distance(self.centroid)\",\n \"def update(self, labels, preds):\\n labels, preds = check_label_shapes(labels, preds, True)\\n\\n for label, pred in zip(labels, preds):\\n self.metrics.update_binary_stats(label, pred)\\n\\n if self.average == \\\"macro\\\":\\n self.sum_metric += self.metrics.fscore\\n self.num_inst += 1\\n self.metrics.reset_stats()\\n else:\\n self.sum_metric = self.metrics.fscore * self.metrics.total_examples\\n self.num_inst = self.metrics.total_examples\",\n \"def cluster_density(self, cluster_density):\\n\\n self._cluster_density = cluster_density\",\n \"def plot_events_cluster(self, cluster, distrib=True, dataname='', timeres=None):\\n\\n def plot_notimeres():\\n \\\"\\\"\\\"\\n All time colapsed\\n @return:\\n \\\"\\\"\\\"\\n cont = np.zeros(cluster.num_clusters())\\n for i in range(self.dataset.shape[0]):\\n posy = self.dataset[i][0]\\n posx = self.dataset[i][1]\\n ejem = np.array([[posy, posx]]).reshape(1,-1)\\n ncl = cluster.predict(ejem)\\n ncl = ncl[0]\\n\\n if distrib:\\n cont[ncl] += 1\\n else:\\n cont[ncl] = 1\\n\\n if distrib:\\n cont = cont / np.max(cont)\\n for i in range(cont.shape[0]):\\n if cont[i] > 0.01:\\n cx = cluster.cluster_centers_[i][0]\\n cy = cluster.cluster_centers_[i][1]\\n mymap.circle_marker(location=[cx, cy],\\n radius=cont[i] * circlesize,\\n line_color='#000000',\\n fill_color='#110000',\\n popup=str(cont[i]), fill_opacity=0.4)\\n else:\\n for i in range(cont.shape[0]):\\n if cont[i] > 0.01:\\n cx = cluster.cluster_centers_[i][0]\\n cy = cluster.cluster_centers_[i][1]\\n\\n mymap.circle_marker(location=[cx, cy],\\n radius=30,\\n line_color='#000000',\\n fill_color='#110000',\\n popup=str(cont[i]), fill_opacity=0.4)\\n\\n def plot_timeres(timeres):\\n \\\"\\\"\\\"\\n Geo points separated by the time resolution zones\\n @return:\\n \\\"\\\"\\\"\\n tint = 24 / len(timeres.intervals)\\n step = 255 / (tint + 1)\\n\\n cont = np.zeros(cluster.num_clusters())\\n for i in range(self.dataset.shape[0]):\\n posy = self.dataset[i][0]\\n posx = self.dataset[i][1]\\n ejem = np.array([[posy, posx]]).reshape(1,-1)\\n ncl = cluster.predict(ejem)\\n ncl = ncl[0]\\n\\n if distrib:\\n cont[ncl] += 1\\n else:\\n cont[ncl] = 1\\n\\n # if distrib:\\n # cont = cont / np.max(cont)\\n # for i in range(cont.shape[0]):\\n # if cont[i] > 0.01:\\n # cx = cluster.cluster_centers_[i][0]\\n # cy = cluster.cluster_centers_[i][1]\\n # mymap.circle_marker(location=[cx, cy],\\n # radius=cont[i] * circlesize,\\n # line_color='#FF0000',\\n # fill_color='#110000')\\n # else:\\n # for i in range(cont.shape[0]):\\n # if cont[i] > 0.01:\\n # cx = cluster.cluster_centers_[i][0]\\n # cy = cluster.cluster_centers_[i][1]\\n # mymap.circle_marker(location=[cx, cy],\\n # radius=30,\\n # line_color='#FF0000',\\n # fill_color='#110000')\\n for t in range(tint):\\n color = '#' + (str(hex((t + 1) * step))[2:]) + \\\\\\n (str(hex((t + 1) * step))[2:]) + 'FF' # (str(hex((t+1)*step))[2:])\\n cont = np.zeros(cluster.num_clusters())\\n for i in range(self.dataset.shape[0]):\\n posy = self.dataset[i][0]\\n posx = self.dataset[i][1]\\n ejem = np.array([[posy, posx]]).reshape(1,-1)\\n ncl = cluster.predict(ejem)\\n ncl = ncl[0]\\n\\n _, evtime = timeres.discretize(self.dataset[i][2])\\n\\n if evtime == t:\\n if distrib:\\n cont[ncl] += 1\\n else:\\n cont[ncl] = 1\\n if distrib:\\n cont = cont / np.max(cont)\\n for i in range(cont.shape[0]):\\n if cont[i] > 0.01:\\n cx = cluster.cluster_centers_[i][0]\\n cy = cluster.cluster_centers_[i][1]\\n mymap.circle_marker(location=[cx, cy],\\n radius=cont[i] * circlesize,\\n line_color=pltcolors[t],\\n fill_color=pltcolors[t], #'#110000',\\n popup=str(t) + '-' + str(cont[i]), fill_opacity=0.2)\\n else:\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i] > 0.01:\\n cx = cluster.cluster_centers_[i][0]\\n cy = cluster.cluster_centers_[i][1]\\n mymap.circle_marker(location=[cx, cy],\\n radius=30,\\n line_color=pltcolors[t],\\n fill_color=pltcolors[t], #'#110000',\\n popup=str(t) + '-' + str(cont[i]), fill_opacity=0.2)\\n\\n print 'Generating the events plot ...'\\n circlesize = 60000 * cluster.radius\\n\\n # if timeres == 0:\\n # fig = plt.figure()\\n # ax = fig.add_subplot(111)\\n\\n minLat, maxLat, minLon, maxLon = self.city[1]\\n # normLat = scale / (maxLat - minLat)\\n # normLon = scale / (maxLon - minLon)\\n mymap = folium.Map(location=[(minLat + maxLat) / 2.0, (minLon + maxLon) / 2.0], zoom_start=12, width=1200,\\n height=1000)\\n\\n if timeres is None:\\n plot_notimeres()\\n else:\\n plot_timeres(timeres)\\n\\n #today = time.strftime('%Y%m%d%H%M%S', time.localtime())\\n nfile = self.application + '-' + dataname + '-Clust'\\n if self.mnhh is not None and self.mnhh is not None:\\n nfile += '-nusr' + str(self.mxhh) + '#' + str(self.mnhh)\\n\\n if timeres is not None:\\n nfile += '-tr' + str(timeres.intervals)\\n nfile += '-s' + str(cluster.radius)\\n\\n # if timeres == 0:\\n # fig.savefig(homepath + 'Results/' + self.city[2] + '-' +\\n # nfile + '.pdf', orientation='landscape', format='pdf')\\n # plt.close()\\n mymap.create_map(path=homepath + 'Results/clusters/' + self.city[2] + nfile + '.html')\",\n \"def add_new_cluster(self):\\n self.result.append(Cluster.Cluster())\\n return len(self.result) - 1\",\n \"def cluster(self):\\n\\t\\tself.index[\\\"cluster\\\"] = {}\\n\\n\\t\\tfor item in self.index[\\\"items\\\"]:\\n\\t\\t\\tself.index[\\\"cluster\\\"][item] = [{\\\"weight\\\" : float(len(set(self.index[\\\"items\\\"][item]).intersection( set(self.index[\\\"items\\\"][id]))))/float(len(self.index[\\\"items\\\"][item])) , \\\"name\\\" : id, \\\"authority\\\" : set(self.index[\\\"items\\\"][item]).intersection( set(self.index[\\\"items\\\"][id])) } for id in self.index[\\\"items\\\"] if id != item and len(set(self.index[\\\"items\\\"][item]).intersection( set(self.index[\\\"items\\\"][id]))) >= 1]\\n\\n\\t\\treturn self.index\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70926946","0.6771409","0.6328401","0.63172925","0.6311955","0.6175837","0.60610443","0.6025551","0.6025551","0.6025551","0.6025551","0.6025551","0.6025551","0.59272796","0.5923734","0.5918287","0.58931756","0.5863579","0.5851121","0.5786061","0.57628703","0.5761598","0.57605314","0.5724762","0.5716833","0.57115173","0.56964725","0.5694519","0.5694519","0.5694519","0.5683727","0.5675847","0.56726253","0.5648498","0.56281745","0.5625051","0.5612647","0.56095064","0.55932665","0.55631804","0.5559124","0.5552232","0.5548644","0.55441946","0.5537014","0.5536331","0.5530899","0.55198044","0.55178666","0.54998785","0.5491512","0.5489696","0.54896104","0.54845375","0.5474589","0.54632163","0.5453613","0.54475427","0.5446053","0.5440399","0.5431397","0.54276556","0.5403722","0.5399569","0.5388004","0.5385762","0.5381841","0.53784376","0.5370629","0.53695136","0.5369432","0.53508383","0.5348788","0.53467894","0.5346536","0.5342776","0.53426415","0.5341654","0.5339369","0.53350294","0.5333425","0.5324247","0.53226346","0.5320962","0.5312371","0.5310238","0.530931","0.5307389","0.53047496","0.5304485","0.53017306","0.5300143","0.5290564","0.52818835","0.5280303","0.5267798","0.5261823","0.5261646","0.5252875","0.5249022"],"string":"[\n \"0.70926946\",\n \"0.6771409\",\n \"0.6328401\",\n \"0.63172925\",\n \"0.6311955\",\n \"0.6175837\",\n \"0.60610443\",\n \"0.6025551\",\n \"0.6025551\",\n \"0.6025551\",\n \"0.6025551\",\n \"0.6025551\",\n \"0.6025551\",\n \"0.59272796\",\n \"0.5923734\",\n \"0.5918287\",\n \"0.58931756\",\n \"0.5863579\",\n \"0.5851121\",\n \"0.5786061\",\n \"0.57628703\",\n \"0.5761598\",\n \"0.57605314\",\n \"0.5724762\",\n \"0.5716833\",\n \"0.57115173\",\n \"0.56964725\",\n \"0.5694519\",\n \"0.5694519\",\n \"0.5694519\",\n \"0.5683727\",\n \"0.5675847\",\n \"0.56726253\",\n \"0.5648498\",\n \"0.56281745\",\n \"0.5625051\",\n \"0.5612647\",\n \"0.56095064\",\n \"0.55932665\",\n \"0.55631804\",\n \"0.5559124\",\n \"0.5552232\",\n \"0.5548644\",\n \"0.55441946\",\n \"0.5537014\",\n \"0.5536331\",\n \"0.5530899\",\n \"0.55198044\",\n \"0.55178666\",\n \"0.54998785\",\n \"0.5491512\",\n \"0.5489696\",\n \"0.54896104\",\n \"0.54845375\",\n \"0.5474589\",\n \"0.54632163\",\n \"0.5453613\",\n \"0.54475427\",\n \"0.5446053\",\n \"0.5440399\",\n \"0.5431397\",\n \"0.54276556\",\n \"0.5403722\",\n \"0.5399569\",\n \"0.5388004\",\n \"0.5385762\",\n \"0.5381841\",\n \"0.53784376\",\n \"0.5370629\",\n \"0.53695136\",\n \"0.5369432\",\n \"0.53508383\",\n \"0.5348788\",\n \"0.53467894\",\n \"0.5346536\",\n \"0.5342776\",\n \"0.53426415\",\n \"0.5341654\",\n \"0.5339369\",\n \"0.53350294\",\n \"0.5333425\",\n \"0.5324247\",\n \"0.53226346\",\n \"0.5320962\",\n \"0.5312371\",\n \"0.5310238\",\n \"0.530931\",\n \"0.5307389\",\n \"0.53047496\",\n \"0.5304485\",\n \"0.53017306\",\n \"0.5300143\",\n \"0.5290564\",\n \"0.52818835\",\n \"0.5280303\",\n \"0.5267798\",\n \"0.5261823\",\n \"0.5261646\",\n \"0.5252875\",\n \"0.5249022\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7776443"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84791,"cells":{"query":{"kind":"string","value":"Update state of each cores in every cluster. This is done for each timestamp."},"document":{"kind":"string","value":"def update_state(self, state, cpu_id): # pylint: disable=R0912\n POWERDOWN = 2\n offline_value = -1\n # if state is in unknowstate, then change state of current cpu_id\n # with cluster freq of current cluster.\n # if state is in powerstate then change state with that power state.\n if self.get_state_name(state) in [\"unknownstate\", \"powerstate\"]:\n for i in range(len(self.cpuids_of_clusters[self.current_cluster])):\n if cpu_id == self.cpuids_of_clusters[self.current_cluster][i]:\n if self.get_state_name(state) == \"unknownstate\":\n self.currentstates_of_clusters[self.current_cluster][i] = self.current_frequency_of_clusters[self.current_cluster]\n elif self.get_state_name(state) == \"powerstate\":\n self.currentstates_of_clusters[self.current_cluster][i] = state\n # If state is in freqstate then update the state with current state.\n # For IKS, if all cores is in power down and current state is freqstate\n # then update the all the cores in current cluster to current state\n # and other state cluster changed to Power down.\n if self.get_state_name(state) == \"freqstate\":\n for i, j in enumerate(self.currentstates_of_clusters[self.current_cluster]):\n if j != offline_value:\n self.currentstates_of_clusters[self.current_cluster][i] = state\n if cpu_id == self.cpuids_of_clusters[self.current_cluster][i]:\n self.currentstates_of_clusters[self.current_cluster][i] = state\n if self.device.scheduler == 'iks':\n check = False # All core in cluster is power down\n for i in range(len(self.currentstates_of_clusters[self.current_cluster])):\n if self.currentstates_of_clusters[self.current_cluster][i] != POWERDOWN:\n check = True\n break\n if not check:\n for i in range(len(self.currentstates_of_clusters[self.current_cluster])):\n self.currentstates_of_clusters[self.current_cluster][i] = self.current_frequency_of_clusters[self.current_cluster]\n for cluster, state_list in enumerate(self.currentstates_of_clusters):\n if cluster != self.current_cluster:\n for j in range(len(state_list)):\n self.currentstates_of_clusters[i][j] = POWERDOWN"},"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_cores(self):\n num_cores = 0\n for job in self.job_list:\n num_cores += int(job.get_core_info())\n self.cores_used = num_cores\n return","def cluster_state(self):\n for ip in set([status.ip for status in self.cluster_status]):\n yield self.node_state(ip)","def update_attr_par(self):\n\n # Retrieve all current values\n self.all_values_temp = nx.get_node_attributes(self.G, 'value')\n\n # Calculate all new values\n new_values_list = Parallel(n_jobs=2)(delayed(self.single_node_update)(i) \\\n for i in range(self.n_v))\n\n # # Set list to dict as needed for node update\n # new_values_dict = {}\n # for i, value in enumerate(new_values_list):\n # new_values_dict[i] = {'value': value}\n #\n # # Update node value\n # nx.set_node_attributes(self.G, new_values_dict)","def update_cluster_freq(self, state, cpu_id):\n # For IKS devices cluster changes only possible when\n # freq changes, for other it is determine by cpu_id.\n if self.device.scheduler != 'iks':\n self.current_cluster = self.get_cluster(cpu_id, state)\n if self.get_state_name(state) == \"freqstate\":\n self.current_cluster = self.get_cluster(cpu_id, state)\n self.current_frequency_of_clusters[self.current_cluster] = state","def cores_per_node(self, cores_per_node):\n\n self._cores_per_node = cores_per_node","def updateClusterInfo(self):\n self.nPoints = len(self.labels)\n self.n = len(np.unique(self.labels))\n self.centers = [ [0.0 for j in range(3)] for i in range(self.n)]","def run(self):\n for i,p in enumerate(self.pairs):\n self.forPointPair(i)\n if i % 100000 == 0:\n print('Percentage Processed: ' + str(round(i * 100 / len(self.pairs), 3)) + '. Existing Cluster Labels: ', len(np.unique(self.labels)))","def flush_parse_initialize(self):\n self.current_cluster = 0\n self.current_frequency_of_clusters = []\n self.timestamp = []\n self.currentstates_of_clusters = []\n self.state_time_map = {}\n self.cpuid_time_map = {}\n self.cpu_freq_time_spent = {}\n self.cpuids_of_clusters = []\n self.parse() # Parse trace.txt generated from trace-cmd instrumentation\n # Initialize the states of each core of clusters and frequency of\n # each clusters with its minimum freq\n # cpu_id is assigned for each of clusters.\n # For IKS devices cpuid remains same in other clusters\n # and for other it will increment by 1\n count = 0\n for cluster, cores_number in enumerate(self.numberofcores_in_cluster):\n self.currentstates_of_clusters.append([-1 for dummy in range(cores_number)])\n self.current_frequency_of_clusters.append(self.minimum_frequency_cluster[cluster])\n if self.device.scheduler == 'iks':\n self.cpuids_of_clusters.append([j for j in range(cores_number)])\n else:\n self.cpuids_of_clusters.append(range(count, count + cores_number))\n count += cores_number\n\n # Initialize the time spent in each state/frequency for each core.\n for i in range(self.device.number_of_cores * self.multiply_factor):\n self.cpu_freq_time_spent[\"cpu{}\".format(i)] = {}\n for j in self.unique_freq():\n self.cpu_freq_time_spent[\"cpu{}\".format(i)][j] = 0\n # To determine offline -1 state is added\n offline_value = -1\n self.cpu_freq_time_spent[\"cpu{}\".format(i)][offline_value] = 0\n if 0 not in self.unique_freq():\n self.cpu_freq_time_spent[\"cpu{}\".format(i)][0] = 0","def update_core_allocations(host, cpu_counts):\n # Remove any previous assignments\n for s in range(0, len(host.nodes)):\n for f in CORE_FUNCTIONS:\n host.cpu_functions[s][f] = []\n # Set new assignments\n for s in range(0, len(host.nodes)):\n cpu_list = host.cpu_lists[s] if s in host.cpu_lists else []\n # Reserve for the platform first\n for i in range(0, cpu_counts[s][constants.PLATFORM_FUNCTION]):\n host.cpu_functions[s][constants.PLATFORM_FUNCTION].append(\n cpu_list.pop(0))\n # Reserve for the vswitch next\n for i in range(0, cpu_counts[s][constants.VSWITCH_FUNCTION]):\n host.cpu_functions[s][constants.VSWITCH_FUNCTION].append(\n cpu_list.pop(0))\n # Reserve for the shared next\n for i in range(0, cpu_counts[s][constants.SHARED_FUNCTION]):\n host.cpu_functions[s][constants.SHARED_FUNCTION].append(\n cpu_list.pop(0))\n for i in range(0, cpu_counts[s][constants.ISOLATED_FUNCTION]):\n host.cpu_functions[s][constants.ISOLATED_FUNCTION].append(\n cpu_list.pop(0))\n # Assign the remaining cpus to the default function for this host\n host.cpu_functions[s][get_default_function(host)] += cpu_list\n return","def update_all_nodes(batchserver_name):\n server,created = getBatchServer(batchserver_name)\n if not pbs_data_nodes.has_key(batchserver_name):\n pbs_data_nodes[batchserver_name] = {'last_update':None, 'nodes':{}}\n\n if pbs_data_nodes[batchserver_name]['last_update'] and (datetime.datetime.now()-pbs_data_nodes[batchserver_name]['last_update']).total_seconds()<GlobalConfiguration.objects.get(pk=1).max_lastupdate:\n logging.debug(\"Nodes info is new enough for server: %s\" % batchserver_name)\n print \"not updated\"\n return pbs_data_nodes\n\n print \"updated\"\n\n conn = pbs.pbs_connect(batchserver_name.encode('iso-8859-1', 'replace'))\n if conn==-1:\n logging.error(\"Cannot connect to %s - live data will be missing\" % server.name)\n return\n statnodes = pbs.pbs_statnode(conn, \"\" , [], \"\")\n pbs.pbs_disconnect(conn)\n\n for sn in statnodes:\n node,created = getNode(sn.name, server)\n attr_dict = dict([ (x.name,x.value) for x in sn.attribs])\n pbs_data_nodes[batchserver_name]['nodes'][node] = update_one_node_from_pbs_data(node, attr_dict)\n pbs_data_nodes[batchserver_name]['last_update'] = datetime.datetime.now()\n\n return pbs_data_nodes","def update_cluster_results(session: Session, project: MasteringProject) -> Operation:\n op = _update_cluster_results_async(session, project)\n return operation.wait(session, op)","def update_all_readings(self):\n\n # update the reading of all nodes\n for node_name in self.nodes:\n\n # update the readings of all nodes\n self.nodes[node_name].reading()\n\n # once all nodes have updated, they can be stabilized\n for node_name in self.nodes:\n\n self.nodes[node_name].stabilize()","def updateNodeStates (self,listAtoms):\r\n \r\n for i in range(len(listAtoms)):\r\n for j in range(len(listAtoms[i].nodeArray)):\r\n self.mol[i].nodeArray[j].state = listAtoms[i].nodeArray[j].state","def compute(self):\n # some possible parameters:\n # minimum size: min node count for a cluster\n # (should be small, or some fraction of total graph size)\n # num splits: desired number of resultant partitions. Partitioning will continue until there are no more \"parallelizing splits\", or the total partition count is >= num splits\n minSplits = 3\n clustermetalist = []\n (roots, inters) = self.rootSplit(self.cluster)\n clustermetalist.append(roots)\n if (len(roots) + len(inters)) < minSplits:\n # split intersects.\n inters = map(self.rootSplit, inters)\n clustermetalist.append(inters[0])\n clustermetalist.append(inters[1])\n else:\n clustermetalist.append(inters)\n \n print \"nodes\", len(self.cluster)\n print \"roots\", len(roots)\n self.ready = clustermetalist\n # The metalist is a list of lists of clusters.\n # list[0] is a list of clusters that are ready for execution.\n # list[1] is a list of clusters that are ready after all clusters\n # in list[0] are complete. Some or all clusters may be ready\n # earlier, but each cluster requires some finite progress in one\n # or more clusters in list[0], otherwise the cluster could be\n # placed in list[0].\n # list[i+1] is related to list[i] similarly as list[1] is related\n # to list[0]\n open(\"pass1.dot\",\"w\").write(self.makeStateGraph(\"pass1\",roots))\n pass","def calc(self):\n self.proc_blocks = [cluster.cells for cluster in self.clusters]\n self.cell_loads = [sum([len(cell) for cell in self.proc_blocks])]\n self.particle_loads = [cluster.np for cluster in self.clusters]\n self.imbalance = LoadBalancer.get_load_imbalance(self.particle_loads)","def update_state(fun):\n def wrapper(*args):\n t1 = time.time()\n files_processed, datasets = fun(*args)\n for dataset in datasets:\n dataset.files_processed += files_processed\n dataset.update_state(args[1], t1)\n return wrapper","def _recalculate_centroids(self):\n\n self._prev_centroids = dict(self.centroids)\n for cluster in self.clusters:\n self.centroids[cluster] = np.average(self.clusters[cluster], axis=0)","def update_all(self):\n self.update_head_node_ip()\n self.get_database_info()\n self.update_users()","def cluster_bal_iter(self):\n # moving\n for j,cluster in enumerate(self.clusters):\n cluster.move()\n self.clusters_allocate_cells()\n for j,cluster in enumerate(self.clusters):\n cluster.calc()\n #print j, '\\t', cluster.center, '\\t', cluster.np, '\\t', cluster.size\n \n # resizing\n for j,cluster in enumerate(self.clusters):\n cluster.resize()\n self.clusters_allocate_cells()\n for j,cluster in enumerate(self.clusters):\n cluster.calc()\n #print j, '\\t', cluster.center, '\\t', cluster.np, '\\t', cluster.size\n \n self.calc()","def update(self):\n for uid, server in self.servers_online.items():\n if len(server.jobs):\n self.populate_server(server)\n for uid, server in self.servers_online.items():\n if server.jobs:\n server.jobs[0].task_time -= time_interval\n server.waiting_time -= time_interval\n if server.jobs[0].task_time <= 0:\n completed_task = server.jobs.pop(0)\n print(f\"Task '{completed_task.description}' completed\")\n self.all_tasks.remove(completed_task)\n self.servers_jobs_list[uid].pop(0)\n for uid, server in self.all_servers.items():\n if server.status:\n print(f\"{server.server_name} has {len(set(server.jobs))} job(s)\")\n else:\n print(f\"{server.server_name} is offline\")","def compute_updates(self, xs, gs, state=None):\n raise NotImplementedError()","def set_cores(self, cores):\n self.cores = cores\n return","def _update_output_states(self, runtime_params=None, time_scale=None, context=None):\n for i in range(len(self.outputStates)):\n state = list(self.outputStates.values())[i]\n state.update(params=runtime_params, time_scale=time_scale, context=context)\n # self.outputValue[i] = state.value\n\n # Assign value of each outputState to corresponding item in self.outputValue\n self.outputValue = list(state.value for state in list(self.outputStates.values()))","def cluster_shutdown():\n map(shutdown, cluster)","def init_cpu_counts(host):\n host.cpu_functions = {}\n host.cpu_lists = {}\n for s in range(0, len(host.nodes)):\n host.cpu_functions[s] = {}\n for f in CORE_FUNCTIONS:\n host.cpu_functions[s][f] = []\n host.cpu_lists[s] = []","def update_state(self, **kwargs):\n\n for name in self.metrics:\n\n metric = self.metrics[name]\n\n argspec = inspect.getfullargspec(metric.update_state)\n\n kwargs_to_pass = {k: kwargs[k] for k in kwargs if k in argspec.args}\n\n metric.update_state(**kwargs_to_pass)","def update_cluster_hosts(self, hosts):\n self._hosts = hosts\n self._collect_hosts_d = True","def update_cluster(self, cluster, params, *args, **kwargs):\n raise NotImplementedError","def start(self):\n\t\tself.distributedVarPart()\n\t\twhile self.t < self.T:\n\t\t\tself.t += 1\n\t\t\tfor cluster in self.clusterList:\n\t\t\t\tprint(\"cluster: \")\n\t\t\t\tprint(cluster)\n\t\t\t\tprint(self.clusterList[cluster])\n\t\t\t\tself.C[cluster] = self.average_consensus(self.clusterList[cluster])\n\t\t\tprint(self.C)\n\t\t\tprint(\"turn t=%s: Centroids%s\"% (self.t, self.C), flush=True)\n\t\t\ttime.sleep(1)","def _nthreads_update(self):\n self.inputs.environ[\"OMP_NUM_THREADS\"] = \"%d\" % self.inputs.num_threads","def _update_all_tasks(self) -> None:\n for task in self.tasks:\n task.update()","def cores_per_node(self):\n return self.cores_per_socket * self.sockets_per_node","def updateList(self):\n for state in list_:\n state.update(True)","def updateState(self):\n self.state = self.microgridPolicy.computeState();","def progressUpdate(clusterid):\n progress_update.updateProgress(clusterid)","def run(self):\n for msr in self.msrs:\n # find state transition matrix\n phi_p, state_prop = self._compute_stm(msr.time)\n\n # use stm to propagate perturbation and covariance\n cov_m = np.matmul(phi_p, np.matmul(self.cov_list[-1],\n np.transpose(phi_p)))\n\n # compute observation deviation, obs_state matrix\n y_i, h_tilde = self._msr_resid(msr, state_prop)\n\n # calculate kalman gain\n k_gain = self._calc_k_gain(cov_m, h_tilde, msr.cov)\n\n # measurement update\n cov_p, state_est = self._measurement_update(y_i,\n h_tilde,\n k_gain,\n cov_m,\n state_prop)\n\n # update the state lists\n self.residuals.append(y_i)\n self.prop_state_list.append(state_est)\n self.estimates.append(state_est)\n self.cov_list.append(cov_p)\n self.times.append(msr.time)","def _update_running_nodes(self) -> None:\n with self._running_node_lock:\n try:\n (ping_nodes, _) = rosnode.rosnode_ping_all()\n except Exception:\n logging.error(\"[NodeMonitor]: Rosnode threw exception. Master node could be dead\")\n ping_nodes = list()\n\n # Since the monitor node is empty, defaulting to monitoring all nodes\n if not self._monitor_nodes:\n self._seen_nodes = set(ping_nodes)\n self._running_nodes = set(ping_nodes)\n else:\n current_running_nodes = set()\n for node in ping_nodes:\n if self._is_monitor_node(node):\n # Update seen nodes if node regex matches monitor nodes\n if node not in self._seen_nodes:\n self._seen_nodes.add(node)\n # Add to current running nodes\n current_running_nodes.add(node)\n self._running_nodes = current_running_nodes","def update_nodes(self):\n raise NotImplementedError('ERROR: sweeper has to implement update_nodes(self)')","def update_state(self):\n\n # Start off assuming no space in the queues and no pointer to a\n # shortest queue.\n self.min_queue = None\n self.has_space_in_a_server_queue = False\n self.queue_size = 0\n self.online_server_count = 0\n\n # Loop through all the servers.\n for server in self.server_list:\n\n # If server is online....\n if server.online is True:\n\n # Increment count of online servers\n self.online_server_count += 1\n\n # If any server has space...\n if len(server.queue) < server.max_queue_size:\n\n # 'Has Space' is True and remains true.\n if self.has_space_in_a_server_queue is False:\n self.has_space_in_a_server_queue = True\n\n # First non-full server we come to.\n if self.min_queue is None:\n self.min_queue = server\n\n # If we already had a non-full queue in hand,\n # compare it to the present one.\n elif len(server.queue) < len(self.min_queue.queue):\n self.min_queue = server\n\n # Increment the count of the parallel server block.\n self.queue_size += len(server.queue)","def update_status(self):\n\n # first get the instances we need to check\n monitor_jobs = {}\n for _, job_node in self.get_executions_iterator():\n if job_node.is_job:\n for job_instance in job_node.instances:\n if not job_instance.simulate:\n if job_instance.host in monitor_jobs:\n monitor_jobs[job_instance.host]['names'].append(\n job_instance.name)\n else:\n monitor_jobs[job_instance.host] = {\n 'config': job_instance.monitor_config,\n 'type': job_instance.monitor_type,\n 'workdir': job_instance.workdir,\n 'names': [job_instance.name],\n 'period': job_instance.monitor_period\n }\n else:\n job_instance.set_status('COMPLETED')\n\n # nothing to do if we don't have nothing to monitor\n if not monitor_jobs:\n return\n\n # then look for the status of the instances through its name\n states = self.jobs_requester.request(monitor_jobs, self.logger)\n\n # finally set job status\n for inst_name, state in states.iteritems():\n self.job_instances_map[inst_name].set_status(state)\n\n # We wait to slow down the loop\n sys.stdout.flush() # necessary to output work properly with sleep\n time.sleep(LOOP_PERIOD)","def test_update_hyperflex_cluster(self):\n pass","def check_cores(self):\n\n cores = []\n # Execute command to check for cores\n header = [\"VDC\", \"Module\", \"Instance\",\n \"Process-name\", \"PID\", \"Date\\(Year-Month-Day Time\\)\"]\n\n if self.device.alias == 'uut':\n # In case of restarting process on a the main VDC\n output = oper_fill_tabular(device=self.device,\n show_command='show cores vdc-all',\n header_fields=header, index=[5])\n else:\n # In case of restarting process on a sub-VDC\n self.device.disconnect()\n output = oper_fill_tabular(device=self.device,\n show_command='show cores',\n header_fields=header, index=[5])\n\n if not output.entries:\n log.info('No core found')\n return []\n\n # Parse through output to collect core information (if any)\n for k in sorted(output.entries.keys(), reverse=True):\n row = output.entries[k]\n date = row.get(\"Date\\(Year-Month-Day Time\\)\", None)\n if not date:\n continue\n date_ = datetime.strptime(date, '%Y-%m-%d %H:%M:%S')\n\n # Save core info\n core_info = dict(module=row['Module'],\n pid=row['PID'],\n instance=row['Instance'],\n process=row['Process-name'],\n date=date.replace(\" \", \"_\"))\n cores.append(core_info)\n\n return cores","def update(self):\n self.cpus_current = psutil.cpu_percent(percpu=True)\n assert len(self.cpus_current) == len(self.cpus)\n return self.cpus_current","def multiClusterAlgorithm(values):\n clusterMap = dict()\n # Lowest unixtime in the values list\n startUnixtime = values[0][0]\n # Separate values into separate clusters in the map, clusterMap\n for value in values:\n if value[2] not in clusterMap.keys():\n clusterMap[value[2]] = []\n clusterMap[value[2]].append(value)\n \n # An array of the predicted values per cluster\n clusterPredicted = []\n # An array of unixtime averages per cluster\n unixtimeAverage = []\n \n # Generate predicted value for each cluster using a weighted average\n # Adds predicted value for each cluster to clusterPredicted and adds\n # the unixtime average for each cluster to unixtimeAverage\n for key in clusterMap.keys():\n clusterLength = len(clusterMap[key]) \n totalUnixtime = sum([elem[0] for elem in clusterMap[key]])\n unixtimeAverage.append(float(totalUnixtime) / float(clusterLength))\n \n clusterLight = [elem[1] for elem in clusterMap[key]]\n\n totalDistanceFromStart = sum([elem[0] - startUnixtime for elem in clusterMap[key]])\n clusterWeightValues = [float(elem[0] - startUnixtime) / float(totalDistanceFromStart) for elem in clusterMap[key]]\n \n predicted = np.average(clusterLight, weights = clusterWeightValues)\n clusterPredicted.append(predicted)\n \n print clusterPredicted\n total = sum([elem - startUnixtime for elem in unixtimeAverage])\n # Create weighted values based on unixtime average per cluster\n weightValues = [float(elem - startUnixtime) / float(total) for elem in unixtimeAverage]\n print weightValues\n # Return a weighted average across clusters\n return np.average(clusterPredicted, weights = weightValues)","def update_all_states(self):\n \n for l in range(0,4):\n temp_s = \"/loop/{}/mode\".format(l+1) # stupid using loop 1 to 4\n temp_m = self.loop_modes[self.loop_states[l]]\n self.osc_client.send_message(temp_s,temp_m)\n print(\"sent_message {} {}\".format(temp_s,temp_m))\n self.set_loop_led(l)\n \n for l in range(0,4):\n for s in range(0,8):\n temp_s = self.osc_slice_string.format(l+1,s)\n temp_m = self.slice_modes[self.slice_states[l][s] ]\n self.osc_client.send_message(temp_s,temp_m)\n print(\"sent message {} {}\".format(temp_s, temp_m))\n self.set_slice_led(l,s)\n return","def update(self, iterable):\n self._update_nodes(iterable)","def _update_clusters(partial, to_update, grids):\n df, settings = partial\n clusters = settings['clusters']\n primary_key = settings['idCol']\n cluster_id = settings['predCol']\n column = settings['feature']\n init, end, end2 = grids\n\n if len(df) > 0:\n tmp = df.apply(lambda row: _inblock(row, column, init, end2), axis=1)\n df = df.loc[tmp]\n df.drop_duplicates([primary_key], inplace=False, ignore_index=True)\n\n for key in to_update:\n if key in clusters:\n df.loc[df[cluster_id] == key, cluster_id] = to_update[key]\n\n df.loc[df[cluster_id].str.contains(\"-0\", na=False), cluster_id] = -1\n df = df.drop([primary_key], axis=1)\n\n return df","def _compute_centroids(self):\n\n for i in range(0, self.k):\n cluster = np.argwhere(self.assigned_clusters == i)\n cluster_points = self.data[cluster].squeeze()\n self.centroids[i] = np.mean(cluster_points, axis=0)","def __update_task(self, tasks, **extra_args):\n for task in tasks:\n assert isinstance(\n task, Task), \"Core.update_job_state: passed an argument\" \\\n \" which is not a `Task` instance.\"\n task.update_state()","def cluster_reboot(cluster):\n map(reboot, cluster)","async def update_series(self):\n log.info('Updating all series')\n await self.updater.update_series()\n log.info('Done updating all series')","def update_all_agent(self):\n for a in self.agents:\n soft_update(a.target_actor, a.actor, self.tau)\n soft_update(a.target_critic, a.critic, self.tau)\n self.num_iteration += 1","def test_setting_state_parallel(self):\n no_replicates = 25\n\n replicate(experiment, no_replicates, parallel=True, no_processes=2)\n for i in range(no_replicates):\n self.assertIn('result', state[SUBSTATE_KEY_PATTERN % i])\n self.assertEqual(state[SUBSTATE_KEY_PATTERN % i]['result'], \"bla\")","def submit_cpucores():\n # TODO(soltesz): move static value to an external, inventory table.\n submit_generic(_root_hostname, 'cpu_cores', 'gauge', _CPU_COUNT)","def incrementTimers(self):\n # online servers\n for server in self.online_servers:\n self.online_servers[server][0] += 1\n # offline servers\n for server in self.offline_servers:\n self.offline_servers[server][0] += 1\n \n return","def compute_cluster_metrics(self, event_index: int, timestamp: datetime, cp_count: int,\n normal_clusters: Tuple[List[List], List[List]], o_clusters: List[Cluster]) -> None:\n c_clusters, p_clusters = normal_clusters[0], normal_clusters[1]\n for group in c_clusters:\n for cluster in group:\n self.compute_cluster_metrics_helper(event_index, timestamp, cp_count, cluster, 'core micro-cluster')\n\n for group in p_clusters:\n for cluster in group:\n self.compute_cluster_metrics_helper(event_index, timestamp, cp_count, cluster, 'potential micro-cluster')\n\n for cluster in o_clusters:\n self.compute_cluster_metrics_helper(event_index, timestamp, cp_count, cluster, 'outlier micro-cluster')","def update_state(self):\n self.reset_state()\n for piece in self.pieces:\n coordinates = piece.get_block_positions()\n for coor in coordinates:\n x, y = coor\n self.state[y][x] = piece","def update(self, clusters):\n centroids = {}\n for cluster, coordinates in clusters.iteritems():\n sumLat = 0\n sumLong = 0\n for coordinate in coordinates:\n sumLat += float(coordinate[0])\n sumLong += float(coordinate[1])\n centroids[cluster] = (sumLat/float(len(coordinates)), sumLong/float(len(coordinates)))\n return centroids","def reset():\n for cpu_id in POSSIBLE_CPUS:\n set_cpu(cpu_id, True)","def gen_cluster_accuracies():\n accuracies = {}\n with Parallel(n_jobs=morphs.parallel.N_JOBS) as parallel:\n for block_path in morphs.paths.blocks():\n print(block_path)\n spikes = morphs.load.ephys_data(block_path, collapse_endpoints=True)\n\n if len(spikes[\"recording\"].unique()) >= 1:\n template_spikes = spikes[spikes[\"stim_id\"].isin(list(\"abcdefgh\"))]\n assert len(template_spikes) > 0\n cluster_groups = template_spikes.groupby(\"cluster\")\n\n morph_dims = spikes.morph_dim.unique()\n morph_dims = morph_dims[~pd.isnull(morph_dims)]\n morph_dims.sort()\n\n max_num_reps = np.max(\n [\n len(stim_group.groupby(by=[\"recording\", \"stim_presentation\"]))\n for stim_id, stim_group in template_spikes.groupby(\"stim_id\")\n ]\n )\n\n accuracies_list = parallel(\n delayed(cluster_accuracy)(\n cluster, cluster_group, morph_dims, max_num_reps\n )\n for (cluster, cluster_group) in cluster_groups\n )\n\n accuracies[block_path] = pd.concat(accuracies_list)\n\n morphs.paths.PROCESSED_DIR.mkdir(parents=True, exist_ok=True)\n with open(morphs.paths.ACCURACIES_PKL.as_posix(), \"wb\") as f:\n pickle.dump(accuracies, f)","def _update(self):\n # clear group before rebuild\n self.clear()\n\n # build configuration groups\n self._config_names = []\n for i in range(self._n_configs):\n config_name = f\"config{i+1:02}\"\n self._config_names.append(config_name)\n self._build_config_group(config_name)\n\n # reset active configuration if necessary\n if not all(cname in self._config_names for cname in self._active_config):\n self._active_config = (self._config_names[0],)\n\n # build datasets\n self._build_datasets()","async def update_all_servers(self):\n await self.updater.update_all_servers()","def update_all(self, message_func=\"default\",\n reduce_func=\"default\",\n apply_node_func=\"default\"):\n num_worker_nodes = int(self.number_of_nodes() / self.num_workers) + 1\n start_node = self.worker_id * num_worker_nodes\n end_node = min((self.worker_id + 1) * num_worker_nodes, self.number_of_nodes())\n worker_nodes = np.arange(start_node, end_node, dtype=np.int64)\n self.pull(worker_nodes, message_func, reduce_func, apply_node_func, inplace=True)\n self._sync_barrier()","def update_states(self) -> None:\n self.set_states()\n self.async_write_ha_state()","def _update_state(self):\n if self.state == State.INITIALIZED:\n print(\"Error: runs not yet submitted, no state to retrieve\")\n return\n elif self.state == State.COMPLETED:\n # No update is necessary, since nothing changes once the state is COMPLETED.\n return\n\n # First, update the status of all batches.\n summaries_by_uuid = self.batches_module.get_summaries(self.project)\n\n for batch in self.batch_runs:\n batch.set_state_summary(summaries_by_uuid[batch.get_uuid()])\n\n # Then, if the state of this whole batch should be updated, do that.\n complete = True\n for b in self.batch_runs:\n if not b.get_calc_state() in ['COMPLETED', 'FAILED']:\n complete = False\n break\n if complete:\n self.state = State.COMPLETED\n\n self._update_cached_status()","def run(self):\n import time\n\n\n for msr in self.msrs:\n # find state transition matrix\n phi_p, state_prop = self._compute_stm(msr.time)\n\n # use stm to propagate perturbation and covariance\n pert_m = np.matmul(phi_p, self.pert_vec[-1])\n cov_m = np.matmul(phi_p, np.matmul(self.cov_list[-1],\n np.transpose(phi_p)))\n\n\n # compute observation deviation, obs_state matrix\n y_i, h_tilde = self._msr_resid(msr, state_prop)\n\n # calculate kalman gain\n k_gain = self._calc_k_gain(cov_m, h_tilde, msr.cov)\n\n # measurement update\n cov_p, pert_p = self._measurement_update(y_i,\n h_tilde,\n pert_m,\n k_gain,\n cov_m)\n\n # update the state lists\n self.residuals.append(y_i)\n self.prop_state_list.append(state_prop)\n self.estimates.append(np.add(state_prop, np.transpose(pert_p))[0])\n self.cov_list.append(cov_p)\n self.pert_vec.append(pert_p)\n self.times.append(msr.time)","def update_current_state(self, agent_num):\n for task_num, i in enumerate(self.tasks):\n current_task_data = []\n task_loc = i.getloc()\n vectorized_task_loc = self.get_vectorized_location(task_loc)\n current_task_data.append(self.t)\n current_task_data.append(self.w_EDR)\n current_task_data.append(self.w_RESOURCE)\n current_task_data.append(self.w_DISTANCE)\n current_task_data.append(agent_num)\n\n current_task_data.append(task_num)\n current_task_data.extend(self.is_agent_idle[agent_num]) # Feature 6\n current_task_data.append((self.is_task_finished[0][task_num])) # Feature 2\n current_task_data.append((self.is_task_enabled[0][task_num])) # Feature 3\n current_task_data.append((self.is_task_alive[0][task_num])) # Feature 4\n current_task_data.append((self.travel_time_constraint_satisfied[agent_num][task_num])) # Feature 5\n is_occupied = self.agent_locations[0][vectorized_task_loc] # if 1 agent is there, 0 is unoccupied\n current_task_data.append((is_occupied)) # Feature 1\n current_task_data.append((self.agent_distances[agent_num][task_num])) # Feature 7\n current_task_data.append((self.orientation[agent_num][task_num])) # Feature 9\n current_task_data.append((self.task_deadlines[0][task_num])) # Feature 10\n current_task_data.append((self.is_task_in_progress[0][task_num])) # Feature 11\n current_task_data.append((\n self.orientation[agent_num][task_num] * self.agent_distances[agent_num][task_num])) # Feature 12\n current_task_data.append((self.how_many_tasks_in_each_square[0][vectorized_task_loc])) # Feature 8\n if self.task_to_schedule == -1:\n null_task = 1\n else:\n null_task = 0\n current_task_data.append(null_task)\n current_task_data.append(-7) # This is not really needed, but I'll add in -7 as a bs val\n self.network_state.append(current_task_data)","def update(self,x,y):\n if self.ncores > 1:\n # parallel updates\n pass # FIXME\n else:\n # sequential updates\n for tree in self.forest:\n tree.update(x,y)","def restructure_host_cpu_data(host):\n init_cpu_counts(host)\n host.sockets = len(host.nodes or [])\n host.hyperthreading = False\n host.physical_cores = 0\n if not host.cpus:\n return\n host.cpu_model = host.cpus[0].cpu_model\n cpu_list = sorted(host.cpus, key=_sort_by_coreid)\n for cpu in cpu_list:\n inode = pecan.request.dbapi.inode_get(inode_id=cpu.forinodeid)\n cpu.numa_node = inode.numa_node\n if cpu.thread == 0:\n host.physical_cores += 1\n elif cpu.thread > 0:\n host.hyperthreading = True\n function = cpu.allocated_function or get_default_function(host)\n host.cpu_functions[cpu.numa_node][function].append(int(cpu.cpu))\n host.cpu_lists[cpu.numa_node].append(int(cpu.cpu))","def refresh_node_status(self):\n\n for node in Node.values():\n del Node[node.name]\n\n status_command = {\"command\": \"UPDATE_STATUS\"}\n publish_command(\n redis_connection(),\n all_nodes_channel_name(),\n status_command)","def _train_loop(self, X, update_counter, context_mask):\n\n epoch = 0\n prev_activation = np.zeros((self.map_dim, self.data_dim))\n influences, learning_rates = self._param_update(0, len(update_counter))\n\n for idx, x in enumerate(progressbar(X)):\n\n prev_activation = self._example(x, influences, prev_activation=prev_activation)\n\n if idx in update_counter:\n\n epoch += 1\n influences, learning_rate = self._param_update(epoch, len(update_counter))\n\n if idx in context_mask:\n\n prev_activation = np.zeros((self.map_dim, self.data_dim))","def cache_thetas_multicore(eta, povs, n_cores, start=0, stop=(len(adjusted_adj_list_4.keys())-1)):\n import os\n import multiprocessing\n processes=[]\n for x in range(n_cores):\n theta_lists = adjusted_adj_list_4.keys()[start:stop]\n theta_lists = np.array_split(theta_lists, n_cores)\n p = multiprocessing.Process(target=cache_thetas,\n args = [eta, povs,theta_lists[x][0],\n theta_lists[x][-1]])\n p.start()\n processes.append(p)\n for p in processes:\n p.join()","def __init__(self, coresys: CoreSys):\n self.coresys = coresys\n self.run = asyncio.Lock()","def __init__(self, coresys: CoreSys):\n self.coresys = coresys\n self.run = asyncio.Lock()","def update(self, iteration):\n pass","def Update(self, ticks=0):\r\n for name in self.actors:\r\n self.actors[name].Update(ticks=ticks)","def update_job_state(self, *tasks, **extra_args):\n pass","def compute_clusters(self, p: float):\n pass","def _update_(self, data):\n # imports\n from intervals import Interval, LinkedIntervalSet\n \n # create a LinkedIntervalSet to store the time-based states for this\n # hero\n states = [Interval(dict((HER_KWD_MAP.get(k, k), d[1][k]) for k in d[1]), d[0]) for d in data]\n self.states = LinkedIntervalSet.from_starts(states)","def automerge_clusters(self):\n all_clusters = self.get_clusters().copy()\n\n if not self._single: # if not in single mode mode\n # initialize the variable to check if some change has happened \n changed = False\n for cl_1 in all_clusters: # cycle over clusters\n c_c1 = all_clusters[cl_1]\n for cl_2 in all_clusters: # inner cycle over clusters\n c_c2 = all_clusters[cl_2]\n # if two clusters have the same speaker and have different \n # cluster identifiers\n if cl_1 != cl_2 and c_c1.get_speaker() != 'unknown' and c_c1.get_speaker() == c_c2.get_speaker() and self._clusters.has_key(cl_1) and self._clusters.has_key(cl_2):\n changed = True\n # merge the clusters an record that something changed\n self._merge_clusters(cl_1, cl_2)\n if changed: # if something has changed\n # rename all the clusters starting from S0\n self._rename_clusters()\n # remove also the old waves and seg files of the old clusters\n shutil.rmtree(self.get_file_basename())\n # rebuild all seg files\n self.generate_seg_file(set_speakers=False)\n # resplit the original wave file according to the new clusters\n self._to_trim()","def initClusters(self):\n if len(self.labelList) != len(self.pointList):\n \traise ValueError(\"Label List and Point List not the same length!\")\n for i in range(len(self.labelList)):\n self.centroids[self.labelList[i]] = self.pointList[i]\n self.pointcounts[self.labelList[i]] = 1","def updateRcloneJobStatus():\n global jobIds, jobStatusGauge\n\n # Check if the jobs are running, update the variables\n for jobName, jobId in jobIds.items():\n jobIsRunning = getRcloneJobRunning(jobId)\n jobIds[jobName] = jobId if jobIsRunning else None\n jobStatusGauge.labels(rclone_job=jobName).set(1 if jobIsRunning else 0)","def batch_update(self, parents_classes_dict):\n print(\"Updating the LowerLevelGrid with a batch of examples\")\n for (class_id, coords), examples in parents_classes_dict.items():\n coords = tuple([int(x / 2) for x in coords])\n self.hypercubes[coords].update_lower_level(example_class=class_id, example_count=len(examples), threshold=self.threshold)\n if self.child_grid:\n self.child_grid.batch_update(parents_classes_dict=parents_classes_dict)","def run_evaluation(self, n_runs=1, n_points=1000, n_iterations=1, min_n_components=2, max_n_components=25,\n\t\t\t\t\t n_splits=3, save_data=False, file_label='',n_microstates=None, all_methods=True,\n\t\t\t\t\t assign_transition_points=True):\n\n\t\tif self.presampled_data is not None:\n\t\t\tsampled_data = self.presampled_data[0]\n\t\t\ttrue_clustering = self.presampled_data[1]\n\t\t\tn_runs = sampled_data.shape[0]\n\n\t\tself.cluster_score_ami_kmeans_ = np.zeros(n_runs)\n\t\tself.cluster_score_ami_AW_ = np.zeros(n_runs)\n\t\tself.cluster_score_ami_spectral_ = np.zeros(n_runs)\n\t\tself.cluster_score_ami_density_peaks_ = np.zeros(n_runs)\n\t\tself.cluster_score_ami_GMM_ = np.zeros(n_runs)\n\t\tself.cluster_score_ami_GMM_FE_min_ = np.zeros(n_runs)\n\n\t\tself.cluster_score_fm_kmeans_ = np.zeros(n_runs)\n\t\tself.cluster_score_fm_AW_ = np.zeros(n_runs)\n\t\tself.cluster_score_fm_spectral_ = np.zeros(n_runs)\n\t\tself.cluster_score_fm_density_peaks_ = np.zeros(n_runs)\n\t\tself.cluster_score_fm_GMM_ = np.zeros(n_runs)\n\t\tself.cluster_score_fm_GMM_FE_min_ = np.zeros(n_runs)\n\n\t\tself.cluster_score_vm_kmeans_ = np.zeros(n_runs)\n\t\tself.cluster_score_vm_AW_ = np.zeros(n_runs)\n\t\tself.cluster_score_vm_spectral_ = np.zeros(n_runs)\n\t\tself.cluster_score_vm_density_peaks_ = np.zeros(n_runs)\n\t\tself.cluster_score_vm_GMM_ = np.zeros(n_runs)\n\t\tself.cluster_score_vm_GMM_FE_min_ = np.zeros(n_runs)\n\n\t\tdata = self.toy_model_.sample(3)\n\n\t\t# Create free energy estimators\n\t\tgmm_FE = GMM_FE.FreeEnergyClustering(data, min_n_components=min_n_components, max_n_components=max_n_components,\n\t\t\t\t\t\t\t\t\t x_lims=self.x_lims_, n_grids=self.n_grids_, stack_landscapes=False,\n\t\t\t\t\t\t\t\t\t n_splits=n_splits, n_iterations=n_iterations,convergence_tol=self.convergence_tol_,\n\t\t\t\t\t\t\t\t\t verbose=self.verbose_)\n\n\t\tkm = kmc.KMeansCluster(min_n_components, max_n_components)\n\t\taw = awc.AWCluster(min_n_components, max_n_components)\n\t\tspectral = sc.SpectralCluster(min_n_components, max_n_components)\n\n\t\tall_data = []\n\t\tfor i_run in range(n_runs):\n\t\t\tprint(\"Run: \"+str(i_run+1)+'/'+str(n_runs))\n\n\t\t\tif self.presampled_data is None:\n\t\t\t\t# Sample data\n\t\t\t\tdata = self.toy_model_.sample(n_points)\n\t\t\telse:\n\t\t\t\tdata = sampled_data[i_run]\n\t\t\t\n\t\t\tall_data.append(data)\n\n\t\t\tprint('Shape data: ' + str(data.shape))\n\n\t\t\t# Set data in model and estimate GMM density\n\t\t\tgmm_FE.data_ = data\n\t\t\tcoords, est_FE_landsc, FE_points = gmm_FE.landscape()\n\n\t\t\t# Get true cluster labels\n\t\t\tif self.presampled_data is None:\n\t\t\t\tif hasattr(self.toy_model_, \"assign_cluster_labels\"):\n\t\t\t\t\tself.true_labels_ = self.toy_model_.assign_cluster_labels(data)\n\t\t\t\telse:\n\t\t\t\t\tprint('Setting true labels.')\n\t\t\t\t\tself.true_labels_, _ = self.true_FE_.cluster(data, np.zeros(data.shape[0]))\n\t\t\telse:\n\t\t\t\tself.true_labels_ = true_clustering[i_run]\n\t\t\t\n\t\t\t# Cluster data with different methods\n\t\t\tif n_microstates is None:\n\t\t\t\tself.FE_min_labels, _ = gmm_FE.cluster(data, FE_points, assign_transition_points=assign_transition_points)\n\t\t\telse:\n\t\t\t\tkmea = KMeans(n_clusters=n_microstates).fit(data[::2])\n\t\t\t\tmicrostate_centers = kmea.cluster_centers_\n\t\t\t\tself.FE_min_labels, _ = gmm_FE.cluster(microstate_centers, FE_points, data, assign_transition_points=assign_transition_points, unravel_grid=False)\n\n\t\t\tif all_methods:\n\t\t\t\tself.km_labels = km.cluster(data)\n\t\t\t\tself.aw_labels = aw.cluster(data)\n\t\t\t\tself.spectral_labels = spectral.cluster(data)\n\n\t\t\t# Score clustering using different scoring metrics\n\t\t\t# V-measure score\n\t\t\tself.cluster_score_vm_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'vm')\n\t\t\tprint(self.cluster_score_vm_GMM_FE_min_[i_run])\n\t\t\tif all_methods:\n\t\t\t\tself.cluster_score_vm_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'vm')\n\t\t\t\tself.cluster_score_vm_kmeans_[i_run] = self._score_clustering(self.km_labels,'vm')\n\t\t\t\tself.cluster_score_vm_AW_[i_run] = self._score_clustering(self.aw_labels,'vm')\n\t\t\t\tself.cluster_score_vm_spectral_[i_run] = self._score_clustering(self.spectral_labels,'vm')\n\n\t\t\t\t# Adjusted MI\n\t\t\t\tself.cluster_score_ami_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'ami')\n\t\t\t\tself.cluster_score_ami_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'ami')\n\t\t\t\tself.cluster_score_ami_kmeans_[i_run] = self._score_clustering(self.km_labels,'ami')\n\t\t\t\tself.cluster_score_ami_AW_[i_run] = self._score_clustering(self.aw_labels,'ami')\n\t\t\t\tself.cluster_score_ami_spectral_[i_run] = self._score_clustering(self.spectral_labels,'ami')\n\n\t\t\t\t# Fowlkes Mallows\n\t\t\t\tself.cluster_score_fm_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'fm')\n\t\t\t\tself.cluster_score_fm_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'fm')\n\t\t\t\tself.cluster_score_fm_kmeans_[i_run] = self._score_clustering(self.km_labels,'fm')\n\t\t\t\tself.cluster_score_fm_AW_[i_run] = self._score_clustering(self.aw_labels,'fm')\n\t\t\t\tself.cluster_score_fm_spectral_[i_run] = self._score_clustering(self.spectral_labels,'fm')\n\t\t\n\t\tif save_data:\n\t\t\tif self.presampled_data is None:\n\t\t\t\tnp.save('data_out/sampled_data_'+self.toy_model_.name+file_label+'.npy',all_data)\n\n\t\t\tif False:\n\t\t\t\tnp.save('data_out/cluster_score_fm_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_fm_GMM_FE_min_)\n\t\t\t\tnp.save('data_out/cluster_score_fm_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_GMM_)\n\t\t\t\tnp.save('data_out/cluster_score_fm_kmeans_' + self.toy_model_.name +file_label +'.npy', self.cluster_score_fm_kmeans_)\n\t\t\t\tnp.save('data_out/cluster_score_fm_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_AW_)\n\t\t\t\tnp.save('data_out/cluster_score_fm_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_spectral_)\n\n\t\t\t\tnp.save('data_out/cluster_score_ami_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_ami_GMM_FE_min_)\n\t\t\t\tnp.save('data_out/cluster_score_ami_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_GMM_)\n\t\t\t\tnp.save('data_out/cluster_score_ami_kmeans_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_kmeans_)\n\t\t\t\tnp.save('data_out/cluster_score_ami_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_AW_)\n\t\t\t\tnp.save('data_out/cluster_score_ami_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_spectral_)\n\n\t\t\tnp.save('data_out/cluster_score_vm_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_vm_GMM_FE_min_)\n\t\t\tif all_methods:\n\t\t\t\tnp.save('data_out/cluster_score_vm_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_GMM_)\n\t\t\t\tnp.save('data_out/cluster_score_vm_kmeans_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_kmeans_)\n\t\t\t\tnp.save('data_out/cluster_score_vm_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_AW_)\n\t\t\t\tnp.save('data_out/cluster_score_vm_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_spectral_)\n\t\treturn","def update_state(self, result):\n for i,k in enumerate(self._current_state.keys()):\n self._current_state[k] = result[i]","def train_workers(self):\n args = dict(actor=self.actor,\n critic=self.critic,\n gamma=self.gamma,\n lamda=self.lamda or self.gamma / 1.005,\n device=self.device,\n optimizers=[self.actor_optimizer, self.critic_optimizer])\n workers = [Worker(i, self.action_size, self.state_size, **args)\n for i in range(self.n_workers)\n ]\n\n print(f'Worker count: {len(workers)}')\n\n for worker in workers:\n worker.start()\n\n while len(constants.scores) < self.n_steps:\n time.sleep(400) # save checkpoint every 400 ms\n\n print(f'\\nCurrent scores: {constants.scores}')\n\n self.save(constants.episode)\n print(f'\\nCheckpoint saved at episode: {constants.episode}\\n')","def update(self):\n\n\t\tif not self.complete:\n\t\t\tfor vasp_run in self.vasp_run_list:\n\t\t\t\tvasp_run.update()","def update_clusters(self, data):\n\n self.unassigned_data_updated = [None]\n cluster_list = []\n cluster_indices = []\n bud_list = []\n bud_indices = []\n\n # First of all, seperate buds and clusters\n for cluster_index, cluster in self.clusters.items():\n if cluster.number_of_members < self.minnpix_cluster:\n bud_list.append(cluster)\n bud_indices.append(cluster_index)\n else:\n cluster_list.append(cluster)\n cluster_indices.append(cluster_index)\n\n # Take all of the bud data and put it back into an unassigned list\n unassigned_data_updated = []\n for i in range(len(bud_indices)):\n self.clusters.pop(bud_indices[i])\n idx = np.squeeze(np.where(self.cluster_arr[1,:] == bud_indices[i]))\n self.cluster_arr[1,idx] = -1.0\n unassigned_data_updated.extend(data[:,bud_list[i].cluster_members].T)\n\n # Turn that into an array and transpose\n unassigned_data_updated = np.asarray(unassigned_data_updated)\n unassigned_data_updated = unassigned_data_updated.T\n\n # There shouldn't be any in theory, but just check there are no duplicates\n try:\n unassigned_data_updated = np.unique(unassigned_data_updated, axis=1)\n except ValueError:\n pass\n\n # Sort the unassigned data according to peak intensity and send it back\n if np.size(unassigned_data_updated) != 0.0:\n sortidx = argsort(unassigned_data_updated[2,:], reversed=True)\n self.unassigned_data_updated = unassigned_data_updated[:,sortidx]\n else:\n pass\n\n return cluster_list, cluster_indices","def cluster_cal(self):\n self.Cluster = []\n for i in range(self.nodenum):\n neighborhood_node = self.neighbor_node(i)\n Node_num = len(neighborhood_node)\n Count = self.neighbor_edge(neighborhood_node)\n if(Node_num == 0 or Node_num == 1):\n self.Cluster.append(0.5)\n else:\n self.Cluster.append(Count/(Node_num*(Node_num - 1)))\n \n self.cluster_coeff = np.average(self.Cluster)","def update_state(self, context: GANContext) -> None:\n updater = lambda value: lambda: self._metric.update_state(value)\n for real_xy, noise in context.dataset:\n real_x, real_y = real_xy\n\n g_inputs = noise\n if len(context.generator_model.inputs) == 2:\n g_inputs = [noise, real_y]\n\n fake = context.generator_model(\n g_inputs, training=context.log_eval_mode == LogEvalMode.TRAIN\n )\n\n # check the resolution is the same as the one passed as input\n resolution = real_x.shape[1]\n if resolution != self.resolution:\n raise ValueError(\n \"Image resolution is not the same as the input resolution.\"\n )\n\n scores = sliced_wasserstein_distance(\n real_x,\n fake,\n resolution_min=self.resolution_min,\n patches_per_image=self.patches_per_image,\n use_svd=self.use_svd,\n patch_size=self.patch_size,\n random_projection_dim=self.random_projection_dim,\n random_sampling_count=self.random_sampling_count,\n )\n\n fake_scores = []\n\n for i, couple in enumerate(scores):\n self.children_real_fake[i][0].update_state(context, couple[0])\n self.children_real_fake[i][1].update_state(context, couple[1])\n fake_scores.append(tf.expand_dims(couple[1], axis=0))\n\n fake_scores = tf.concat(fake_scores, axis=0)\n\n self._distribute_strategy.experimental_run_v2(updater(fake_scores))","def kmeans_006():\n n_centroids_vals = [1000, 2000, 2500, 3000]\n scores = []\n\n for n_centroids in n_centroids_vals:\n s = 15\n crop = 150\n n_patches = 400000\n rf_size = 5\n logger.info(\"Training with n_centroids {}\".format(n_centroids))\n\n train_x_crop_scale = CropScaleImageTransformer(training=True,\n result_path='data/data_train_crop_{}_scale_{}.npy'.format(crop, s),\n crop_size=crop,\n scaled_size=s,\n n_jobs=-1,\n memmap=True)\n test_x_crop_scale = CropScaleImageTransformer(training=False,\n result_path='data/data_test_crop_{}_scale_{}.npy'.format(crop, s),\n crop_size=crop,\n scaled_size=s,\n n_jobs=-1,\n memmap=True)\n\n kmeans_generator = KMeansFeatureGenerator(n_centroids=n_centroids,\n rf_size=rf_size,\n result_path='data/mdl_kmeans_006_centroids_{}'.format(n_centroids),\n n_iterations=20,\n n_jobs=-1,)\n\n patch_extractor = models.KMeansFeatures.PatchSampler(n_patches=n_patches,\n patch_size=rf_size,\n n_jobs=-1)\n images = train_x_crop_scale.transform()\n\n patches = patch_extractor.transform(images)\n\n kmeans_generator.fit(patches)\n\n del patches\n gc.collect()\n\n train_x = kmeans_generator.transform(images, save_to_file='data/data_kmeans_features_006_centroids_{}.npy'.format(n_centroids), memmap=True)\n train_y = classes.train_solutions.data\n # Unload some objects\n del images\n gc.collect()\n\n wrapper = ModelWrapper(models.Ridge.RidgeRFEstimator, {'alpha': 500, 'n_estimators': 250}, n_jobs=-1)\n wrapper.cross_validation(train_x, train_y, n_folds=2, parallel_estimator=True)\n\n score = (n_centroids, wrapper.cv_scores)\n logger.info(\"Scores: {}\".format(score))\n scores.append(score)\n\n del wrapper\n gc.collect()","def update(self):\n stats = self._thread.stats()\n if self._var_id == CONTAINER_MONITOR_STATUS:\n self._state = stats.get('status', None)\n elif self._var_id == CONTAINER_MONITOR_MEMORY_USAGE:\n self._state = stats.get('memory_usage', None)\n elif self._var_id == CONTAINER_MONITOR_CPU_PERCENTAGE:\n self._state = stats.get('cpu_percent', None)\n if 'cpu' in stats:\n self._attributes[ATTR_ONLINE_CPUS] = stats['cpu'].get('online_cpus', None)\n elif self._var_id == CONTAINER_MONITOR_MEMORY_PERCENTAGE:\n self._state = stats.get('memory_percent', None)\n # Network\n elif self._var_id == CONTAINER_MONITOR_NETWORK_UP:\n self._state = round(stats.get('network_up', None) / 1024.0, PRECISION)\n elif self._var_id == CONTAINER_MONITOR_NETWORK_DOWN:\n self._state = round(stats.get('network_down', None) / 1024.0, PRECISION)","def updateall(self, params):\n for gauge in self.gauges:\n self.safexec(gauge.updateall, params)","def update_job_state(self, job):","def train_clustermodel_nonsparse(self):\n \n segtimes_df, nonsparse_matrix = self.create_nonsparse_matrix(self.data)\n segtimes_df['index']=segtimes_df.index\n nonsparse_matrix['index']=nonsparse_matrix.index\n data_to_scale = pd.merge(segtimes_df, nonsparse_matrix, on=['index'])\n data_scaled = self.scale_matrix(data_to_scale)\n data_to_cluster = data_scaled.drop(columns = ['segment_id','level_0','date','time'])\n \n print('Clustering using nonsparse segment/time matrix and: ' + self.algorithm)\n clusterer = self.clustering_algorithms[self.algorithm]\n self.clustering_model = clusterer.fit(data_to_cluster)\n \n clusters_df = pd.DataFrame(self.clustering_model.labels_, columns = ['cluster_nonsparse'])\n clusters_df['segtimekey'] = clusters_df.index\n segtimes_df['segtimekey'] = segtimes_df.index\n clusters_df = clusters_df.reset_index(drop=True)\n self.clusters_df_final = pd.merge(segtimes_df, clusters_df, on=['segtimekey'])\n self.clusters_df_final['cluster_nonsparse'].value_counts()\n \n today = datetime.date.today()\n filename = self.algorithm + '_nonsparse_cluster_model_' + today.strftime('%Y%m%d') + '.pkl'\n joblib.dump(self.clustering_model, filename)\n \n print('Stored ' + filename)\n \n return self.clustering_model, self.clusters_df_final[['segment_id','date','time','cluster_nonsparse']]","def set_cpus(core_str, **kwargs):\n online_cores = osutil.parse_cpus(core_str)\n offline_cores = POSSIBLE_CPUS - online_cores\n for online in online_cores:\n set_cpu(online, True, **kwargs)\n for offline in offline_cores:\n set_cpu(offline, False, **kwargs)","def update_concentrations_batch(self): \n #--- Update the cell concentrations ---\n # dX_i/dt = mu_i*(1-rmp/100)*X_i*(1 - sum(i,(1-rmp/100)X(i))/carrying_capacity) or \n # (X_i(t+dt) - X_i(t))/dt = mu*(1-rmp/100)*X_i(t)*(1 - sum(i,(1-rmp/100)*X_i(t))/carrying_capacity)\n # where rmp is the random mortality percentage\n # If concentration is negative set it to zero\n members_gDW_per_ml_total = sum([(1 - self.random_mortality_percentage/100)*member.organism.gDW_per_ml[self._t] for member in self.community_members])\n self._logisticG_factor_gDW_per_ml = 1 - members_gDW_per_ml_total/self.carrying_capacity['gDW_per_ml']\n if len([member for member in self.community_members if member.organism.cells_per_ml != None]) == len(self.community_members):\n members_cells_per_ml_total = sum([(1 - self.random_mortality_percentage/100)*member.organism.cells_per_ml[self._t] for member in self.community_members])\n self._logisticG_factor_cells_per_ml = 1 - members_cells_per_ml_total/self.carrying_capacity['cells_per_ml']\n\n for member in self.community_members:\n # We always need gDW_per_ml to update compound concentrations but\n # providing cells_per_ml is optional\n member.organism.gDW_per_ml[self._t + self._dt] = max(member.organism.mu[self._t]*(1-self.random_mortality_percentage/100)*member.organism.gDW_per_ml[self._t]*self._logisticG_factor_gDW_per_ml*self._dt + member.organism.gDW_per_ml[self._t],0)\n\n if member.organism.cells_per_ml is not None:\n member.organism.cells_per_ml[self._t + self._dt] = max(member.organism.mu[self._t]*(1 - self.random_mortality_percentage/100)*member.organism.cells_per_ml[self._t]*self._logisticG_factor_cells_per_ml*self._dt + member.organism.cells_per_ml[self._t],0)\n\n # Total death rate (** newly added for DMMM_mortality **)\n if member.organism.mu[self._t] < 0:\n # In thise case random_mortality_rate has already been incorporated into mu\n # (see DMMM.py)\n member.organism.total_death_rate[self._t] = member.organism.mu[self._t] \n else:\n member.organism.total_death_rate[self._t] = member.organism.random_mortality_rate\n\n\n #--- Update shared compound concentrations ---\n # dC/dt = f where, f = sum(k,v_export_k*X_k) - sum(k,v_uptake_k*X_k) + dead_pool_rate\n # (C(t+dt) - c(t))/dt = sum(k,v_export_k*X_k) - sum(k,v_uptake_k*X_k) + dead_pool \n # where, dead_pool_rate = sum(k,-self.cell_pool_factor*cell_pool_concentration_k*total_death_rate_k*X_k)\n # Here, cell_pool_concentration is the concentration of the compound pool \n # per gDW or per cells, which should have already been assigned to each \n # shared compound. The minus sign is because total_death_rate is negative\n # while dead_pool_rate must be non-negative. Here, self.cell_pool_factor is\n # the factor that should be multiplied by concentration of that compound \n # (this is because sometimes we want to explore how the growth is affected if \n # the cell pool is higher than the ones reported experimentally)\n total_cmps_conc = sum([cmp.concentration[self._t] for cmp in self.shared_compounds])\n self._logisticG_factor_cmps = 1 - total_cmps_conc/self.carrying_capacity['compounds_mM']\n self._f = dict([(cmp,None) for cmp in self.shared_compounds])\n\n if not hasattr(self,'cell_pool_factor'):\n self.cell_pool_factor = 1\n\n for shared_cmp in self.shared_compounds:\n dead_pool_rate = -sum([self.cell_pool_factor*shared_cmp.cell_pool_concentration[member.organism.id]*member.organism.total_death_rate[self._t]*1000*member.organism.gDW_per_ml[self._t] for member in self.community_members])\n if dead_pool_rate < 0:\n raise userError('dead_pool_rate is negative')\n\n f = sum([r.flux[self._t]*1000*r.model.organism.gDW_per_ml[self._t] for r in shared_cmp.reactions]) + dead_pool_rate\n self._f[shared_cmp] = f\n\n conc = f*self._logisticG_factor_cmps*self._dt + shared_cmp.concentration[self._t]\n\n if conc >= 0 or (conc < 0 and abs(conc) <= 1e-9):\n conc = max(conc,0)\n\n shared_cmp.concentration[self._t + self._dt] = conc","def cluster(self):\n logger.debug(\"Beginning feature based clustering on %d clusters.\" % len(self.c2b))\n # Merge the two nearest clusters until we can't.\n #\n while self.mergeNearestClusters():\n pass\n logger.debug(\"After clustering, there are now %d clusters remaining.\" % len(self.c2b))\n return self.c2b.values()","def update_count(self):\n try:\n self._thread_pool_executor.submit(self._update_count_fn)\n except:\n self._logger.exception('Exception caught submitting count metrics update task.')","def update(self, labels, preds):\n labels, preds = check_label_shapes(labels, preds, True)\n\n for label, pred in zip(labels, preds):\n self.metrics.update_binary_stats(label, pred)\n\n if self.average == \"macro\":\n self.sum_metric += self.metrics.fscore\n self.num_inst += 1\n self.metrics.reset_stats()\n else:\n self.sum_metric = self.metrics.fscore * self.metrics.total_examples\n self.num_inst = self.metrics.total_examples"],"string":"[\n \"def update_cores(self):\\n num_cores = 0\\n for job in self.job_list:\\n num_cores += int(job.get_core_info())\\n self.cores_used = num_cores\\n return\",\n \"def cluster_state(self):\\n for ip in set([status.ip for status in self.cluster_status]):\\n yield self.node_state(ip)\",\n \"def update_attr_par(self):\\n\\n # Retrieve all current values\\n self.all_values_temp = nx.get_node_attributes(self.G, 'value')\\n\\n # Calculate all new values\\n new_values_list = Parallel(n_jobs=2)(delayed(self.single_node_update)(i) \\\\\\n for i in range(self.n_v))\\n\\n # # Set list to dict as needed for node update\\n # new_values_dict = {}\\n # for i, value in enumerate(new_values_list):\\n # new_values_dict[i] = {'value': value}\\n #\\n # # Update node value\\n # nx.set_node_attributes(self.G, new_values_dict)\",\n \"def update_cluster_freq(self, state, cpu_id):\\n # For IKS devices cluster changes only possible when\\n # freq changes, for other it is determine by cpu_id.\\n if self.device.scheduler != 'iks':\\n self.current_cluster = self.get_cluster(cpu_id, state)\\n if self.get_state_name(state) == \\\"freqstate\\\":\\n self.current_cluster = self.get_cluster(cpu_id, state)\\n self.current_frequency_of_clusters[self.current_cluster] = state\",\n \"def cores_per_node(self, cores_per_node):\\n\\n self._cores_per_node = cores_per_node\",\n \"def updateClusterInfo(self):\\n self.nPoints = len(self.labels)\\n self.n = len(np.unique(self.labels))\\n self.centers = [ [0.0 for j in range(3)] for i in range(self.n)]\",\n \"def run(self):\\n for i,p in enumerate(self.pairs):\\n self.forPointPair(i)\\n if i % 100000 == 0:\\n print('Percentage Processed: ' + str(round(i * 100 / len(self.pairs), 3)) + '. Existing Cluster Labels: ', len(np.unique(self.labels)))\",\n \"def flush_parse_initialize(self):\\n self.current_cluster = 0\\n self.current_frequency_of_clusters = []\\n self.timestamp = []\\n self.currentstates_of_clusters = []\\n self.state_time_map = {}\\n self.cpuid_time_map = {}\\n self.cpu_freq_time_spent = {}\\n self.cpuids_of_clusters = []\\n self.parse() # Parse trace.txt generated from trace-cmd instrumentation\\n # Initialize the states of each core of clusters and frequency of\\n # each clusters with its minimum freq\\n # cpu_id is assigned for each of clusters.\\n # For IKS devices cpuid remains same in other clusters\\n # and for other it will increment by 1\\n count = 0\\n for cluster, cores_number in enumerate(self.numberofcores_in_cluster):\\n self.currentstates_of_clusters.append([-1 for dummy in range(cores_number)])\\n self.current_frequency_of_clusters.append(self.minimum_frequency_cluster[cluster])\\n if self.device.scheduler == 'iks':\\n self.cpuids_of_clusters.append([j for j in range(cores_number)])\\n else:\\n self.cpuids_of_clusters.append(range(count, count + cores_number))\\n count += cores_number\\n\\n # Initialize the time spent in each state/frequency for each core.\\n for i in range(self.device.number_of_cores * self.multiply_factor):\\n self.cpu_freq_time_spent[\\\"cpu{}\\\".format(i)] = {}\\n for j in self.unique_freq():\\n self.cpu_freq_time_spent[\\\"cpu{}\\\".format(i)][j] = 0\\n # To determine offline -1 state is added\\n offline_value = -1\\n self.cpu_freq_time_spent[\\\"cpu{}\\\".format(i)][offline_value] = 0\\n if 0 not in self.unique_freq():\\n self.cpu_freq_time_spent[\\\"cpu{}\\\".format(i)][0] = 0\",\n \"def update_core_allocations(host, cpu_counts):\\n # Remove any previous assignments\\n for s in range(0, len(host.nodes)):\\n for f in CORE_FUNCTIONS:\\n host.cpu_functions[s][f] = []\\n # Set new assignments\\n for s in range(0, len(host.nodes)):\\n cpu_list = host.cpu_lists[s] if s in host.cpu_lists else []\\n # Reserve for the platform first\\n for i in range(0, cpu_counts[s][constants.PLATFORM_FUNCTION]):\\n host.cpu_functions[s][constants.PLATFORM_FUNCTION].append(\\n cpu_list.pop(0))\\n # Reserve for the vswitch next\\n for i in range(0, cpu_counts[s][constants.VSWITCH_FUNCTION]):\\n host.cpu_functions[s][constants.VSWITCH_FUNCTION].append(\\n cpu_list.pop(0))\\n # Reserve for the shared next\\n for i in range(0, cpu_counts[s][constants.SHARED_FUNCTION]):\\n host.cpu_functions[s][constants.SHARED_FUNCTION].append(\\n cpu_list.pop(0))\\n for i in range(0, cpu_counts[s][constants.ISOLATED_FUNCTION]):\\n host.cpu_functions[s][constants.ISOLATED_FUNCTION].append(\\n cpu_list.pop(0))\\n # Assign the remaining cpus to the default function for this host\\n host.cpu_functions[s][get_default_function(host)] += cpu_list\\n return\",\n \"def update_all_nodes(batchserver_name):\\n server,created = getBatchServer(batchserver_name)\\n if not pbs_data_nodes.has_key(batchserver_name):\\n pbs_data_nodes[batchserver_name] = {'last_update':None, 'nodes':{}}\\n\\n if pbs_data_nodes[batchserver_name]['last_update'] and (datetime.datetime.now()-pbs_data_nodes[batchserver_name]['last_update']).total_seconds()<GlobalConfiguration.objects.get(pk=1).max_lastupdate:\\n logging.debug(\\\"Nodes info is new enough for server: %s\\\" % batchserver_name)\\n print \\\"not updated\\\"\\n return pbs_data_nodes\\n\\n print \\\"updated\\\"\\n\\n conn = pbs.pbs_connect(batchserver_name.encode('iso-8859-1', 'replace'))\\n if conn==-1:\\n logging.error(\\\"Cannot connect to %s - live data will be missing\\\" % server.name)\\n return\\n statnodes = pbs.pbs_statnode(conn, \\\"\\\" , [], \\\"\\\")\\n pbs.pbs_disconnect(conn)\\n\\n for sn in statnodes:\\n node,created = getNode(sn.name, server)\\n attr_dict = dict([ (x.name,x.value) for x in sn.attribs])\\n pbs_data_nodes[batchserver_name]['nodes'][node] = update_one_node_from_pbs_data(node, attr_dict)\\n pbs_data_nodes[batchserver_name]['last_update'] = datetime.datetime.now()\\n\\n return pbs_data_nodes\",\n \"def update_cluster_results(session: Session, project: MasteringProject) -> Operation:\\n op = _update_cluster_results_async(session, project)\\n return operation.wait(session, op)\",\n \"def update_all_readings(self):\\n\\n # update the reading of all nodes\\n for node_name in self.nodes:\\n\\n # update the readings of all nodes\\n self.nodes[node_name].reading()\\n\\n # once all nodes have updated, they can be stabilized\\n for node_name in self.nodes:\\n\\n self.nodes[node_name].stabilize()\",\n \"def updateNodeStates (self,listAtoms):\\r\\n \\r\\n for i in range(len(listAtoms)):\\r\\n for j in range(len(listAtoms[i].nodeArray)):\\r\\n self.mol[i].nodeArray[j].state = listAtoms[i].nodeArray[j].state\",\n \"def compute(self):\\n # some possible parameters:\\n # minimum size: min node count for a cluster\\n # (should be small, or some fraction of total graph size)\\n # num splits: desired number of resultant partitions. Partitioning will continue until there are no more \\\"parallelizing splits\\\", or the total partition count is >= num splits\\n minSplits = 3\\n clustermetalist = []\\n (roots, inters) = self.rootSplit(self.cluster)\\n clustermetalist.append(roots)\\n if (len(roots) + len(inters)) < minSplits:\\n # split intersects.\\n inters = map(self.rootSplit, inters)\\n clustermetalist.append(inters[0])\\n clustermetalist.append(inters[1])\\n else:\\n clustermetalist.append(inters)\\n \\n print \\\"nodes\\\", len(self.cluster)\\n print \\\"roots\\\", len(roots)\\n self.ready = clustermetalist\\n # The metalist is a list of lists of clusters.\\n # list[0] is a list of clusters that are ready for execution.\\n # list[1] is a list of clusters that are ready after all clusters\\n # in list[0] are complete. Some or all clusters may be ready\\n # earlier, but each cluster requires some finite progress in one\\n # or more clusters in list[0], otherwise the cluster could be\\n # placed in list[0].\\n # list[i+1] is related to list[i] similarly as list[1] is related\\n # to list[0]\\n open(\\\"pass1.dot\\\",\\\"w\\\").write(self.makeStateGraph(\\\"pass1\\\",roots))\\n pass\",\n \"def calc(self):\\n self.proc_blocks = [cluster.cells for cluster in self.clusters]\\n self.cell_loads = [sum([len(cell) for cell in self.proc_blocks])]\\n self.particle_loads = [cluster.np for cluster in self.clusters]\\n self.imbalance = LoadBalancer.get_load_imbalance(self.particle_loads)\",\n \"def update_state(fun):\\n def wrapper(*args):\\n t1 = time.time()\\n files_processed, datasets = fun(*args)\\n for dataset in datasets:\\n dataset.files_processed += files_processed\\n dataset.update_state(args[1], t1)\\n return wrapper\",\n \"def _recalculate_centroids(self):\\n\\n self._prev_centroids = dict(self.centroids)\\n for cluster in self.clusters:\\n self.centroids[cluster] = np.average(self.clusters[cluster], axis=0)\",\n \"def update_all(self):\\n self.update_head_node_ip()\\n self.get_database_info()\\n self.update_users()\",\n \"def cluster_bal_iter(self):\\n # moving\\n for j,cluster in enumerate(self.clusters):\\n cluster.move()\\n self.clusters_allocate_cells()\\n for j,cluster in enumerate(self.clusters):\\n cluster.calc()\\n #print j, '\\\\t', cluster.center, '\\\\t', cluster.np, '\\\\t', cluster.size\\n \\n # resizing\\n for j,cluster in enumerate(self.clusters):\\n cluster.resize()\\n self.clusters_allocate_cells()\\n for j,cluster in enumerate(self.clusters):\\n cluster.calc()\\n #print j, '\\\\t', cluster.center, '\\\\t', cluster.np, '\\\\t', cluster.size\\n \\n self.calc()\",\n \"def update(self):\\n for uid, server in self.servers_online.items():\\n if len(server.jobs):\\n self.populate_server(server)\\n for uid, server in self.servers_online.items():\\n if server.jobs:\\n server.jobs[0].task_time -= time_interval\\n server.waiting_time -= time_interval\\n if server.jobs[0].task_time <= 0:\\n completed_task = server.jobs.pop(0)\\n print(f\\\"Task '{completed_task.description}' completed\\\")\\n self.all_tasks.remove(completed_task)\\n self.servers_jobs_list[uid].pop(0)\\n for uid, server in self.all_servers.items():\\n if server.status:\\n print(f\\\"{server.server_name} has {len(set(server.jobs))} job(s)\\\")\\n else:\\n print(f\\\"{server.server_name} is offline\\\")\",\n \"def compute_updates(self, xs, gs, state=None):\\n raise NotImplementedError()\",\n \"def set_cores(self, cores):\\n self.cores = cores\\n return\",\n \"def _update_output_states(self, runtime_params=None, time_scale=None, context=None):\\n for i in range(len(self.outputStates)):\\n state = list(self.outputStates.values())[i]\\n state.update(params=runtime_params, time_scale=time_scale, context=context)\\n # self.outputValue[i] = state.value\\n\\n # Assign value of each outputState to corresponding item in self.outputValue\\n self.outputValue = list(state.value for state in list(self.outputStates.values()))\",\n \"def cluster_shutdown():\\n map(shutdown, cluster)\",\n \"def init_cpu_counts(host):\\n host.cpu_functions = {}\\n host.cpu_lists = {}\\n for s in range(0, len(host.nodes)):\\n host.cpu_functions[s] = {}\\n for f in CORE_FUNCTIONS:\\n host.cpu_functions[s][f] = []\\n host.cpu_lists[s] = []\",\n \"def update_state(self, **kwargs):\\n\\n for name in self.metrics:\\n\\n metric = self.metrics[name]\\n\\n argspec = inspect.getfullargspec(metric.update_state)\\n\\n kwargs_to_pass = {k: kwargs[k] for k in kwargs if k in argspec.args}\\n\\n metric.update_state(**kwargs_to_pass)\",\n \"def update_cluster_hosts(self, hosts):\\n self._hosts = hosts\\n self._collect_hosts_d = True\",\n \"def update_cluster(self, cluster, params, *args, **kwargs):\\n raise NotImplementedError\",\n \"def start(self):\\n\\t\\tself.distributedVarPart()\\n\\t\\twhile self.t < self.T:\\n\\t\\t\\tself.t += 1\\n\\t\\t\\tfor cluster in self.clusterList:\\n\\t\\t\\t\\tprint(\\\"cluster: \\\")\\n\\t\\t\\t\\tprint(cluster)\\n\\t\\t\\t\\tprint(self.clusterList[cluster])\\n\\t\\t\\t\\tself.C[cluster] = self.average_consensus(self.clusterList[cluster])\\n\\t\\t\\tprint(self.C)\\n\\t\\t\\tprint(\\\"turn t=%s: Centroids%s\\\"% (self.t, self.C), flush=True)\\n\\t\\t\\ttime.sleep(1)\",\n \"def _nthreads_update(self):\\n self.inputs.environ[\\\"OMP_NUM_THREADS\\\"] = \\\"%d\\\" % self.inputs.num_threads\",\n \"def _update_all_tasks(self) -> None:\\n for task in self.tasks:\\n task.update()\",\n \"def cores_per_node(self):\\n return self.cores_per_socket * self.sockets_per_node\",\n \"def updateList(self):\\n for state in list_:\\n state.update(True)\",\n \"def updateState(self):\\n self.state = self.microgridPolicy.computeState();\",\n \"def progressUpdate(clusterid):\\n progress_update.updateProgress(clusterid)\",\n \"def run(self):\\n for msr in self.msrs:\\n # find state transition matrix\\n phi_p, state_prop = self._compute_stm(msr.time)\\n\\n # use stm to propagate perturbation and covariance\\n cov_m = np.matmul(phi_p, np.matmul(self.cov_list[-1],\\n np.transpose(phi_p)))\\n\\n # compute observation deviation, obs_state matrix\\n y_i, h_tilde = self._msr_resid(msr, state_prop)\\n\\n # calculate kalman gain\\n k_gain = self._calc_k_gain(cov_m, h_tilde, msr.cov)\\n\\n # measurement update\\n cov_p, state_est = self._measurement_update(y_i,\\n h_tilde,\\n k_gain,\\n cov_m,\\n state_prop)\\n\\n # update the state lists\\n self.residuals.append(y_i)\\n self.prop_state_list.append(state_est)\\n self.estimates.append(state_est)\\n self.cov_list.append(cov_p)\\n self.times.append(msr.time)\",\n \"def _update_running_nodes(self) -> None:\\n with self._running_node_lock:\\n try:\\n (ping_nodes, _) = rosnode.rosnode_ping_all()\\n except Exception:\\n logging.error(\\\"[NodeMonitor]: Rosnode threw exception. Master node could be dead\\\")\\n ping_nodes = list()\\n\\n # Since the monitor node is empty, defaulting to monitoring all nodes\\n if not self._monitor_nodes:\\n self._seen_nodes = set(ping_nodes)\\n self._running_nodes = set(ping_nodes)\\n else:\\n current_running_nodes = set()\\n for node in ping_nodes:\\n if self._is_monitor_node(node):\\n # Update seen nodes if node regex matches monitor nodes\\n if node not in self._seen_nodes:\\n self._seen_nodes.add(node)\\n # Add to current running nodes\\n current_running_nodes.add(node)\\n self._running_nodes = current_running_nodes\",\n \"def update_nodes(self):\\n raise NotImplementedError('ERROR: sweeper has to implement update_nodes(self)')\",\n \"def update_state(self):\\n\\n # Start off assuming no space in the queues and no pointer to a\\n # shortest queue.\\n self.min_queue = None\\n self.has_space_in_a_server_queue = False\\n self.queue_size = 0\\n self.online_server_count = 0\\n\\n # Loop through all the servers.\\n for server in self.server_list:\\n\\n # If server is online....\\n if server.online is True:\\n\\n # Increment count of online servers\\n self.online_server_count += 1\\n\\n # If any server has space...\\n if len(server.queue) < server.max_queue_size:\\n\\n # 'Has Space' is True and remains true.\\n if self.has_space_in_a_server_queue is False:\\n self.has_space_in_a_server_queue = True\\n\\n # First non-full server we come to.\\n if self.min_queue is None:\\n self.min_queue = server\\n\\n # If we already had a non-full queue in hand,\\n # compare it to the present one.\\n elif len(server.queue) < len(self.min_queue.queue):\\n self.min_queue = server\\n\\n # Increment the count of the parallel server block.\\n self.queue_size += len(server.queue)\",\n \"def update_status(self):\\n\\n # first get the instances we need to check\\n monitor_jobs = {}\\n for _, job_node in self.get_executions_iterator():\\n if job_node.is_job:\\n for job_instance in job_node.instances:\\n if not job_instance.simulate:\\n if job_instance.host in monitor_jobs:\\n monitor_jobs[job_instance.host]['names'].append(\\n job_instance.name)\\n else:\\n monitor_jobs[job_instance.host] = {\\n 'config': job_instance.monitor_config,\\n 'type': job_instance.monitor_type,\\n 'workdir': job_instance.workdir,\\n 'names': [job_instance.name],\\n 'period': job_instance.monitor_period\\n }\\n else:\\n job_instance.set_status('COMPLETED')\\n\\n # nothing to do if we don't have nothing to monitor\\n if not monitor_jobs:\\n return\\n\\n # then look for the status of the instances through its name\\n states = self.jobs_requester.request(monitor_jobs, self.logger)\\n\\n # finally set job status\\n for inst_name, state in states.iteritems():\\n self.job_instances_map[inst_name].set_status(state)\\n\\n # We wait to slow down the loop\\n sys.stdout.flush() # necessary to output work properly with sleep\\n time.sleep(LOOP_PERIOD)\",\n \"def test_update_hyperflex_cluster(self):\\n pass\",\n \"def check_cores(self):\\n\\n cores = []\\n # Execute command to check for cores\\n header = [\\\"VDC\\\", \\\"Module\\\", \\\"Instance\\\",\\n \\\"Process-name\\\", \\\"PID\\\", \\\"Date\\\\(Year-Month-Day Time\\\\)\\\"]\\n\\n if self.device.alias == 'uut':\\n # In case of restarting process on a the main VDC\\n output = oper_fill_tabular(device=self.device,\\n show_command='show cores vdc-all',\\n header_fields=header, index=[5])\\n else:\\n # In case of restarting process on a sub-VDC\\n self.device.disconnect()\\n output = oper_fill_tabular(device=self.device,\\n show_command='show cores',\\n header_fields=header, index=[5])\\n\\n if not output.entries:\\n log.info('No core found')\\n return []\\n\\n # Parse through output to collect core information (if any)\\n for k in sorted(output.entries.keys(), reverse=True):\\n row = output.entries[k]\\n date = row.get(\\\"Date\\\\(Year-Month-Day Time\\\\)\\\", None)\\n if not date:\\n continue\\n date_ = datetime.strptime(date, '%Y-%m-%d %H:%M:%S')\\n\\n # Save core info\\n core_info = dict(module=row['Module'],\\n pid=row['PID'],\\n instance=row['Instance'],\\n process=row['Process-name'],\\n date=date.replace(\\\" \\\", \\\"_\\\"))\\n cores.append(core_info)\\n\\n return cores\",\n \"def update(self):\\n self.cpus_current = psutil.cpu_percent(percpu=True)\\n assert len(self.cpus_current) == len(self.cpus)\\n return self.cpus_current\",\n \"def multiClusterAlgorithm(values):\\n clusterMap = dict()\\n # Lowest unixtime in the values list\\n startUnixtime = values[0][0]\\n # Separate values into separate clusters in the map, clusterMap\\n for value in values:\\n if value[2] not in clusterMap.keys():\\n clusterMap[value[2]] = []\\n clusterMap[value[2]].append(value)\\n \\n # An array of the predicted values per cluster\\n clusterPredicted = []\\n # An array of unixtime averages per cluster\\n unixtimeAverage = []\\n \\n # Generate predicted value for each cluster using a weighted average\\n # Adds predicted value for each cluster to clusterPredicted and adds\\n # the unixtime average for each cluster to unixtimeAverage\\n for key in clusterMap.keys():\\n clusterLength = len(clusterMap[key]) \\n totalUnixtime = sum([elem[0] for elem in clusterMap[key]])\\n unixtimeAverage.append(float(totalUnixtime) / float(clusterLength))\\n \\n clusterLight = [elem[1] for elem in clusterMap[key]]\\n\\n totalDistanceFromStart = sum([elem[0] - startUnixtime for elem in clusterMap[key]])\\n clusterWeightValues = [float(elem[0] - startUnixtime) / float(totalDistanceFromStart) for elem in clusterMap[key]]\\n \\n predicted = np.average(clusterLight, weights = clusterWeightValues)\\n clusterPredicted.append(predicted)\\n \\n print clusterPredicted\\n total = sum([elem - startUnixtime for elem in unixtimeAverage])\\n # Create weighted values based on unixtime average per cluster\\n weightValues = [float(elem - startUnixtime) / float(total) for elem in unixtimeAverage]\\n print weightValues\\n # Return a weighted average across clusters\\n return np.average(clusterPredicted, weights = weightValues)\",\n \"def update_all_states(self):\\n \\n for l in range(0,4):\\n temp_s = \\\"/loop/{}/mode\\\".format(l+1) # stupid using loop 1 to 4\\n temp_m = self.loop_modes[self.loop_states[l]]\\n self.osc_client.send_message(temp_s,temp_m)\\n print(\\\"sent_message {} {}\\\".format(temp_s,temp_m))\\n self.set_loop_led(l)\\n \\n for l in range(0,4):\\n for s in range(0,8):\\n temp_s = self.osc_slice_string.format(l+1,s)\\n temp_m = self.slice_modes[self.slice_states[l][s] ]\\n self.osc_client.send_message(temp_s,temp_m)\\n print(\\\"sent message {} {}\\\".format(temp_s, temp_m))\\n self.set_slice_led(l,s)\\n return\",\n \"def update(self, iterable):\\n self._update_nodes(iterable)\",\n \"def _update_clusters(partial, to_update, grids):\\n df, settings = partial\\n clusters = settings['clusters']\\n primary_key = settings['idCol']\\n cluster_id = settings['predCol']\\n column = settings['feature']\\n init, end, end2 = grids\\n\\n if len(df) > 0:\\n tmp = df.apply(lambda row: _inblock(row, column, init, end2), axis=1)\\n df = df.loc[tmp]\\n df.drop_duplicates([primary_key], inplace=False, ignore_index=True)\\n\\n for key in to_update:\\n if key in clusters:\\n df.loc[df[cluster_id] == key, cluster_id] = to_update[key]\\n\\n df.loc[df[cluster_id].str.contains(\\\"-0\\\", na=False), cluster_id] = -1\\n df = df.drop([primary_key], axis=1)\\n\\n return df\",\n \"def _compute_centroids(self):\\n\\n for i in range(0, self.k):\\n cluster = np.argwhere(self.assigned_clusters == i)\\n cluster_points = self.data[cluster].squeeze()\\n self.centroids[i] = np.mean(cluster_points, axis=0)\",\n \"def __update_task(self, tasks, **extra_args):\\n for task in tasks:\\n assert isinstance(\\n task, Task), \\\"Core.update_job_state: passed an argument\\\" \\\\\\n \\\" which is not a `Task` instance.\\\"\\n task.update_state()\",\n \"def cluster_reboot(cluster):\\n map(reboot, cluster)\",\n \"async def update_series(self):\\n log.info('Updating all series')\\n await self.updater.update_series()\\n log.info('Done updating all series')\",\n \"def update_all_agent(self):\\n for a in self.agents:\\n soft_update(a.target_actor, a.actor, self.tau)\\n soft_update(a.target_critic, a.critic, self.tau)\\n self.num_iteration += 1\",\n \"def test_setting_state_parallel(self):\\n no_replicates = 25\\n\\n replicate(experiment, no_replicates, parallel=True, no_processes=2)\\n for i in range(no_replicates):\\n self.assertIn('result', state[SUBSTATE_KEY_PATTERN % i])\\n self.assertEqual(state[SUBSTATE_KEY_PATTERN % i]['result'], \\\"bla\\\")\",\n \"def submit_cpucores():\\n # TODO(soltesz): move static value to an external, inventory table.\\n submit_generic(_root_hostname, 'cpu_cores', 'gauge', _CPU_COUNT)\",\n \"def incrementTimers(self):\\n # online servers\\n for server in self.online_servers:\\n self.online_servers[server][0] += 1\\n # offline servers\\n for server in self.offline_servers:\\n self.offline_servers[server][0] += 1\\n \\n return\",\n \"def compute_cluster_metrics(self, event_index: int, timestamp: datetime, cp_count: int,\\n normal_clusters: Tuple[List[List], List[List]], o_clusters: List[Cluster]) -> None:\\n c_clusters, p_clusters = normal_clusters[0], normal_clusters[1]\\n for group in c_clusters:\\n for cluster in group:\\n self.compute_cluster_metrics_helper(event_index, timestamp, cp_count, cluster, 'core micro-cluster')\\n\\n for group in p_clusters:\\n for cluster in group:\\n self.compute_cluster_metrics_helper(event_index, timestamp, cp_count, cluster, 'potential micro-cluster')\\n\\n for cluster in o_clusters:\\n self.compute_cluster_metrics_helper(event_index, timestamp, cp_count, cluster, 'outlier micro-cluster')\",\n \"def update_state(self):\\n self.reset_state()\\n for piece in self.pieces:\\n coordinates = piece.get_block_positions()\\n for coor in coordinates:\\n x, y = coor\\n self.state[y][x] = piece\",\n \"def update(self, clusters):\\n centroids = {}\\n for cluster, coordinates in clusters.iteritems():\\n sumLat = 0\\n sumLong = 0\\n for coordinate in coordinates:\\n sumLat += float(coordinate[0])\\n sumLong += float(coordinate[1])\\n centroids[cluster] = (sumLat/float(len(coordinates)), sumLong/float(len(coordinates)))\\n return centroids\",\n \"def reset():\\n for cpu_id in POSSIBLE_CPUS:\\n set_cpu(cpu_id, True)\",\n \"def gen_cluster_accuracies():\\n accuracies = {}\\n with Parallel(n_jobs=morphs.parallel.N_JOBS) as parallel:\\n for block_path in morphs.paths.blocks():\\n print(block_path)\\n spikes = morphs.load.ephys_data(block_path, collapse_endpoints=True)\\n\\n if len(spikes[\\\"recording\\\"].unique()) >= 1:\\n template_spikes = spikes[spikes[\\\"stim_id\\\"].isin(list(\\\"abcdefgh\\\"))]\\n assert len(template_spikes) > 0\\n cluster_groups = template_spikes.groupby(\\\"cluster\\\")\\n\\n morph_dims = spikes.morph_dim.unique()\\n morph_dims = morph_dims[~pd.isnull(morph_dims)]\\n morph_dims.sort()\\n\\n max_num_reps = np.max(\\n [\\n len(stim_group.groupby(by=[\\\"recording\\\", \\\"stim_presentation\\\"]))\\n for stim_id, stim_group in template_spikes.groupby(\\\"stim_id\\\")\\n ]\\n )\\n\\n accuracies_list = parallel(\\n delayed(cluster_accuracy)(\\n cluster, cluster_group, morph_dims, max_num_reps\\n )\\n for (cluster, cluster_group) in cluster_groups\\n )\\n\\n accuracies[block_path] = pd.concat(accuracies_list)\\n\\n morphs.paths.PROCESSED_DIR.mkdir(parents=True, exist_ok=True)\\n with open(morphs.paths.ACCURACIES_PKL.as_posix(), \\\"wb\\\") as f:\\n pickle.dump(accuracies, f)\",\n \"def _update(self):\\n # clear group before rebuild\\n self.clear()\\n\\n # build configuration groups\\n self._config_names = []\\n for i in range(self._n_configs):\\n config_name = f\\\"config{i+1:02}\\\"\\n self._config_names.append(config_name)\\n self._build_config_group(config_name)\\n\\n # reset active configuration if necessary\\n if not all(cname in self._config_names for cname in self._active_config):\\n self._active_config = (self._config_names[0],)\\n\\n # build datasets\\n self._build_datasets()\",\n \"async def update_all_servers(self):\\n await self.updater.update_all_servers()\",\n \"def update_all(self, message_func=\\\"default\\\",\\n reduce_func=\\\"default\\\",\\n apply_node_func=\\\"default\\\"):\\n num_worker_nodes = int(self.number_of_nodes() / self.num_workers) + 1\\n start_node = self.worker_id * num_worker_nodes\\n end_node = min((self.worker_id + 1) * num_worker_nodes, self.number_of_nodes())\\n worker_nodes = np.arange(start_node, end_node, dtype=np.int64)\\n self.pull(worker_nodes, message_func, reduce_func, apply_node_func, inplace=True)\\n self._sync_barrier()\",\n \"def update_states(self) -> None:\\n self.set_states()\\n self.async_write_ha_state()\",\n \"def _update_state(self):\\n if self.state == State.INITIALIZED:\\n print(\\\"Error: runs not yet submitted, no state to retrieve\\\")\\n return\\n elif self.state == State.COMPLETED:\\n # No update is necessary, since nothing changes once the state is COMPLETED.\\n return\\n\\n # First, update the status of all batches.\\n summaries_by_uuid = self.batches_module.get_summaries(self.project)\\n\\n for batch in self.batch_runs:\\n batch.set_state_summary(summaries_by_uuid[batch.get_uuid()])\\n\\n # Then, if the state of this whole batch should be updated, do that.\\n complete = True\\n for b in self.batch_runs:\\n if not b.get_calc_state() in ['COMPLETED', 'FAILED']:\\n complete = False\\n break\\n if complete:\\n self.state = State.COMPLETED\\n\\n self._update_cached_status()\",\n \"def run(self):\\n import time\\n\\n\\n for msr in self.msrs:\\n # find state transition matrix\\n phi_p, state_prop = self._compute_stm(msr.time)\\n\\n # use stm to propagate perturbation and covariance\\n pert_m = np.matmul(phi_p, self.pert_vec[-1])\\n cov_m = np.matmul(phi_p, np.matmul(self.cov_list[-1],\\n np.transpose(phi_p)))\\n\\n\\n # compute observation deviation, obs_state matrix\\n y_i, h_tilde = self._msr_resid(msr, state_prop)\\n\\n # calculate kalman gain\\n k_gain = self._calc_k_gain(cov_m, h_tilde, msr.cov)\\n\\n # measurement update\\n cov_p, pert_p = self._measurement_update(y_i,\\n h_tilde,\\n pert_m,\\n k_gain,\\n cov_m)\\n\\n # update the state lists\\n self.residuals.append(y_i)\\n self.prop_state_list.append(state_prop)\\n self.estimates.append(np.add(state_prop, np.transpose(pert_p))[0])\\n self.cov_list.append(cov_p)\\n self.pert_vec.append(pert_p)\\n self.times.append(msr.time)\",\n \"def update_current_state(self, agent_num):\\n for task_num, i in enumerate(self.tasks):\\n current_task_data = []\\n task_loc = i.getloc()\\n vectorized_task_loc = self.get_vectorized_location(task_loc)\\n current_task_data.append(self.t)\\n current_task_data.append(self.w_EDR)\\n current_task_data.append(self.w_RESOURCE)\\n current_task_data.append(self.w_DISTANCE)\\n current_task_data.append(agent_num)\\n\\n current_task_data.append(task_num)\\n current_task_data.extend(self.is_agent_idle[agent_num]) # Feature 6\\n current_task_data.append((self.is_task_finished[0][task_num])) # Feature 2\\n current_task_data.append((self.is_task_enabled[0][task_num])) # Feature 3\\n current_task_data.append((self.is_task_alive[0][task_num])) # Feature 4\\n current_task_data.append((self.travel_time_constraint_satisfied[agent_num][task_num])) # Feature 5\\n is_occupied = self.agent_locations[0][vectorized_task_loc] # if 1 agent is there, 0 is unoccupied\\n current_task_data.append((is_occupied)) # Feature 1\\n current_task_data.append((self.agent_distances[agent_num][task_num])) # Feature 7\\n current_task_data.append((self.orientation[agent_num][task_num])) # Feature 9\\n current_task_data.append((self.task_deadlines[0][task_num])) # Feature 10\\n current_task_data.append((self.is_task_in_progress[0][task_num])) # Feature 11\\n current_task_data.append((\\n self.orientation[agent_num][task_num] * self.agent_distances[agent_num][task_num])) # Feature 12\\n current_task_data.append((self.how_many_tasks_in_each_square[0][vectorized_task_loc])) # Feature 8\\n if self.task_to_schedule == -1:\\n null_task = 1\\n else:\\n null_task = 0\\n current_task_data.append(null_task)\\n current_task_data.append(-7) # This is not really needed, but I'll add in -7 as a bs val\\n self.network_state.append(current_task_data)\",\n \"def update(self,x,y):\\n if self.ncores > 1:\\n # parallel updates\\n pass # FIXME\\n else:\\n # sequential updates\\n for tree in self.forest:\\n tree.update(x,y)\",\n \"def restructure_host_cpu_data(host):\\n init_cpu_counts(host)\\n host.sockets = len(host.nodes or [])\\n host.hyperthreading = False\\n host.physical_cores = 0\\n if not host.cpus:\\n return\\n host.cpu_model = host.cpus[0].cpu_model\\n cpu_list = sorted(host.cpus, key=_sort_by_coreid)\\n for cpu in cpu_list:\\n inode = pecan.request.dbapi.inode_get(inode_id=cpu.forinodeid)\\n cpu.numa_node = inode.numa_node\\n if cpu.thread == 0:\\n host.physical_cores += 1\\n elif cpu.thread > 0:\\n host.hyperthreading = True\\n function = cpu.allocated_function or get_default_function(host)\\n host.cpu_functions[cpu.numa_node][function].append(int(cpu.cpu))\\n host.cpu_lists[cpu.numa_node].append(int(cpu.cpu))\",\n \"def refresh_node_status(self):\\n\\n for node in Node.values():\\n del Node[node.name]\\n\\n status_command = {\\\"command\\\": \\\"UPDATE_STATUS\\\"}\\n publish_command(\\n redis_connection(),\\n all_nodes_channel_name(),\\n status_command)\",\n \"def _train_loop(self, X, update_counter, context_mask):\\n\\n epoch = 0\\n prev_activation = np.zeros((self.map_dim, self.data_dim))\\n influences, learning_rates = self._param_update(0, len(update_counter))\\n\\n for idx, x in enumerate(progressbar(X)):\\n\\n prev_activation = self._example(x, influences, prev_activation=prev_activation)\\n\\n if idx in update_counter:\\n\\n epoch += 1\\n influences, learning_rate = self._param_update(epoch, len(update_counter))\\n\\n if idx in context_mask:\\n\\n prev_activation = np.zeros((self.map_dim, self.data_dim))\",\n \"def cache_thetas_multicore(eta, povs, n_cores, start=0, stop=(len(adjusted_adj_list_4.keys())-1)):\\n import os\\n import multiprocessing\\n processes=[]\\n for x in range(n_cores):\\n theta_lists = adjusted_adj_list_4.keys()[start:stop]\\n theta_lists = np.array_split(theta_lists, n_cores)\\n p = multiprocessing.Process(target=cache_thetas,\\n args = [eta, povs,theta_lists[x][0],\\n theta_lists[x][-1]])\\n p.start()\\n processes.append(p)\\n for p in processes:\\n p.join()\",\n \"def __init__(self, coresys: CoreSys):\\n self.coresys = coresys\\n self.run = asyncio.Lock()\",\n \"def __init__(self, coresys: CoreSys):\\n self.coresys = coresys\\n self.run = asyncio.Lock()\",\n \"def update(self, iteration):\\n pass\",\n \"def Update(self, ticks=0):\\r\\n for name in self.actors:\\r\\n self.actors[name].Update(ticks=ticks)\",\n \"def update_job_state(self, *tasks, **extra_args):\\n pass\",\n \"def compute_clusters(self, p: float):\\n pass\",\n \"def _update_(self, data):\\n # imports\\n from intervals import Interval, LinkedIntervalSet\\n \\n # create a LinkedIntervalSet to store the time-based states for this\\n # hero\\n states = [Interval(dict((HER_KWD_MAP.get(k, k), d[1][k]) for k in d[1]), d[0]) for d in data]\\n self.states = LinkedIntervalSet.from_starts(states)\",\n \"def automerge_clusters(self):\\n all_clusters = self.get_clusters().copy()\\n\\n if not self._single: # if not in single mode mode\\n # initialize the variable to check if some change has happened \\n changed = False\\n for cl_1 in all_clusters: # cycle over clusters\\n c_c1 = all_clusters[cl_1]\\n for cl_2 in all_clusters: # inner cycle over clusters\\n c_c2 = all_clusters[cl_2]\\n # if two clusters have the same speaker and have different \\n # cluster identifiers\\n if cl_1 != cl_2 and c_c1.get_speaker() != 'unknown' and c_c1.get_speaker() == c_c2.get_speaker() and self._clusters.has_key(cl_1) and self._clusters.has_key(cl_2):\\n changed = True\\n # merge the clusters an record that something changed\\n self._merge_clusters(cl_1, cl_2)\\n if changed: # if something has changed\\n # rename all the clusters starting from S0\\n self._rename_clusters()\\n # remove also the old waves and seg files of the old clusters\\n shutil.rmtree(self.get_file_basename())\\n # rebuild all seg files\\n self.generate_seg_file(set_speakers=False)\\n # resplit the original wave file according to the new clusters\\n self._to_trim()\",\n \"def initClusters(self):\\n if len(self.labelList) != len(self.pointList):\\n \\traise ValueError(\\\"Label List and Point List not the same length!\\\")\\n for i in range(len(self.labelList)):\\n self.centroids[self.labelList[i]] = self.pointList[i]\\n self.pointcounts[self.labelList[i]] = 1\",\n \"def updateRcloneJobStatus():\\n global jobIds, jobStatusGauge\\n\\n # Check if the jobs are running, update the variables\\n for jobName, jobId in jobIds.items():\\n jobIsRunning = getRcloneJobRunning(jobId)\\n jobIds[jobName] = jobId if jobIsRunning else None\\n jobStatusGauge.labels(rclone_job=jobName).set(1 if jobIsRunning else 0)\",\n \"def batch_update(self, parents_classes_dict):\\n print(\\\"Updating the LowerLevelGrid with a batch of examples\\\")\\n for (class_id, coords), examples in parents_classes_dict.items():\\n coords = tuple([int(x / 2) for x in coords])\\n self.hypercubes[coords].update_lower_level(example_class=class_id, example_count=len(examples), threshold=self.threshold)\\n if self.child_grid:\\n self.child_grid.batch_update(parents_classes_dict=parents_classes_dict)\",\n \"def run_evaluation(self, n_runs=1, n_points=1000, n_iterations=1, min_n_components=2, max_n_components=25,\\n\\t\\t\\t\\t\\t n_splits=3, save_data=False, file_label='',n_microstates=None, all_methods=True,\\n\\t\\t\\t\\t\\t assign_transition_points=True):\\n\\n\\t\\tif self.presampled_data is not None:\\n\\t\\t\\tsampled_data = self.presampled_data[0]\\n\\t\\t\\ttrue_clustering = self.presampled_data[1]\\n\\t\\t\\tn_runs = sampled_data.shape[0]\\n\\n\\t\\tself.cluster_score_ami_kmeans_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_ami_AW_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_ami_spectral_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_ami_density_peaks_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_ami_GMM_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_ami_GMM_FE_min_ = np.zeros(n_runs)\\n\\n\\t\\tself.cluster_score_fm_kmeans_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_fm_AW_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_fm_spectral_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_fm_density_peaks_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_fm_GMM_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_fm_GMM_FE_min_ = np.zeros(n_runs)\\n\\n\\t\\tself.cluster_score_vm_kmeans_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_vm_AW_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_vm_spectral_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_vm_density_peaks_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_vm_GMM_ = np.zeros(n_runs)\\n\\t\\tself.cluster_score_vm_GMM_FE_min_ = np.zeros(n_runs)\\n\\n\\t\\tdata = self.toy_model_.sample(3)\\n\\n\\t\\t# Create free energy estimators\\n\\t\\tgmm_FE = GMM_FE.FreeEnergyClustering(data, min_n_components=min_n_components, max_n_components=max_n_components,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t x_lims=self.x_lims_, n_grids=self.n_grids_, stack_landscapes=False,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t n_splits=n_splits, n_iterations=n_iterations,convergence_tol=self.convergence_tol_,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t verbose=self.verbose_)\\n\\n\\t\\tkm = kmc.KMeansCluster(min_n_components, max_n_components)\\n\\t\\taw = awc.AWCluster(min_n_components, max_n_components)\\n\\t\\tspectral = sc.SpectralCluster(min_n_components, max_n_components)\\n\\n\\t\\tall_data = []\\n\\t\\tfor i_run in range(n_runs):\\n\\t\\t\\tprint(\\\"Run: \\\"+str(i_run+1)+'/'+str(n_runs))\\n\\n\\t\\t\\tif self.presampled_data is None:\\n\\t\\t\\t\\t# Sample data\\n\\t\\t\\t\\tdata = self.toy_model_.sample(n_points)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tdata = sampled_data[i_run]\\n\\t\\t\\t\\n\\t\\t\\tall_data.append(data)\\n\\n\\t\\t\\tprint('Shape data: ' + str(data.shape))\\n\\n\\t\\t\\t# Set data in model and estimate GMM density\\n\\t\\t\\tgmm_FE.data_ = data\\n\\t\\t\\tcoords, est_FE_landsc, FE_points = gmm_FE.landscape()\\n\\n\\t\\t\\t# Get true cluster labels\\n\\t\\t\\tif self.presampled_data is None:\\n\\t\\t\\t\\tif hasattr(self.toy_model_, \\\"assign_cluster_labels\\\"):\\n\\t\\t\\t\\t\\tself.true_labels_ = self.toy_model_.assign_cluster_labels(data)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tprint('Setting true labels.')\\n\\t\\t\\t\\t\\tself.true_labels_, _ = self.true_FE_.cluster(data, np.zeros(data.shape[0]))\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.true_labels_ = true_clustering[i_run]\\n\\t\\t\\t\\n\\t\\t\\t# Cluster data with different methods\\n\\t\\t\\tif n_microstates is None:\\n\\t\\t\\t\\tself.FE_min_labels, _ = gmm_FE.cluster(data, FE_points, assign_transition_points=assign_transition_points)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tkmea = KMeans(n_clusters=n_microstates).fit(data[::2])\\n\\t\\t\\t\\tmicrostate_centers = kmea.cluster_centers_\\n\\t\\t\\t\\tself.FE_min_labels, _ = gmm_FE.cluster(microstate_centers, FE_points, data, assign_transition_points=assign_transition_points, unravel_grid=False)\\n\\n\\t\\t\\tif all_methods:\\n\\t\\t\\t\\tself.km_labels = km.cluster(data)\\n\\t\\t\\t\\tself.aw_labels = aw.cluster(data)\\n\\t\\t\\t\\tself.spectral_labels = spectral.cluster(data)\\n\\n\\t\\t\\t# Score clustering using different scoring metrics\\n\\t\\t\\t# V-measure score\\n\\t\\t\\tself.cluster_score_vm_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'vm')\\n\\t\\t\\tprint(self.cluster_score_vm_GMM_FE_min_[i_run])\\n\\t\\t\\tif all_methods:\\n\\t\\t\\t\\tself.cluster_score_vm_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'vm')\\n\\t\\t\\t\\tself.cluster_score_vm_kmeans_[i_run] = self._score_clustering(self.km_labels,'vm')\\n\\t\\t\\t\\tself.cluster_score_vm_AW_[i_run] = self._score_clustering(self.aw_labels,'vm')\\n\\t\\t\\t\\tself.cluster_score_vm_spectral_[i_run] = self._score_clustering(self.spectral_labels,'vm')\\n\\n\\t\\t\\t\\t# Adjusted MI\\n\\t\\t\\t\\tself.cluster_score_ami_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'ami')\\n\\t\\t\\t\\tself.cluster_score_ami_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'ami')\\n\\t\\t\\t\\tself.cluster_score_ami_kmeans_[i_run] = self._score_clustering(self.km_labels,'ami')\\n\\t\\t\\t\\tself.cluster_score_ami_AW_[i_run] = self._score_clustering(self.aw_labels,'ami')\\n\\t\\t\\t\\tself.cluster_score_ami_spectral_[i_run] = self._score_clustering(self.spectral_labels,'ami')\\n\\n\\t\\t\\t\\t# Fowlkes Mallows\\n\\t\\t\\t\\tself.cluster_score_fm_GMM_FE_min_[i_run] = self._score_clustering(self.FE_min_labels,'fm')\\n\\t\\t\\t\\tself.cluster_score_fm_GMM_[i_run] = self._score_clustering(gmm_FE.density_est_.predict(data),'fm')\\n\\t\\t\\t\\tself.cluster_score_fm_kmeans_[i_run] = self._score_clustering(self.km_labels,'fm')\\n\\t\\t\\t\\tself.cluster_score_fm_AW_[i_run] = self._score_clustering(self.aw_labels,'fm')\\n\\t\\t\\t\\tself.cluster_score_fm_spectral_[i_run] = self._score_clustering(self.spectral_labels,'fm')\\n\\t\\t\\n\\t\\tif save_data:\\n\\t\\t\\tif self.presampled_data is None:\\n\\t\\t\\t\\tnp.save('data_out/sampled_data_'+self.toy_model_.name+file_label+'.npy',all_data)\\n\\n\\t\\t\\tif False:\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_fm_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_fm_GMM_FE_min_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_fm_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_GMM_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_fm_kmeans_' + self.toy_model_.name +file_label +'.npy', self.cluster_score_fm_kmeans_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_fm_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_AW_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_fm_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_fm_spectral_)\\n\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_ami_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_ami_GMM_FE_min_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_ami_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_GMM_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_ami_kmeans_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_kmeans_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_ami_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_AW_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_ami_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_ami_spectral_)\\n\\n\\t\\t\\tnp.save('data_out/cluster_score_vm_FE_min_'+self.toy_model_.name+file_label+'.npy',self.cluster_score_vm_GMM_FE_min_)\\n\\t\\t\\tif all_methods:\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_vm_GMM_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_GMM_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_vm_kmeans_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_kmeans_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_vm_AW_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_AW_)\\n\\t\\t\\t\\tnp.save('data_out/cluster_score_vm_spectral_' + self.toy_model_.name + file_label+'.npy', self.cluster_score_vm_spectral_)\\n\\t\\treturn\",\n \"def update_state(self, result):\\n for i,k in enumerate(self._current_state.keys()):\\n self._current_state[k] = result[i]\",\n \"def train_workers(self):\\n args = dict(actor=self.actor,\\n critic=self.critic,\\n gamma=self.gamma,\\n lamda=self.lamda or self.gamma / 1.005,\\n device=self.device,\\n optimizers=[self.actor_optimizer, self.critic_optimizer])\\n workers = [Worker(i, self.action_size, self.state_size, **args)\\n for i in range(self.n_workers)\\n ]\\n\\n print(f'Worker count: {len(workers)}')\\n\\n for worker in workers:\\n worker.start()\\n\\n while len(constants.scores) < self.n_steps:\\n time.sleep(400) # save checkpoint every 400 ms\\n\\n print(f'\\\\nCurrent scores: {constants.scores}')\\n\\n self.save(constants.episode)\\n print(f'\\\\nCheckpoint saved at episode: {constants.episode}\\\\n')\",\n \"def update(self):\\n\\n\\t\\tif not self.complete:\\n\\t\\t\\tfor vasp_run in self.vasp_run_list:\\n\\t\\t\\t\\tvasp_run.update()\",\n \"def update_clusters(self, data):\\n\\n self.unassigned_data_updated = [None]\\n cluster_list = []\\n cluster_indices = []\\n bud_list = []\\n bud_indices = []\\n\\n # First of all, seperate buds and clusters\\n for cluster_index, cluster in self.clusters.items():\\n if cluster.number_of_members < self.minnpix_cluster:\\n bud_list.append(cluster)\\n bud_indices.append(cluster_index)\\n else:\\n cluster_list.append(cluster)\\n cluster_indices.append(cluster_index)\\n\\n # Take all of the bud data and put it back into an unassigned list\\n unassigned_data_updated = []\\n for i in range(len(bud_indices)):\\n self.clusters.pop(bud_indices[i])\\n idx = np.squeeze(np.where(self.cluster_arr[1,:] == bud_indices[i]))\\n self.cluster_arr[1,idx] = -1.0\\n unassigned_data_updated.extend(data[:,bud_list[i].cluster_members].T)\\n\\n # Turn that into an array and transpose\\n unassigned_data_updated = np.asarray(unassigned_data_updated)\\n unassigned_data_updated = unassigned_data_updated.T\\n\\n # There shouldn't be any in theory, but just check there are no duplicates\\n try:\\n unassigned_data_updated = np.unique(unassigned_data_updated, axis=1)\\n except ValueError:\\n pass\\n\\n # Sort the unassigned data according to peak intensity and send it back\\n if np.size(unassigned_data_updated) != 0.0:\\n sortidx = argsort(unassigned_data_updated[2,:], reversed=True)\\n self.unassigned_data_updated = unassigned_data_updated[:,sortidx]\\n else:\\n pass\\n\\n return cluster_list, cluster_indices\",\n \"def cluster_cal(self):\\n self.Cluster = []\\n for i in range(self.nodenum):\\n neighborhood_node = self.neighbor_node(i)\\n Node_num = len(neighborhood_node)\\n Count = self.neighbor_edge(neighborhood_node)\\n if(Node_num == 0 or Node_num == 1):\\n self.Cluster.append(0.5)\\n else:\\n self.Cluster.append(Count/(Node_num*(Node_num - 1)))\\n \\n self.cluster_coeff = np.average(self.Cluster)\",\n \"def update_state(self, context: GANContext) -> None:\\n updater = lambda value: lambda: self._metric.update_state(value)\\n for real_xy, noise in context.dataset:\\n real_x, real_y = real_xy\\n\\n g_inputs = noise\\n if len(context.generator_model.inputs) == 2:\\n g_inputs = [noise, real_y]\\n\\n fake = context.generator_model(\\n g_inputs, training=context.log_eval_mode == LogEvalMode.TRAIN\\n )\\n\\n # check the resolution is the same as the one passed as input\\n resolution = real_x.shape[1]\\n if resolution != self.resolution:\\n raise ValueError(\\n \\\"Image resolution is not the same as the input resolution.\\\"\\n )\\n\\n scores = sliced_wasserstein_distance(\\n real_x,\\n fake,\\n resolution_min=self.resolution_min,\\n patches_per_image=self.patches_per_image,\\n use_svd=self.use_svd,\\n patch_size=self.patch_size,\\n random_projection_dim=self.random_projection_dim,\\n random_sampling_count=self.random_sampling_count,\\n )\\n\\n fake_scores = []\\n\\n for i, couple in enumerate(scores):\\n self.children_real_fake[i][0].update_state(context, couple[0])\\n self.children_real_fake[i][1].update_state(context, couple[1])\\n fake_scores.append(tf.expand_dims(couple[1], axis=0))\\n\\n fake_scores = tf.concat(fake_scores, axis=0)\\n\\n self._distribute_strategy.experimental_run_v2(updater(fake_scores))\",\n \"def kmeans_006():\\n n_centroids_vals = [1000, 2000, 2500, 3000]\\n scores = []\\n\\n for n_centroids in n_centroids_vals:\\n s = 15\\n crop = 150\\n n_patches = 400000\\n rf_size = 5\\n logger.info(\\\"Training with n_centroids {}\\\".format(n_centroids))\\n\\n train_x_crop_scale = CropScaleImageTransformer(training=True,\\n result_path='data/data_train_crop_{}_scale_{}.npy'.format(crop, s),\\n crop_size=crop,\\n scaled_size=s,\\n n_jobs=-1,\\n memmap=True)\\n test_x_crop_scale = CropScaleImageTransformer(training=False,\\n result_path='data/data_test_crop_{}_scale_{}.npy'.format(crop, s),\\n crop_size=crop,\\n scaled_size=s,\\n n_jobs=-1,\\n memmap=True)\\n\\n kmeans_generator = KMeansFeatureGenerator(n_centroids=n_centroids,\\n rf_size=rf_size,\\n result_path='data/mdl_kmeans_006_centroids_{}'.format(n_centroids),\\n n_iterations=20,\\n n_jobs=-1,)\\n\\n patch_extractor = models.KMeansFeatures.PatchSampler(n_patches=n_patches,\\n patch_size=rf_size,\\n n_jobs=-1)\\n images = train_x_crop_scale.transform()\\n\\n patches = patch_extractor.transform(images)\\n\\n kmeans_generator.fit(patches)\\n\\n del patches\\n gc.collect()\\n\\n train_x = kmeans_generator.transform(images, save_to_file='data/data_kmeans_features_006_centroids_{}.npy'.format(n_centroids), memmap=True)\\n train_y = classes.train_solutions.data\\n # Unload some objects\\n del images\\n gc.collect()\\n\\n wrapper = ModelWrapper(models.Ridge.RidgeRFEstimator, {'alpha': 500, 'n_estimators': 250}, n_jobs=-1)\\n wrapper.cross_validation(train_x, train_y, n_folds=2, parallel_estimator=True)\\n\\n score = (n_centroids, wrapper.cv_scores)\\n logger.info(\\\"Scores: {}\\\".format(score))\\n scores.append(score)\\n\\n del wrapper\\n gc.collect()\",\n \"def update(self):\\n stats = self._thread.stats()\\n if self._var_id == CONTAINER_MONITOR_STATUS:\\n self._state = stats.get('status', None)\\n elif self._var_id == CONTAINER_MONITOR_MEMORY_USAGE:\\n self._state = stats.get('memory_usage', None)\\n elif self._var_id == CONTAINER_MONITOR_CPU_PERCENTAGE:\\n self._state = stats.get('cpu_percent', None)\\n if 'cpu' in stats:\\n self._attributes[ATTR_ONLINE_CPUS] = stats['cpu'].get('online_cpus', None)\\n elif self._var_id == CONTAINER_MONITOR_MEMORY_PERCENTAGE:\\n self._state = stats.get('memory_percent', None)\\n # Network\\n elif self._var_id == CONTAINER_MONITOR_NETWORK_UP:\\n self._state = round(stats.get('network_up', None) / 1024.0, PRECISION)\\n elif self._var_id == CONTAINER_MONITOR_NETWORK_DOWN:\\n self._state = round(stats.get('network_down', None) / 1024.0, PRECISION)\",\n \"def updateall(self, params):\\n for gauge in self.gauges:\\n self.safexec(gauge.updateall, params)\",\n \"def update_job_state(self, job):\",\n \"def train_clustermodel_nonsparse(self):\\n \\n segtimes_df, nonsparse_matrix = self.create_nonsparse_matrix(self.data)\\n segtimes_df['index']=segtimes_df.index\\n nonsparse_matrix['index']=nonsparse_matrix.index\\n data_to_scale = pd.merge(segtimes_df, nonsparse_matrix, on=['index'])\\n data_scaled = self.scale_matrix(data_to_scale)\\n data_to_cluster = data_scaled.drop(columns = ['segment_id','level_0','date','time'])\\n \\n print('Clustering using nonsparse segment/time matrix and: ' + self.algorithm)\\n clusterer = self.clustering_algorithms[self.algorithm]\\n self.clustering_model = clusterer.fit(data_to_cluster)\\n \\n clusters_df = pd.DataFrame(self.clustering_model.labels_, columns = ['cluster_nonsparse'])\\n clusters_df['segtimekey'] = clusters_df.index\\n segtimes_df['segtimekey'] = segtimes_df.index\\n clusters_df = clusters_df.reset_index(drop=True)\\n self.clusters_df_final = pd.merge(segtimes_df, clusters_df, on=['segtimekey'])\\n self.clusters_df_final['cluster_nonsparse'].value_counts()\\n \\n today = datetime.date.today()\\n filename = self.algorithm + '_nonsparse_cluster_model_' + today.strftime('%Y%m%d') + '.pkl'\\n joblib.dump(self.clustering_model, filename)\\n \\n print('Stored ' + filename)\\n \\n return self.clustering_model, self.clusters_df_final[['segment_id','date','time','cluster_nonsparse']]\",\n \"def set_cpus(core_str, **kwargs):\\n online_cores = osutil.parse_cpus(core_str)\\n offline_cores = POSSIBLE_CPUS - online_cores\\n for online in online_cores:\\n set_cpu(online, True, **kwargs)\\n for offline in offline_cores:\\n set_cpu(offline, False, **kwargs)\",\n \"def update_concentrations_batch(self): \\n #--- Update the cell concentrations ---\\n # dX_i/dt = mu_i*(1-rmp/100)*X_i*(1 - sum(i,(1-rmp/100)X(i))/carrying_capacity) or \\n # (X_i(t+dt) - X_i(t))/dt = mu*(1-rmp/100)*X_i(t)*(1 - sum(i,(1-rmp/100)*X_i(t))/carrying_capacity)\\n # where rmp is the random mortality percentage\\n # If concentration is negative set it to zero\\n members_gDW_per_ml_total = sum([(1 - self.random_mortality_percentage/100)*member.organism.gDW_per_ml[self._t] for member in self.community_members])\\n self._logisticG_factor_gDW_per_ml = 1 - members_gDW_per_ml_total/self.carrying_capacity['gDW_per_ml']\\n if len([member for member in self.community_members if member.organism.cells_per_ml != None]) == len(self.community_members):\\n members_cells_per_ml_total = sum([(1 - self.random_mortality_percentage/100)*member.organism.cells_per_ml[self._t] for member in self.community_members])\\n self._logisticG_factor_cells_per_ml = 1 - members_cells_per_ml_total/self.carrying_capacity['cells_per_ml']\\n\\n for member in self.community_members:\\n # We always need gDW_per_ml to update compound concentrations but\\n # providing cells_per_ml is optional\\n member.organism.gDW_per_ml[self._t + self._dt] = max(member.organism.mu[self._t]*(1-self.random_mortality_percentage/100)*member.organism.gDW_per_ml[self._t]*self._logisticG_factor_gDW_per_ml*self._dt + member.organism.gDW_per_ml[self._t],0)\\n\\n if member.organism.cells_per_ml is not None:\\n member.organism.cells_per_ml[self._t + self._dt] = max(member.organism.mu[self._t]*(1 - self.random_mortality_percentage/100)*member.organism.cells_per_ml[self._t]*self._logisticG_factor_cells_per_ml*self._dt + member.organism.cells_per_ml[self._t],0)\\n\\n # Total death rate (** newly added for DMMM_mortality **)\\n if member.organism.mu[self._t] < 0:\\n # In thise case random_mortality_rate has already been incorporated into mu\\n # (see DMMM.py)\\n member.organism.total_death_rate[self._t] = member.organism.mu[self._t] \\n else:\\n member.organism.total_death_rate[self._t] = member.organism.random_mortality_rate\\n\\n\\n #--- Update shared compound concentrations ---\\n # dC/dt = f where, f = sum(k,v_export_k*X_k) - sum(k,v_uptake_k*X_k) + dead_pool_rate\\n # (C(t+dt) - c(t))/dt = sum(k,v_export_k*X_k) - sum(k,v_uptake_k*X_k) + dead_pool \\n # where, dead_pool_rate = sum(k,-self.cell_pool_factor*cell_pool_concentration_k*total_death_rate_k*X_k)\\n # Here, cell_pool_concentration is the concentration of the compound pool \\n # per gDW or per cells, which should have already been assigned to each \\n # shared compound. The minus sign is because total_death_rate is negative\\n # while dead_pool_rate must be non-negative. Here, self.cell_pool_factor is\\n # the factor that should be multiplied by concentration of that compound \\n # (this is because sometimes we want to explore how the growth is affected if \\n # the cell pool is higher than the ones reported experimentally)\\n total_cmps_conc = sum([cmp.concentration[self._t] for cmp in self.shared_compounds])\\n self._logisticG_factor_cmps = 1 - total_cmps_conc/self.carrying_capacity['compounds_mM']\\n self._f = dict([(cmp,None) for cmp in self.shared_compounds])\\n\\n if not hasattr(self,'cell_pool_factor'):\\n self.cell_pool_factor = 1\\n\\n for shared_cmp in self.shared_compounds:\\n dead_pool_rate = -sum([self.cell_pool_factor*shared_cmp.cell_pool_concentration[member.organism.id]*member.organism.total_death_rate[self._t]*1000*member.organism.gDW_per_ml[self._t] for member in self.community_members])\\n if dead_pool_rate < 0:\\n raise userError('dead_pool_rate is negative')\\n\\n f = sum([r.flux[self._t]*1000*r.model.organism.gDW_per_ml[self._t] for r in shared_cmp.reactions]) + dead_pool_rate\\n self._f[shared_cmp] = f\\n\\n conc = f*self._logisticG_factor_cmps*self._dt + shared_cmp.concentration[self._t]\\n\\n if conc >= 0 or (conc < 0 and abs(conc) <= 1e-9):\\n conc = max(conc,0)\\n\\n shared_cmp.concentration[self._t + self._dt] = conc\",\n \"def cluster(self):\\n logger.debug(\\\"Beginning feature based clustering on %d clusters.\\\" % len(self.c2b))\\n # Merge the two nearest clusters until we can't.\\n #\\n while self.mergeNearestClusters():\\n pass\\n logger.debug(\\\"After clustering, there are now %d clusters remaining.\\\" % len(self.c2b))\\n return self.c2b.values()\",\n \"def update_count(self):\\n try:\\n self._thread_pool_executor.submit(self._update_count_fn)\\n except:\\n self._logger.exception('Exception caught submitting count metrics update task.')\",\n \"def update(self, labels, preds):\\n labels, preds = check_label_shapes(labels, preds, True)\\n\\n for label, pred in zip(labels, preds):\\n self.metrics.update_binary_stats(label, pred)\\n\\n if self.average == \\\"macro\\\":\\n self.sum_metric += self.metrics.fscore\\n self.num_inst += 1\\n self.metrics.reset_stats()\\n else:\\n self.sum_metric = self.metrics.fscore * self.metrics.total_examples\\n self.num_inst = self.metrics.total_examples\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6780373","0.62166446","0.60941476","0.6064973","0.58558685","0.5828296","0.5750417","0.5698166","0.559145","0.55552137","0.5542846","0.55281645","0.55234426","0.55096674","0.5472171","0.5465183","0.5462773","0.5457216","0.5441518","0.5434996","0.54208565","0.5409633","0.54063624","0.5393192","0.539224","0.53805584","0.53746235","0.5367149","0.53534824","0.53440845","0.5343668","0.534101","0.53364545","0.53282917","0.5309909","0.5289363","0.52872217","0.52856344","0.527742","0.52737737","0.5272777","0.5253949","0.5241536","0.5231095","0.52306753","0.5210208","0.5192136","0.51902026","0.5184202","0.51809984","0.5172008","0.5164579","0.51629704","0.5152102","0.51520485","0.5149675","0.51433873","0.51347685","0.51291","0.5124583","0.5115984","0.5113577","0.51087886","0.5104594","0.5102114","0.5093959","0.50893396","0.5083366","0.5075686","0.5075642","0.50708133","0.50633055","0.50520086","0.50520086","0.5046056","0.5040478","0.5034714","0.50330704","0.5032525","0.5027008","0.50175214","0.5014351","0.50119215","0.5008607","0.5002814","0.49936604","0.49915493","0.4990433","0.49882904","0.49869445","0.498317","0.49788675","0.49749488","0.49715987","0.4971191","0.49708447","0.49665806","0.49574733","0.4956999","0.49537358"],"string":"[\n \"0.6780373\",\n \"0.62166446\",\n \"0.60941476\",\n \"0.6064973\",\n \"0.58558685\",\n \"0.5828296\",\n \"0.5750417\",\n \"0.5698166\",\n \"0.559145\",\n \"0.55552137\",\n \"0.5542846\",\n \"0.55281645\",\n \"0.55234426\",\n \"0.55096674\",\n \"0.5472171\",\n \"0.5465183\",\n \"0.5462773\",\n \"0.5457216\",\n \"0.5441518\",\n \"0.5434996\",\n \"0.54208565\",\n \"0.5409633\",\n \"0.54063624\",\n \"0.5393192\",\n \"0.539224\",\n \"0.53805584\",\n \"0.53746235\",\n \"0.5367149\",\n \"0.53534824\",\n \"0.53440845\",\n \"0.5343668\",\n \"0.534101\",\n \"0.53364545\",\n \"0.53282917\",\n \"0.5309909\",\n \"0.5289363\",\n \"0.52872217\",\n \"0.52856344\",\n \"0.527742\",\n \"0.52737737\",\n \"0.5272777\",\n \"0.5253949\",\n \"0.5241536\",\n \"0.5231095\",\n \"0.52306753\",\n \"0.5210208\",\n \"0.5192136\",\n \"0.51902026\",\n \"0.5184202\",\n \"0.51809984\",\n \"0.5172008\",\n \"0.5164579\",\n \"0.51629704\",\n \"0.5152102\",\n \"0.51520485\",\n \"0.5149675\",\n \"0.51433873\",\n \"0.51347685\",\n \"0.51291\",\n \"0.5124583\",\n \"0.5115984\",\n \"0.5113577\",\n \"0.51087886\",\n \"0.5104594\",\n \"0.5102114\",\n \"0.5093959\",\n \"0.50893396\",\n \"0.5083366\",\n \"0.5075686\",\n \"0.5075642\",\n \"0.50708133\",\n \"0.50633055\",\n \"0.50520086\",\n \"0.50520086\",\n \"0.5046056\",\n \"0.5040478\",\n \"0.5034714\",\n \"0.50330704\",\n \"0.5032525\",\n \"0.5027008\",\n \"0.50175214\",\n \"0.5014351\",\n \"0.50119215\",\n \"0.5008607\",\n \"0.5002814\",\n \"0.49936604\",\n \"0.49915493\",\n \"0.4990433\",\n \"0.49882904\",\n \"0.49869445\",\n \"0.498317\",\n \"0.49788675\",\n \"0.49749488\",\n \"0.49715987\",\n \"0.4971191\",\n \"0.49708447\",\n \"0.49665806\",\n \"0.49574733\",\n \"0.4956999\",\n \"0.49537358\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6289924"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":84792,"cells":{"query":{"kind":"string","value":"Determine the unique Frequency and state"},"document":{"kind":"string","value":"def unique_freq(self):\n unique_freq = []\n for i in self.timestamp:\n if self.state_time_map[i] not in unique_freq and self.state_time_map[i] != self.UNKNOWNSTATE:\n unique_freq.append(self.state_time_map[i])\n for i in self.minimum_frequency_cluster:\n if i not in unique_freq:\n unique_freq.append(i)\n return unique_freq"},"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 freq():","def freq(self) -> int:","def get_frequency(self):\r\n # print '*********in get freq'\r\n self.cntr.run('FREQ 1')\r\n f_0_ = self.cntr.get_measurements(1)\r\n self.f_0 = f_0_[0]\r\n self.cntr.run('FREQ 2')\r\n f_rep_ = self.cntr.get_measurements(1)\r\n self.f_rep = f_rep_[0]","def find_freq(self):\n state = self.env.reset()\n state_dim = len(state)\n seq = [state]\n\n for _ in range(self.args.exploration_iterations*10):\n action = np.random.randint(self.env.action_space.n)\n next_state, reward, done, info = self.env.step(action)\n seq.append(next_state)\n if done:\n state = self.env.reset()\n else:\n state = next_state\n\n # Create a primitive MDP for every unique state explored\n states = set(seq)\n for state in states:\n primitive_mdp = MDP(level=0, state_var=state)\n primitive_mdp.exits = {x for x in range(self.env.action_space.n)}\n primitive_mdp.mer = frozenset({state})\n primitive_mdp.primitive_states = {state}\n self.mdps[0].add(primitive_mdp)\n\n freq = [{'sv': i, 'last': None, 'changes': 0} for i in range(state_dim)]\n for state in seq:\n for i in range(state_dim):\n if freq[i]['last'] is None:\n freq[i]['last'] = state[i]\n else:\n if state[i] != freq[i]['last']:\n freq[i]['changes'] += 1\n freq[i]['last'] = state[i]\n\n sorted_freq = sorted(freq, key=lambda x: x['changes'], reverse=True)\n return [d['sv'] for d in sorted_freq], state_dim","def GetFrequency(self):\n ...","def source_freq(self) -> int:","def get_frequency(self):\n\n #TODO\n\n\n self.__running_time = round(time.time() * 1000) - self.__running_time\n\n return self.__frequency_dict","def _create_freq_dist(self):\r\n freq_dict = dict()\r\n\r\n for element in self.data:\r\n if element in freq_dict:\r\n freq_dict[element] += 1\r\n else:\r\n freq_dict[element] = 1\r\n\r\n return freq_dict","def test_frequency(self):\n self.assertEqual(functions.frequency([1, 2, 3, 4, 4, 4], 4), 3)\n self.assertEqual(functions.frequency(\n [True, False, True, True], False), 1)","def semitone_diff_to_frequency(n: float) -> float:\n return A4 * A**n","def mode(self):\r\n\t\t_set\t= set(self.sample)\r\n\t\t_list\t= [self.sample.count(i) for i in _set]\r\n\t\treturn list(_set)[_list.index(max(_list))]","def frequency(self):\n return infer_frequency(self._obj, 'ignore')","def get_frequency(self):\r\n return self.f","def frequency(self):\n inigen = IniGen()\n fields = algorithm_fields.algorithms['frequency']\n\n output_uuid_map = {}\n\n # set up global parameters\n algorithm_path = fields['path']\n enabled = \"True\"\n inigen.emit_global(algorithm_path, enabled)\n\n for label in self.uuid_map:\n if label == 'LSTATE':\n distillate_label = label\n else:\n distillate_label = get_distillate_label([label])\n if 'ANG' not in distillate_label:\n continue\n\n # header\n inigen.emit_run_header(label, CHUNKING, MINTIME, MAXTIME)\n\n # body\n dep_label = label\n dep_name = fields['deps'][0]\n dep_uuid = self.uuid_map[label]\n deps = [[dep_label, dep_name, dep_uuid]]\n\n param_section_name = fields['params'][0]\n param_section_value = \"Production/{0}/{1}/{2}\".format(self.location, self.name, distillate_label)\n param_name_name = fields['params'][1]\n param_name_value = \"FREQ\"\n params = [[param_section_name, param_section_value],\n [param_name_name, param_name_value]]\n\n outputs = fields['outputs']\n\n emitted = inigen.emit_run_body(deps, params, outputs)\n\n output_uuid_map[label+\"_1-SEC\"] = emitted[-3][-36:]\n output_uuid_map[label+\"_C37\"] = emitted[-2][-36:]\n\n filename = \"{0}/FREQ_{1}.ini\".format(self.dirname, self.name)\n inigen.generate_file(filename)\n return output_uuid_map","def getFrq(self):\n fr = [0 for i in range(26)]\n for i in self.state[0]:\n for j in self.state[1]:\n fr[ord(self.table[i][j]) - ord('a')] += 1\n return fr","def frequency_counter(count):\n return counts(count)","def FirstRepeatingFrequency(self):\n prev_freqs = {0}\n freq = 0\n for offset in cycle(self.freq_changes):\n freq += offset\n if freq in prev_freqs:\n return freq\n else:\n prev_freqs.add(freq)","def freq(self):\n diceFreq = [0 for x in range(0,6)]\n for i in self.view():\n diceFreq[i - 1] += 1\n return tuple(diceFreq)","def unif_sampler(self):\n state = np.zeros(self.K+1, dtype=int)\n\n # adds high one according to probability\n high_one = np.random.binomial(1, self.high_one_prob)\n if high_one:\n state = self.get_high_one(state)\n\n # checks potential of state, returning early if necessary\n if (self.initial_potential - self.potential(state)) <= 0:\n return state\n\n # samples according to uniform probability\n pot_state = self.potential(state)\n\n for i in range(max(10, int(1/(100000*self.weights[0])))):\n levels = np.random.randint(low=0, high=self.unif_high, size=int(\n np.min([100000, 1.0/self.weights[0]])))\n # adds on each level as the potential allows\n for l in levels:\n if pot_state + self.weights[l] <= self.initial_potential:\n state[l] += 1\n pot_state += self.weights[l]\n\n # checks potential to break\n if pot_state >= self.initial_potential - max(1e-8, self.weights[0]):\n break\n # checks potential to break\n if pot_state >= self.initial_potential - max(1e-8, self.weights[0]):\n break\n\n return state","def freq(self, frequency: Optional[int]):","def ResultingFrequency(self):\n return sum(self.freq_changes)","def sample_count(self):","def __init__(self):\n self.freq = collections.defaultdict(set)\n self.cache = collections.defaultdict()\n self.max_freq = 0\n self.min_freq = 0","def evaluate(self, state):\n\n fitness = 0\n\n for i in range(1, len(state)):\n if state[i] != state[i - 1]:\n fitness += 1\n\n return fitness","def collect_type_freqs(self):\n tf.logging.info('collecting type_freq, mapping type_id -> # instances')\n self.type_freq = collections.defaultdict(int)\n for f in self.frames():\n if self.instance_of in f:\n self.type_freq[f[self.instance_of].id] += 1\n # not sure why this is needed - do some things have Null id's?\n del self.type_freq[None]","def update_frequencies():\n pass","def _collect_counts(self):\n for t in self.system.keys():\n if t in self.gold:\n self.tp += 1\n else:\n self.fp += 1\n for t in self.gold.keys():\n if t not in self.system:\n self.fn += 1","def frequencyofints(a ,memeff = True) :\n\tif memeff :\n\t\ta.sort()\n\t\t#get unique list of values:\n\t\tu = np.unique(a) \n\n\t\tfreq = np.zeros(len(u), dtype = int) \n\t\tj = 0 \n\t\tfor i,ue in enumerate(u) :\n\t\t\twhile u[i] == a[j] :\n\t\t\t\tfreq[i] += 1\n\t\t\t\tif j == len(a) - 1:\n\t\t\t\t\tbreak\n\t\t\t\tj += 1 \n\t\treturn u , freq\t\t\t\n\t\t\n\telse:\n\t\tx = np.bincount(a) \n\t\tvals = np.nonzero(x) [0]\n\t\tfreq = x[vals]\n\n\treturn vals, freq","def observed_species(counts):\n return (counts!=0).sum()","def freq(self, value: int, /) -> None:","def singles(counts):\n return (counts==1).sum()","def at_frequency(self):\n result = str(self.seq).count(\"A\") + str(self.seq).count(\"T\")\n return result","def freq(self, x):\n return self.d.get(x, 0)","def get_high_one(self, state):\n non_zero_idxs = [-2, -3, -4]\n idx_idxs = np.random.randint(low=0, high=3, size=10)\n for idx_idx in idx_idxs:\n non_zero_idx = non_zero_idxs[idx_idx]\n if self.potential(state) + self.weights[non_zero_idx] <= self.initial_potential:\n state[non_zero_idx] += 1\n break\n return state","def get_frequency(self,):\n\n # TODO: Find way to appropriately reconvert the frequency to its initial\n # TODO: Value or alert that the value is APPROXIMATE\n FTW = int (0)\n freq = int(0)\n\n FTW_bytes = self._read('CFTW0')\n FTW = FTW.from_bytes(FTW_bytes,'big')\n freq = FTW*self.clock_freq/2**32\n\n print('Latest frequency set: ', \"{:.2e}\".format(freq), 'Hz')\n print(['%.2e' % elem for elem in self.frequencies])\n\n return self.frequencies","def frequency(self):\n index = self._ordered_input_names.index('frequency')\n return self._inputs[index]","def frequency(self):\n return self._pca.frequency","def osd(counts):\n return (counts!=0).sum(), (counts==1).sum(), (counts==2).sum()","def make_temp_histograms_sequentially(self):\n print \"\\nfind all unique code words\"\n\n self.len_of_code_book = h.create_temp_histograms(self.qsr_path, self.accu_path)\n return True","def frequency(self):\n return float(self.get_frequency())","def getFrequencyDict(sequence):\n # freqs: dictionary (element_type -> int)\n \n for x in sequence:\n hand[x] = hand.get(x,0) + 1\n updatehand(hand, word)\n print hand\n print \"freq function\"\n #return hand","def get_frequent(self):\n total_rows = self.df[self.col_name].count()\n frequency = self.df[self.col_name].value_counts().reset_index()\n frequency.columns = ['value', 'occurrence']\n frequency['percentage'] = frequency['occurrence']/total_rows\n return frequency.head(20)","def get_frequency(arr):\n freq = {}\n for i in arr:\n if(i not in freq):\n freq[i] = 0\n freq[i] += 1\n \n return freq","def __init__(self):\n self.num_counts = {}","def test_frequency(self):\n self.assertAlmostEqual(self.tunneling.frequency.value_si, self.frequency, 4)","def test_frequency(self):\n self.assertAlmostEqual(self.tunneling.frequency.value_si, self.frequency, 4)","def unique_instance(un_data):\n test_dict = dict()\n indexed = list()\n count = 0\n for i,item in enumerate(un_data):\n if not test_dict.has_key( hash(item) ):\n test_dict[ hash(item) ] = 0\n else:\n count = count + 1\n indexed.append(i)\n return count, indexed","def count_unique_features(self):\n return N_UNIQUE_FEATS","def update_state_occupancy_count(self, obs):\n obs_hash = self.compute_obs_hash(obs)\n matches_previous_obs = self.prev_obs_hash is not None and obs_hash == self.prev_obs_hash\n self.state_occupancy_counts[obs_hash] += 1\n self.prev_obs_hash = obs_hash\n return {\n \"occupancy_count\": self.state_occupancy_counts[obs_hash],\n \"num_unique_states\": len(self.state_occupancy_counts),\n \"matches_previous_obs\": matches_previous_obs\n }","def freq(self, freq=None):\n raise NotImplementedError()","def test_make_sorted_frequencies_abolute(self):\r\n\r\n # works on empty\r\n counts = array([])\r\n self.assertItemsEqual(make_sorted_frequencies(counts, True), [])\r\n\r\n # works on zeros\r\n counts = array([0, 0, 0, 0, 0, 0])\r\n self.assertItemsEqual(make_sorted_frequencies(counts, True), [])\r\n\r\n # works on flat data\r\n counts = array([3, 3, 3, 3, 3])\r\n expected_freqs = [3, 3, 3, 3, 3]\r\n observed_freqs = make_sorted_frequencies(counts, True)\r\n self.assertItemsEqual(observed_freqs, expected_freqs)\r\n\r\n # works o real data\r\n counts = array([1, 2, 0, 1, 0, 2, 4])\r\n expected_freqs = [4, 2, 2, 1, 1]\r\n observed_freqs = make_sorted_frequencies(counts, True)\r\n self.assertItemsEqual(observed_freqs, expected_freqs)","def generate_n_u(t):\n return np.unique(t, return_counts=True)[1]","def test_frequency():\n random_vals = []\n\n # generating 50 random integers between 0 and 10 and appending them to a list\n for i in range(50):\n random_vals.append(random.randrange(0, 10, 1))\n\n # generating 1 random integer to count\n rand_count_val = random.randrange(0, 10, 1)\n\n # test cases\n tests = [\n (random_vals, rand_count_val, random_vals.count(rand_count_val)),\n ([], 1, 0),\n ([1, 1, 1, 1, 2], 1, 4),\n ([1, 2, 3, 4], 5, 0)\n ]\n\n # looping through every test case\n for test, item, expected in tests:\n result = frequency(item, test)\n assert result == expected, 'Failed on {} - got {}, expected {}'.format(test, result, expected)","def frequencies(self):\n return self._frequencies","def computeFreq(self):\n for x in self.data:\n i = 0\n for interval in self.classesInterval:\n if interval[0] <= x <= interval[1]:\n self.frequencies[i] += 1\n break\n i += 1\n\n self.minFreq = self.frequencies[0]\n self.maxFreq = self.frequencies[0]\n for f in self.frequencies:\n if f < self.minFreq:\n self.minFreq = f\n elif f > self.maxFreq:\n self.maxFreq = f","def get_frequency_dict(sequence):\n freq = {}\n for x in sequence:\n freq[x] = freq.get(x, 0) + 1\n return freq","def getFreq(self,):\n\t\treturn self.freq;","def get_freq(self):\n return self.freq","def aitemfreq(a):\r\n scores = pstats.aunique(a)\r\n scores = N.sort(scores)\r\n freq = N.zeros(len(scores))\r\n for i in range(len(scores)):\r\n freq[i] = N.add.reduce(N.equal(a,scores[i]))\r\n return N.array(pstats.aabut(scores, freq))","def __init__(self):\n self.freq = {}","def __calculate_frequency(self, data_set, feature):\n feature_data = list(data_set[feature])\n value_frequency = Counter(feature_data)\n return dict(value_frequency)","def frequentOneItem(self):\n\n candidate = {}\n # global finalPatterns, minSup, Database\n # self.minSup = self.minSup\n for i in range(len(self.Database)):\n for j in range(len(self.Database[i])):\n if self.Database[i][j] not in candidate:\n candidate[self.Database[i][j]] = [i]\n else:\n candidate[self.Database[i][j]] += [i]\n self.finalPatterns = {keys: value for keys, value in candidate.items() if len(value) >= self.minSup}\n #print(candidate)","def compute_visit_freq_table(self, episodes):\n visited_states = {state: 0 for state in self._all_states}\n visited_sets_episodes = []\n for episode in episodes:\n visited_set = set()\n if episode.solved:\n visited_set.add(self.goal_state)\n states_batch = [self.obs2tuple(obs) for obs in\n episode.transition_batch.observation]\n for state in states_batch:\n visited_states[state] += 1\n visited_set.add(state)\n self._visited_states_in_history.add(state)\n visited_sets_episodes.append(visited_set)\n if episode.solved:\n visited_states[self.goal_state] += 1\n\n visited_freq = np.mean([len(x) / 3 ** self.n_disks\n for x in visited_sets_episodes])\n visited_states = {state: visited_states[state] /\n (len(episodes) * 3 ** self.n_disks)\n for state in self._all_states}\n return visited_states, visited_freq","def __len__(self):\n i = 0\n for S in self.states():\n i += 1\n return i","def distr(self,X):\r\n return {x:X.count(x) for x in set(X)}","def test_freq(self):\n\n Teffs, Lums, Teffs_out, Lums_out = [], [], [], []\n for track in self.tracks:\n for model in track.models:\n if (not model.freq_sorted()):\n print(model.name)\n Teffs_out.append(model.string_to_param(\"Teff\"))\n Lums_out.append(model.string_to_param(\"log_Luminosity\"))\n else:\n Teffs.append(model.string_to_param(\"Teff\"))\n Lums.append(model.string_to_param(\"log_Luminosity\"))\n return Teffs_out, Lums_out, Teffs, Lums","def nf(self): # noqa: D401\n return len(self._freqs)","def frequency(self) -> NumType:\n return self._freq","def __calc_empirical_counts__(self):\n self.empirical_counts = np.zeros(self._features_vector_length, dtype=float)\n for feature, freq in self.features_dict.items():\n for index in feature:\n self.empirical_counts[index] += freq\n assert len(self.empirical_counts) == np.count_nonzero(self.empirical_counts), \"0 in empirical counts vector\"","def test_categorical_log_frequency():\n # assert the distribution of the samples is close to the distribution of the data\n # using cstest:\n # - uniform (assert p-value > 0.05)\n # - very skewed / biased? (assert p-value > 0.05)\n # - inversely correlated (assert correlation < 0)","def get_list_frequencies(self):\r\n return self.fs","def frequencies(self):\r\n\r\n # Get the sampling rate from the seed time-series:\r\n self.method['Fs'] = self.method.get('Fs', self.seed.sampling_rate)\r\n NFFT = self.method.get('NFFT', 64)\r\n Fs = self.method.get('Fs')\r\n freqs = tsu.get_freqs(Fs, NFFT)\r\n lb_idx, ub_idx = tsu.get_bounds(freqs, self.lb, self.ub)\r\n\r\n return freqs[lb_idx:ub_idx]","def test_getAbundanceFrequencyCounts(self):\r\n # Verified with iNEXT.\r\n exp = defaultdict(int, {1: 1, 2: 1, 3: 1, 4: 1, 5: 1})\r\n obs = self.est1.getAbundanceFrequencyCounts()\r\n self.assertEqual(obs, exp)\r\n\r\n # Verified against results in Colwell 2012 paper.\r\n self.assertEqual(self.est2.getAbundanceFrequencyCounts(), colwell_fk1)\r\n self.assertEqual(self.est3.getAbundanceFrequencyCounts(), colwell_fk2)","def _test_get_a_freq(self):\n for i, energy_test in enumerate(self.energy_list):\n if i+1 < len(self.energy_list):\n energy = (self.energy_list[i+1]+self.energy_list[i])/2.\n else:\n energy = (-self.energy_list[i-1]+2.*self.energy_list[i])\n energy_test_2 = energy_test-1e-2\n print i, energy_test_2, self._get_a_freq(energy_test_2)\n print i, energy_test, self._get_a_freq(energy_test)\n energy_test_2 = energy_test+1e-2\n print i, energy_test_2, self._get_a_freq(energy_test_2)\n print i, energy_test, 1./self.closed_orbits_t[energy_test]\n print i, energy, self._get_a_freq(energy)\n print","def first_frequency_twice(changes: Sequence[int]) -> int:\n frequency = 0\n counts = {frequency: 1}\n found = False\n while not found:\n for change in changes:\n frequency += change\n count = counts.get(frequency, 0) + 1\n if count == 2:\n found = True\n break\n counts[frequency] = count\n return frequency","def test_make_sorted_frequencies(self):\r\n\r\n # works on empty\r\n counts = array([])\r\n self.assertItemsEqual(make_sorted_frequencies(counts), [])\r\n\r\n # works on zeros\r\n counts = array([0, 0, 0, 0, 0, 0])\r\n self.assertItemsEqual(make_sorted_frequencies(counts), [])\r\n\r\n # works on flat data\r\n counts = array([3, 3, 3, 3, 3])\r\n expected_freqs = [0.2, 0.2, 0.2, 0.2, 0.2]\r\n observed_freqs = make_sorted_frequencies(counts)\r\n self.assertItemsEqual(observed_freqs, expected_freqs)\r\n\r\n # works on real data\r\n counts = array([1, 2, 0, 1, 0, 2, 4])\r\n expected_freqs = [0.4, 0.2, 0.2, 0.1, 0.1]\r\n observed_freqs = make_sorted_frequencies(counts)\r\n self.assertItemsEqual(observed_freqs, expected_freqs)","def frequencies(self):\n radii = self.radii\n freqs = (1 / (self.shape[0] * self.pixel[0])) * radii\n return freqs","def _get_existence_frequency(self):\n with np.errstate(invalid='ignore'):\n return np.nan_to_num(self.existence_array / self.coverage_array * 100)","def get_frequencies(self):\n num_seconds = float(self.timestamps[-2] - self.timestamps[0]) / float(1000)\n samples_per_second = len(self.data) / num_seconds\n num_samples = len(self.data)\n oscilations_per_sample = [float(oscilations) / num_samples for oscilations in range(0, num_samples)]\n return [ops * samples_per_second for ops in oscilations_per_sample]","def frequency(self) -> int:\n return self._frequency","def most_frequent(s):\n\n hist = make_histogram(s)\n\n t = []\n for x, freq in hist.items():\n t.append((freq, x))\n \n t.sort(reverse = True)\n # print(t)\n res = []\n for freq, x in t:\n res.append(x)\n \n return res","def count():","def __len__(self):\n return self.data.index.get_level_values(0).to_series().nunique()","def test_constant():\n generator = SignalGenerator()\n data = generator.constant()\n freq_features = FrequencyFeature(data, sr=50)\n freq_features.fft().peaks()\n assert np.allclose(freq_features.dominant_frequency(n=1), np.zeros((1, 3)))\n assert np.allclose(\n freq_features.dominant_frequency_power(n=1), np.zeros((1, 3)))","def getFrequencyDict(sequence):\n # freqs: dictionary (element_type -> int)\n freq = {}\n for x in sequence:\n freq[x] = freq.get(x,0) + 1\n return freq","def getFrequencyDict(sequence):\n # freqs: dictionary (element_type -> int)\n freq = {}\n for x in sequence:\n freq[x] = freq.get(x,0) + 1\n return freq","def getFrequencyDict(sequence):\n # freqs: dictionary (element_type -> int)\n freq = {}\n for x in sequence:\n freq[x] = freq.get(x,0) + 1\n return freq","def frequency(self, pt):\n return math.floor(abs(self.id - pt.id) / 2)","def find_repeating_frequency(values):\n frequencies = set([0])\n\n index = 0\n frequency = 0\n while True:\n found = False\n for value in values:\n frequency += value\n index += 1\n if frequency in frequencies:\n found = True\n break\n\n frequencies.add(frequency)\n\n if found:\n break\n\n return frequency","def freq_count(self):\n #eg: fc = spammy.freq_count()\n count_dict = defaultdict(int)\n for entry in self._train_list:\n if entry in self._vocab_set:\n count_dict[entry] += 1\n return count_dict","def frequency(self, w, s=1.0):\n x = w * s\n # Heaviside mock\n Hw = np.array(w)\n Hw[w <= 0] = 0\n Hw[w > 0] = 1\n return np.pi ** -0.25 * Hw * np.exp((-((x - self.w0) ** 2)) / 2)","def get_on_neurons(Fish,state):\r\n state_snap= Fish[state,:]\r\n \r\n label=[]\r\n for i in range(len(state_snap)):\r\n if state_snap[i]>2:\r\n label.append(1)\r\n else: \r\n label.append(0)\r\n return label","def buildFrequencyDic(L):\n pass","def transitionfreq(molecule, transition) :\n return s.transitionFreq(molecule, transition)","def frequency(self):\n return self.reference_clock_speed / 4096 / self.prescale_reg","def unique(self):\n # variables for uniques \n self._currentSet = 1\n self._uniqueValue = {}\n\n pd = self._dataTable\n for col in pd:\n arr = pd[col].unique()\n for i in arr:\n unique_entry = ((col,i),)\n self._uniqueValue[unique_entry] = 0 \n\n self._sets[self._currentSet] = self._uniqueValue","def information(self, fdist):\n freq = fdist.get(self.string)\n if not freq:\n freq = 0\n return 1 - (log(freq + 1) / log(fdist.N() + 1))","def findClosed(freqSet, freqSup):","def freqvals(t):\n N = len(t)\n T = t[-1] - t[0]\n dt = T/N\n nyquist = 1/(2.0*dt)\n lowfreq = 1/T\n return (N, T, dt, nyquist, lowfreq)","def gc_frequency(self):\n result = str(self.seq).count(\"G\") + str(self.seq).count(\"C\")\n return result"],"string":"[\n \"def freq():\",\n \"def freq(self) -> int:\",\n \"def get_frequency(self):\\r\\n # print '*********in get freq'\\r\\n self.cntr.run('FREQ 1')\\r\\n f_0_ = self.cntr.get_measurements(1)\\r\\n self.f_0 = f_0_[0]\\r\\n self.cntr.run('FREQ 2')\\r\\n f_rep_ = self.cntr.get_measurements(1)\\r\\n self.f_rep = f_rep_[0]\",\n \"def find_freq(self):\\n state = self.env.reset()\\n state_dim = len(state)\\n seq = [state]\\n\\n for _ in range(self.args.exploration_iterations*10):\\n action = np.random.randint(self.env.action_space.n)\\n next_state, reward, done, info = self.env.step(action)\\n seq.append(next_state)\\n if done:\\n state = self.env.reset()\\n else:\\n state = next_state\\n\\n # Create a primitive MDP for every unique state explored\\n states = set(seq)\\n for state in states:\\n primitive_mdp = MDP(level=0, state_var=state)\\n primitive_mdp.exits = {x for x in range(self.env.action_space.n)}\\n primitive_mdp.mer = frozenset({state})\\n primitive_mdp.primitive_states = {state}\\n self.mdps[0].add(primitive_mdp)\\n\\n freq = [{'sv': i, 'last': None, 'changes': 0} for i in range(state_dim)]\\n for state in seq:\\n for i in range(state_dim):\\n if freq[i]['last'] is None:\\n freq[i]['last'] = state[i]\\n else:\\n if state[i] != freq[i]['last']:\\n freq[i]['changes'] += 1\\n freq[i]['last'] = state[i]\\n\\n sorted_freq = sorted(freq, key=lambda x: x['changes'], reverse=True)\\n return [d['sv'] for d in sorted_freq], state_dim\",\n \"def GetFrequency(self):\\n ...\",\n \"def source_freq(self) -> int:\",\n \"def get_frequency(self):\\n\\n #TODO\\n\\n\\n self.__running_time = round(time.time() * 1000) - self.__running_time\\n\\n return self.__frequency_dict\",\n \"def _create_freq_dist(self):\\r\\n freq_dict = dict()\\r\\n\\r\\n for element in self.data:\\r\\n if element in freq_dict:\\r\\n freq_dict[element] += 1\\r\\n else:\\r\\n freq_dict[element] = 1\\r\\n\\r\\n return freq_dict\",\n \"def test_frequency(self):\\n self.assertEqual(functions.frequency([1, 2, 3, 4, 4, 4], 4), 3)\\n self.assertEqual(functions.frequency(\\n [True, False, True, True], False), 1)\",\n \"def semitone_diff_to_frequency(n: float) -> float:\\n return A4 * A**n\",\n \"def mode(self):\\r\\n\\t\\t_set\\t= set(self.sample)\\r\\n\\t\\t_list\\t= [self.sample.count(i) for i in _set]\\r\\n\\t\\treturn list(_set)[_list.index(max(_list))]\",\n \"def frequency(self):\\n return infer_frequency(self._obj, 'ignore')\",\n \"def get_frequency(self):\\r\\n return self.f\",\n \"def frequency(self):\\n inigen = IniGen()\\n fields = algorithm_fields.algorithms['frequency']\\n\\n output_uuid_map = {}\\n\\n # set up global parameters\\n algorithm_path = fields['path']\\n enabled = \\\"True\\\"\\n inigen.emit_global(algorithm_path, enabled)\\n\\n for label in self.uuid_map:\\n if label == 'LSTATE':\\n distillate_label = label\\n else:\\n distillate_label = get_distillate_label([label])\\n if 'ANG' not in distillate_label:\\n continue\\n\\n # header\\n inigen.emit_run_header(label, CHUNKING, MINTIME, MAXTIME)\\n\\n # body\\n dep_label = label\\n dep_name = fields['deps'][0]\\n dep_uuid = self.uuid_map[label]\\n deps = [[dep_label, dep_name, dep_uuid]]\\n\\n param_section_name = fields['params'][0]\\n param_section_value = \\\"Production/{0}/{1}/{2}\\\".format(self.location, self.name, distillate_label)\\n param_name_name = fields['params'][1]\\n param_name_value = \\\"FREQ\\\"\\n params = [[param_section_name, param_section_value],\\n [param_name_name, param_name_value]]\\n\\n outputs = fields['outputs']\\n\\n emitted = inigen.emit_run_body(deps, params, outputs)\\n\\n output_uuid_map[label+\\\"_1-SEC\\\"] = emitted[-3][-36:]\\n output_uuid_map[label+\\\"_C37\\\"] = emitted[-2][-36:]\\n\\n filename = \\\"{0}/FREQ_{1}.ini\\\".format(self.dirname, self.name)\\n inigen.generate_file(filename)\\n return output_uuid_map\",\n \"def getFrq(self):\\n fr = [0 for i in range(26)]\\n for i in self.state[0]:\\n for j in self.state[1]:\\n fr[ord(self.table[i][j]) - ord('a')] += 1\\n return fr\",\n \"def frequency_counter(count):\\n return counts(count)\",\n \"def FirstRepeatingFrequency(self):\\n prev_freqs = {0}\\n freq = 0\\n for offset in cycle(self.freq_changes):\\n freq += offset\\n if freq in prev_freqs:\\n return freq\\n else:\\n prev_freqs.add(freq)\",\n \"def freq(self):\\n diceFreq = [0 for x in range(0,6)]\\n for i in self.view():\\n diceFreq[i - 1] += 1\\n return tuple(diceFreq)\",\n \"def unif_sampler(self):\\n state = np.zeros(self.K+1, dtype=int)\\n\\n # adds high one according to probability\\n high_one = np.random.binomial(1, self.high_one_prob)\\n if high_one:\\n state = self.get_high_one(state)\\n\\n # checks potential of state, returning early if necessary\\n if (self.initial_potential - self.potential(state)) <= 0:\\n return state\\n\\n # samples according to uniform probability\\n pot_state = self.potential(state)\\n\\n for i in range(max(10, int(1/(100000*self.weights[0])))):\\n levels = np.random.randint(low=0, high=self.unif_high, size=int(\\n np.min([100000, 1.0/self.weights[0]])))\\n # adds on each level as the potential allows\\n for l in levels:\\n if pot_state + self.weights[l] <= self.initial_potential:\\n state[l] += 1\\n pot_state += self.weights[l]\\n\\n # checks potential to break\\n if pot_state >= self.initial_potential - max(1e-8, self.weights[0]):\\n break\\n # checks potential to break\\n if pot_state >= self.initial_potential - max(1e-8, self.weights[0]):\\n break\\n\\n return state\",\n \"def freq(self, frequency: Optional[int]):\",\n \"def ResultingFrequency(self):\\n return sum(self.freq_changes)\",\n \"def sample_count(self):\",\n \"def __init__(self):\\n self.freq = collections.defaultdict(set)\\n self.cache = collections.defaultdict()\\n self.max_freq = 0\\n self.min_freq = 0\",\n \"def evaluate(self, state):\\n\\n fitness = 0\\n\\n for i in range(1, len(state)):\\n if state[i] != state[i - 1]:\\n fitness += 1\\n\\n return fitness\",\n \"def collect_type_freqs(self):\\n tf.logging.info('collecting type_freq, mapping type_id -> # instances')\\n self.type_freq = collections.defaultdict(int)\\n for f in self.frames():\\n if self.instance_of in f:\\n self.type_freq[f[self.instance_of].id] += 1\\n # not sure why this is needed - do some things have Null id's?\\n del self.type_freq[None]\",\n \"def update_frequencies():\\n pass\",\n \"def _collect_counts(self):\\n for t in self.system.keys():\\n if t in self.gold:\\n self.tp += 1\\n else:\\n self.fp += 1\\n for t in self.gold.keys():\\n if t not in self.system:\\n self.fn += 1\",\n \"def frequencyofints(a ,memeff = True) :\\n\\tif memeff :\\n\\t\\ta.sort()\\n\\t\\t#get unique list of values:\\n\\t\\tu = np.unique(a) \\n\\n\\t\\tfreq = np.zeros(len(u), dtype = int) \\n\\t\\tj = 0 \\n\\t\\tfor i,ue in enumerate(u) :\\n\\t\\t\\twhile u[i] == a[j] :\\n\\t\\t\\t\\tfreq[i] += 1\\n\\t\\t\\t\\tif j == len(a) - 1:\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\tj += 1 \\n\\t\\treturn u , freq\\t\\t\\t\\n\\t\\t\\n\\telse:\\n\\t\\tx = np.bincount(a) \\n\\t\\tvals = np.nonzero(x) [0]\\n\\t\\tfreq = x[vals]\\n\\n\\treturn vals, freq\",\n \"def observed_species(counts):\\n return (counts!=0).sum()\",\n \"def freq(self, value: int, /) -> None:\",\n \"def singles(counts):\\n return (counts==1).sum()\",\n \"def at_frequency(self):\\n result = str(self.seq).count(\\\"A\\\") + str(self.seq).count(\\\"T\\\")\\n return result\",\n \"def freq(self, x):\\n return self.d.get(x, 0)\",\n \"def get_high_one(self, state):\\n non_zero_idxs = [-2, -3, -4]\\n idx_idxs = np.random.randint(low=0, high=3, size=10)\\n for idx_idx in idx_idxs:\\n non_zero_idx = non_zero_idxs[idx_idx]\\n if self.potential(state) + self.weights[non_zero_idx] <= self.initial_potential:\\n state[non_zero_idx] += 1\\n break\\n return state\",\n \"def get_frequency(self,):\\n\\n # TODO: Find way to appropriately reconvert the frequency to its initial\\n # TODO: Value or alert that the value is APPROXIMATE\\n FTW = int (0)\\n freq = int(0)\\n\\n FTW_bytes = self._read('CFTW0')\\n FTW = FTW.from_bytes(FTW_bytes,'big')\\n freq = FTW*self.clock_freq/2**32\\n\\n print('Latest frequency set: ', \\\"{:.2e}\\\".format(freq), 'Hz')\\n print(['%.2e' % elem for elem in self.frequencies])\\n\\n return self.frequencies\",\n \"def frequency(self):\\n index = self._ordered_input_names.index('frequency')\\n return self._inputs[index]\",\n \"def frequency(self):\\n return self._pca.frequency\",\n \"def osd(counts):\\n return (counts!=0).sum(), (counts==1).sum(), (counts==2).sum()\",\n \"def make_temp_histograms_sequentially(self):\\n print \\\"\\\\nfind all unique code words\\\"\\n\\n self.len_of_code_book = h.create_temp_histograms(self.qsr_path, self.accu_path)\\n return True\",\n \"def frequency(self):\\n return float(self.get_frequency())\",\n \"def getFrequencyDict(sequence):\\n # freqs: dictionary (element_type -> int)\\n \\n for x in sequence:\\n hand[x] = hand.get(x,0) + 1\\n updatehand(hand, word)\\n print hand\\n print \\\"freq function\\\"\\n #return hand\",\n \"def get_frequent(self):\\n total_rows = self.df[self.col_name].count()\\n frequency = self.df[self.col_name].value_counts().reset_index()\\n frequency.columns = ['value', 'occurrence']\\n frequency['percentage'] = frequency['occurrence']/total_rows\\n return frequency.head(20)\",\n \"def get_frequency(arr):\\n freq = {}\\n for i in arr:\\n if(i not in freq):\\n freq[i] = 0\\n freq[i] += 1\\n \\n return freq\",\n \"def __init__(self):\\n self.num_counts = {}\",\n \"def test_frequency(self):\\n self.assertAlmostEqual(self.tunneling.frequency.value_si, self.frequency, 4)\",\n \"def test_frequency(self):\\n self.assertAlmostEqual(self.tunneling.frequency.value_si, self.frequency, 4)\",\n \"def unique_instance(un_data):\\n test_dict = dict()\\n indexed = list()\\n count = 0\\n for i,item in enumerate(un_data):\\n if not test_dict.has_key( hash(item) ):\\n test_dict[ hash(item) ] = 0\\n else:\\n count = count + 1\\n indexed.append(i)\\n return count, indexed\",\n \"def count_unique_features(self):\\n return N_UNIQUE_FEATS\",\n \"def update_state_occupancy_count(self, obs):\\n obs_hash = self.compute_obs_hash(obs)\\n matches_previous_obs = self.prev_obs_hash is not None and obs_hash == self.prev_obs_hash\\n self.state_occupancy_counts[obs_hash] += 1\\n self.prev_obs_hash = obs_hash\\n return {\\n \\\"occupancy_count\\\": self.state_occupancy_counts[obs_hash],\\n \\\"num_unique_states\\\": len(self.state_occupancy_counts),\\n \\\"matches_previous_obs\\\": matches_previous_obs\\n }\",\n \"def freq(self, freq=None):\\n raise NotImplementedError()\",\n \"def test_make_sorted_frequencies_abolute(self):\\r\\n\\r\\n # works on empty\\r\\n counts = array([])\\r\\n self.assertItemsEqual(make_sorted_frequencies(counts, True), [])\\r\\n\\r\\n # works on zeros\\r\\n counts = array([0, 0, 0, 0, 0, 0])\\r\\n self.assertItemsEqual(make_sorted_frequencies(counts, True), [])\\r\\n\\r\\n # works on flat data\\r\\n counts = array([3, 3, 3, 3, 3])\\r\\n expected_freqs = [3, 3, 3, 3, 3]\\r\\n observed_freqs = make_sorted_frequencies(counts, True)\\r\\n self.assertItemsEqual(observed_freqs, expected_freqs)\\r\\n\\r\\n # works o real data\\r\\n counts = array([1, 2, 0, 1, 0, 2, 4])\\r\\n expected_freqs = [4, 2, 2, 1, 1]\\r\\n observed_freqs = make_sorted_frequencies(counts, True)\\r\\n self.assertItemsEqual(observed_freqs, expected_freqs)\",\n \"def generate_n_u(t):\\n return np.unique(t, return_counts=True)[1]\",\n \"def test_frequency():\\n random_vals = []\\n\\n # generating 50 random integers between 0 and 10 and appending them to a list\\n for i in range(50):\\n random_vals.append(random.randrange(0, 10, 1))\\n\\n # generating 1 random integer to count\\n rand_count_val = random.randrange(0, 10, 1)\\n\\n # test cases\\n tests = [\\n (random_vals, rand_count_val, random_vals.count(rand_count_val)),\\n ([], 1, 0),\\n ([1, 1, 1, 1, 2], 1, 4),\\n ([1, 2, 3, 4], 5, 0)\\n ]\\n\\n # looping through every test case\\n for test, item, expected in tests:\\n result = frequency(item, test)\\n assert result == expected, 'Failed on {} - got {}, expected {}'.format(test, result, expected)\",\n \"def frequencies(self):\\n return self._frequencies\",\n \"def computeFreq(self):\\n for x in self.data:\\n i = 0\\n for interval in self.classesInterval:\\n if interval[0] <= x <= interval[1]:\\n self.frequencies[i] += 1\\n break\\n i += 1\\n\\n self.minFreq = self.frequencies[0]\\n self.maxFreq = self.frequencies[0]\\n for f in self.frequencies:\\n if f < self.minFreq:\\n self.minFreq = f\\n elif f > self.maxFreq:\\n self.maxFreq = f\",\n \"def get_frequency_dict(sequence):\\n freq = {}\\n for x in sequence:\\n freq[x] = freq.get(x, 0) + 1\\n return freq\",\n \"def getFreq(self,):\\n\\t\\treturn self.freq;\",\n \"def get_freq(self):\\n return self.freq\",\n \"def aitemfreq(a):\\r\\n scores = pstats.aunique(a)\\r\\n scores = N.sort(scores)\\r\\n freq = N.zeros(len(scores))\\r\\n for i in range(len(scores)):\\r\\n freq[i] = N.add.reduce(N.equal(a,scores[i]))\\r\\n return N.array(pstats.aabut(scores, freq))\",\n \"def __init__(self):\\n self.freq = {}\",\n \"def __calculate_frequency(self, data_set, feature):\\n feature_data = list(data_set[feature])\\n value_frequency = Counter(feature_data)\\n return dict(value_frequency)\",\n \"def frequentOneItem(self):\\n\\n candidate = {}\\n # global finalPatterns, minSup, Database\\n # self.minSup = self.minSup\\n for i in range(len(self.Database)):\\n for j in range(len(self.Database[i])):\\n if self.Database[i][j] not in candidate:\\n candidate[self.Database[i][j]] = [i]\\n else:\\n candidate[self.Database[i][j]] += [i]\\n self.finalPatterns = {keys: value for keys, value in candidate.items() if len(value) >= self.minSup}\\n #print(candidate)\",\n \"def compute_visit_freq_table(self, episodes):\\n visited_states = {state: 0 for state in self._all_states}\\n visited_sets_episodes = []\\n for episode in episodes:\\n visited_set = set()\\n if episode.solved:\\n visited_set.add(self.goal_state)\\n states_batch = [self.obs2tuple(obs) for obs in\\n episode.transition_batch.observation]\\n for state in states_batch:\\n visited_states[state] += 1\\n visited_set.add(state)\\n self._visited_states_in_history.add(state)\\n visited_sets_episodes.append(visited_set)\\n if episode.solved:\\n visited_states[self.goal_state] += 1\\n\\n visited_freq = np.mean([len(x) / 3 ** self.n_disks\\n for x in visited_sets_episodes])\\n visited_states = {state: visited_states[state] /\\n (len(episodes) * 3 ** self.n_disks)\\n for state in self._all_states}\\n return visited_states, visited_freq\",\n \"def __len__(self):\\n i = 0\\n for S in self.states():\\n i += 1\\n return i\",\n \"def distr(self,X):\\r\\n return {x:X.count(x) for x in set(X)}\",\n \"def test_freq(self):\\n\\n Teffs, Lums, Teffs_out, Lums_out = [], [], [], []\\n for track in self.tracks:\\n for model in track.models:\\n if (not model.freq_sorted()):\\n print(model.name)\\n Teffs_out.append(model.string_to_param(\\\"Teff\\\"))\\n Lums_out.append(model.string_to_param(\\\"log_Luminosity\\\"))\\n else:\\n Teffs.append(model.string_to_param(\\\"Teff\\\"))\\n Lums.append(model.string_to_param(\\\"log_Luminosity\\\"))\\n return Teffs_out, Lums_out, Teffs, Lums\",\n \"def nf(self): # noqa: D401\\n return len(self._freqs)\",\n \"def frequency(self) -> NumType:\\n return self._freq\",\n \"def __calc_empirical_counts__(self):\\n self.empirical_counts = np.zeros(self._features_vector_length, dtype=float)\\n for feature, freq in self.features_dict.items():\\n for index in feature:\\n self.empirical_counts[index] += freq\\n assert len(self.empirical_counts) == np.count_nonzero(self.empirical_counts), \\\"0 in empirical counts vector\\\"\",\n \"def test_categorical_log_frequency():\\n # assert the distribution of the samples is close to the distribution of the data\\n # using cstest:\\n # - uniform (assert p-value > 0.05)\\n # - very skewed / biased? (assert p-value > 0.05)\\n # - inversely correlated (assert correlation < 0)\",\n \"def get_list_frequencies(self):\\r\\n return self.fs\",\n \"def frequencies(self):\\r\\n\\r\\n # Get the sampling rate from the seed time-series:\\r\\n self.method['Fs'] = self.method.get('Fs', self.seed.sampling_rate)\\r\\n NFFT = self.method.get('NFFT', 64)\\r\\n Fs = self.method.get('Fs')\\r\\n freqs = tsu.get_freqs(Fs, NFFT)\\r\\n lb_idx, ub_idx = tsu.get_bounds(freqs, self.lb, self.ub)\\r\\n\\r\\n return freqs[lb_idx:ub_idx]\",\n \"def test_getAbundanceFrequencyCounts(self):\\r\\n # Verified with iNEXT.\\r\\n exp = defaultdict(int, {1: 1, 2: 1, 3: 1, 4: 1, 5: 1})\\r\\n obs = self.est1.getAbundanceFrequencyCounts()\\r\\n self.assertEqual(obs, exp)\\r\\n\\r\\n # Verified against results in Colwell 2012 paper.\\r\\n self.assertEqual(self.est2.getAbundanceFrequencyCounts(), colwell_fk1)\\r\\n self.assertEqual(self.est3.getAbundanceFrequencyCounts(), colwell_fk2)\",\n \"def _test_get_a_freq(self):\\n for i, energy_test in enumerate(self.energy_list):\\n if i+1 < len(self.energy_list):\\n energy = (self.energy_list[i+1]+self.energy_list[i])/2.\\n else:\\n energy = (-self.energy_list[i-1]+2.*self.energy_list[i])\\n energy_test_2 = energy_test-1e-2\\n print i, energy_test_2, self._get_a_freq(energy_test_2)\\n print i, energy_test, self._get_a_freq(energy_test)\\n energy_test_2 = energy_test+1e-2\\n print i, energy_test_2, self._get_a_freq(energy_test_2)\\n print i, energy_test, 1./self.closed_orbits_t[energy_test]\\n print i, energy, self._get_a_freq(energy)\\n print\",\n \"def first_frequency_twice(changes: Sequence[int]) -> int:\\n frequency = 0\\n counts = {frequency: 1}\\n found = False\\n while not found:\\n for change in changes:\\n frequency += change\\n count = counts.get(frequency, 0) + 1\\n if count == 2:\\n found = True\\n break\\n counts[frequency] = count\\n return frequency\",\n \"def test_make_sorted_frequencies(self):\\r\\n\\r\\n # works on empty\\r\\n counts = array([])\\r\\n self.assertItemsEqual(make_sorted_frequencies(counts), [])\\r\\n\\r\\n # works on zeros\\r\\n counts = array([0, 0, 0, 0, 0, 0])\\r\\n self.assertItemsEqual(make_sorted_frequencies(counts), [])\\r\\n\\r\\n # works on flat data\\r\\n counts = array([3, 3, 3, 3, 3])\\r\\n expected_freqs = [0.2, 0.2, 0.2, 0.2, 0.2]\\r\\n observed_freqs = make_sorted_frequencies(counts)\\r\\n self.assertItemsEqual(observed_freqs, expected_freqs)\\r\\n\\r\\n # works on real data\\r\\n counts = array([1, 2, 0, 1, 0, 2, 4])\\r\\n expected_freqs = [0.4, 0.2, 0.2, 0.1, 0.1]\\r\\n observed_freqs = make_sorted_frequencies(counts)\\r\\n self.assertItemsEqual(observed_freqs, expected_freqs)\",\n \"def frequencies(self):\\n radii = self.radii\\n freqs = (1 / (self.shape[0] * self.pixel[0])) * radii\\n return freqs\",\n \"def _get_existence_frequency(self):\\n with np.errstate(invalid='ignore'):\\n return np.nan_to_num(self.existence_array / self.coverage_array * 100)\",\n \"def get_frequencies(self):\\n num_seconds = float(self.timestamps[-2] - self.timestamps[0]) / float(1000)\\n samples_per_second = len(self.data) / num_seconds\\n num_samples = len(self.data)\\n oscilations_per_sample = [float(oscilations) / num_samples for oscilations in range(0, num_samples)]\\n return [ops * samples_per_second for ops in oscilations_per_sample]\",\n \"def frequency(self) -> int:\\n return self._frequency\",\n \"def most_frequent(s):\\n\\n hist = make_histogram(s)\\n\\n t = []\\n for x, freq in hist.items():\\n t.append((freq, x))\\n \\n t.sort(reverse = True)\\n # print(t)\\n res = []\\n for freq, x in t:\\n res.append(x)\\n \\n return res\",\n \"def count():\",\n \"def __len__(self):\\n return self.data.index.get_level_values(0).to_series().nunique()\",\n \"def test_constant():\\n generator = SignalGenerator()\\n data = generator.constant()\\n freq_features = FrequencyFeature(data, sr=50)\\n freq_features.fft().peaks()\\n assert np.allclose(freq_features.dominant_frequency(n=1), np.zeros((1, 3)))\\n assert np.allclose(\\n freq_features.dominant_frequency_power(n=1), np.zeros((1, 3)))\",\n \"def getFrequencyDict(sequence):\\n # freqs: dictionary (element_type -> int)\\n freq = {}\\n for x in sequence:\\n freq[x] = freq.get(x,0) + 1\\n return freq\",\n \"def getFrequencyDict(sequence):\\n # freqs: dictionary (element_type -> int)\\n freq = {}\\n for x in sequence:\\n freq[x] = freq.get(x,0) + 1\\n return freq\",\n \"def getFrequencyDict(sequence):\\n # freqs: dictionary (element_type -> int)\\n freq = {}\\n for x in sequence:\\n freq[x] = freq.get(x,0) + 1\\n return freq\",\n \"def frequency(self, pt):\\n return math.floor(abs(self.id - pt.id) / 2)\",\n \"def find_repeating_frequency(values):\\n frequencies = set([0])\\n\\n index = 0\\n frequency = 0\\n while True:\\n found = False\\n for value in values:\\n frequency += value\\n index += 1\\n if frequency in frequencies:\\n found = True\\n break\\n\\n frequencies.add(frequency)\\n\\n if found:\\n break\\n\\n return frequency\",\n \"def freq_count(self):\\n #eg: fc = spammy.freq_count()\\n count_dict = defaultdict(int)\\n for entry in self._train_list:\\n if entry in self._vocab_set:\\n count_dict[entry] += 1\\n return count_dict\",\n \"def frequency(self, w, s=1.0):\\n x = w * s\\n # Heaviside mock\\n Hw = np.array(w)\\n Hw[w <= 0] = 0\\n Hw[w > 0] = 1\\n return np.pi ** -0.25 * Hw * np.exp((-((x - self.w0) ** 2)) / 2)\",\n \"def get_on_neurons(Fish,state):\\r\\n state_snap= Fish[state,:]\\r\\n \\r\\n label=[]\\r\\n for i in range(len(state_snap)):\\r\\n if state_snap[i]>2:\\r\\n label.append(1)\\r\\n else: \\r\\n label.append(0)\\r\\n return label\",\n \"def buildFrequencyDic(L):\\n pass\",\n \"def transitionfreq(molecule, transition) :\\n return s.transitionFreq(molecule, transition)\",\n \"def frequency(self):\\n return self.reference_clock_speed / 4096 / self.prescale_reg\",\n \"def unique(self):\\n # variables for uniques \\n self._currentSet = 1\\n self._uniqueValue = {}\\n\\n pd = self._dataTable\\n for col in pd:\\n arr = pd[col].unique()\\n for i in arr:\\n unique_entry = ((col,i),)\\n self._uniqueValue[unique_entry] = 0 \\n\\n self._sets[self._currentSet] = self._uniqueValue\",\n \"def information(self, fdist):\\n freq = fdist.get(self.string)\\n if not freq:\\n freq = 0\\n return 1 - (log(freq + 1) / log(fdist.N() + 1))\",\n \"def findClosed(freqSet, freqSup):\",\n \"def freqvals(t):\\n N = len(t)\\n T = t[-1] - t[0]\\n dt = T/N\\n nyquist = 1/(2.0*dt)\\n lowfreq = 1/T\\n return (N, T, dt, nyquist, lowfreq)\",\n \"def gc_frequency(self):\\n result = str(self.seq).count(\\\"G\\\") + str(self.seq).count(\\\"C\\\")\\n return result\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6752879","0.65904456","0.6134581","0.6110019","0.60763687","0.6033786","0.59830177","0.59820443","0.59509546","0.5918082","0.5894775","0.5856046","0.5792838","0.5790568","0.5765567","0.57557666","0.5713634","0.5709292","0.5696585","0.5632066","0.5631045","0.56084406","0.5596425","0.5577664","0.55766445","0.5558793","0.55511117","0.55439633","0.5538507","0.5530472","0.5513155","0.5510608","0.5498246","0.5498178","0.5488926","0.54777217","0.54749364","0.547179","0.54675287","0.5464524","0.5462033","0.54617107","0.5461074","0.5458332","0.54580224","0.54580224","0.5451022","0.5431946","0.5427432","0.54253435","0.54179794","0.5417851","0.54157174","0.5404364","0.5396904","0.53961384","0.5391775","0.53891706","0.53693306","0.5355366","0.53487694","0.5348221","0.53436285","0.5338781","0.5336731","0.533624","0.5323486","0.5314034","0.5304486","0.52999777","0.5292818","0.5291657","0.52881265","0.52814543","0.5273582","0.5271394","0.5269283","0.5262018","0.52509576","0.5247423","0.52471966","0.5245107","0.52423817","0.52418095","0.52318084","0.52318084","0.52318084","0.5231474","0.52284455","0.5220562","0.5218232","0.52132833","0.5209935","0.5197028","0.5193937","0.51925313","0.5191908","0.5191468","0.5187143","0.5184291"],"string":"[\n \"0.6752879\",\n \"0.65904456\",\n \"0.6134581\",\n \"0.6110019\",\n \"0.60763687\",\n \"0.6033786\",\n \"0.59830177\",\n \"0.59820443\",\n \"0.59509546\",\n \"0.5918082\",\n \"0.5894775\",\n \"0.5856046\",\n \"0.5792838\",\n \"0.5790568\",\n \"0.5765567\",\n \"0.57557666\",\n \"0.5713634\",\n \"0.5709292\",\n \"0.5696585\",\n \"0.5632066\",\n \"0.5631045\",\n \"0.56084406\",\n \"0.5596425\",\n \"0.5577664\",\n \"0.55766445\",\n \"0.5558793\",\n \"0.55511117\",\n \"0.55439633\",\n \"0.5538507\",\n \"0.5530472\",\n \"0.5513155\",\n \"0.5510608\",\n \"0.5498246\",\n \"0.5498178\",\n \"0.5488926\",\n \"0.54777217\",\n \"0.54749364\",\n \"0.547179\",\n \"0.54675287\",\n \"0.5464524\",\n \"0.5462033\",\n \"0.54617107\",\n \"0.5461074\",\n \"0.5458332\",\n \"0.54580224\",\n \"0.54580224\",\n \"0.5451022\",\n \"0.5431946\",\n \"0.5427432\",\n \"0.54253435\",\n \"0.54179794\",\n \"0.5417851\",\n \"0.54157174\",\n \"0.5404364\",\n \"0.5396904\",\n \"0.53961384\",\n \"0.5391775\",\n \"0.53891706\",\n \"0.53693306\",\n \"0.5355366\",\n \"0.53487694\",\n \"0.5348221\",\n \"0.53436285\",\n \"0.5338781\",\n \"0.5336731\",\n \"0.533624\",\n \"0.5323486\",\n \"0.5314034\",\n \"0.5304486\",\n \"0.52999777\",\n \"0.5292818\",\n \"0.5291657\",\n \"0.52881265\",\n \"0.52814543\",\n \"0.5273582\",\n \"0.5271394\",\n \"0.5269283\",\n \"0.5262018\",\n \"0.52509576\",\n \"0.5247423\",\n \"0.52471966\",\n \"0.5245107\",\n \"0.52423817\",\n \"0.52418095\",\n \"0.52318084\",\n \"0.52318084\",\n \"0.52318084\",\n \"0.5231474\",\n \"0.52284455\",\n \"0.5220562\",\n \"0.5218232\",\n \"0.52132833\",\n \"0.5209935\",\n \"0.5197028\",\n \"0.5193937\",\n \"0.51925313\",\n \"0.5191908\",\n \"0.5191468\",\n \"0.5187143\",\n \"0.5184291\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7312302"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84793,"cells":{"query":{"kind":"string","value":"Normalize the result with total execution time."},"document":{"kind":"string","value":"def percentage(self):\n temp = self.cpu_freq_time_spent.copy()\n for i in self.cpu_freq_time_spent:\n total = 0\n for j in self.cpu_freq_time_spent[i]:\n total += self.cpu_freq_time_spent[i][j]\n for j in self.cpu_freq_time_spent[i]:\n if total != 0:\n temp[i][j] = self.cpu_freq_time_spent[i][j] * 100 / total\n else:\n temp[i][j] = 0\n return temp"},"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 normalize(self):\n total = float(self.totalCount())\n if total != 0:\n self.divideAll(total)","def mean_run_time(self) -> float:\n return float(self.result_array.sum(axis=0).mean())","def normalize(self):\n total = self.total()\n for x in self.d:\n self.d[x] /= total\n return total","def _normalizeTime(self, t : float) -> float:\n return (t - self.t0)/self.tau","def finalize(self, trim):\n self.perf_delta.sort()\n if trim > 0:\n self.perf_delta = self.perf_delta[trim:-trim]\n self.perf_seconds = [v.total_seconds() for v in self.perf_delta]\n self.mean = timedelta(seconds=statistics.mean(self.perf_seconds))\n self.min = timedelta(seconds=min(self.perf_seconds))\n self.max = timedelta(seconds=max(self.perf_seconds))\n self.stdev = statistics.stdev(self.perf_seconds)","def normalize(self):\n total = float(self.totalCount())\n if total == 0: return\n for key in self.keys():\n self[key] = self[key] / total","def measure(self):\n # --- perform repeated runs\n for i_run in range(self.n_runs):\n if self.verbosity > 0:\n print(\"Run {0} / {1} ...\".format(i_run, self.n_runs), end = '')\n tdelta = self._timed_execute()\n self._run_times[i_run] = tdelta\n\t\t\t\n if self.verbosity == 2:\n print(tdelta)\n \n # calculate mean\n self._tmean = np.mean(self._run_times)\n # calculate standard deviation\n self._tstdev = np.std(self._run_times)\n # allow access to results\n self.__hasrun = True","def std_run_time(self) -> float:\n return float(self.result_array.sum(axis=0).std())","def averageTime(self):\n \n pass","def _normalizeDeltaTime(self, dt : float) -> float:\n return dt / self.tau","def normalize_emission(self):\n self._e /= self._e.sum(0)","def calc_stats(results):\r\n all_res = []\r\n count = 0\r\n for values in results.status_code_counter.values():\r\n all_res += values\r\n count += len(values)\r\n\r\n cum_time = sum(all_res)\r\n\r\n if cum_time == 0 or len(all_res) == 0:\r\n rps = avg = min_ = max_ = amp = 0\r\n else:\r\n if results.total_time == 0:\r\n rps = 0\r\n else:\r\n rps = len(all_res) / float(results.total_time)\r\n avg = sum(all_res) / len(all_res)\r\n max_ = max(all_res)\r\n min_ = min(all_res)\r\n amp = max(all_res) - min(all_res)\r\n stdev = math.sqrt(sum((x-avg)**2 for x in all_res) / count)\r\n\r\n return (\r\n RunStats(count, results.total_time, rps, avg, min_, max_, amp, stdev)\r\n )","def avgtime(self):\n return (self._total_time['value'] / 1000) / self._total_time['count'] if self._total_time['count'] else 0","def as_hms(self):\n if self._raw_seconds < 0:\n result = self._compute_positive_hms()\n for i in xrange(len(result)):\n if result[i]:\n result[i] = -result[i]\n break\n return result\n else:\n return self._compute_positive_hms()","def result (result = None):\n if result is not None:\n results.append (float (result))\n\n if len (results) < self.min_count:\n return None, None\n\n result_mean = functools.reduce (operator.add, results, 0) / len (results)\n result_error = (functools.reduce (operator.add,\n ((result - result_mean)**2 for result in results), 0) / (len (results) - 1))\n return result_mean, result_error","def avg_record_time(self):\n summed_time = 0\n for time_rec in self:\n try:\n summed_time += float(sanitize(time_rec))\n except Exception as err:\n return err\n return summed_time / len(self)","def total_time(self):\n time = 0\n for segment in self.data:\n segment_time = 0\n\n last_time = None\n\n for point in segment:\n current_time = point[\"time\"]\n\n # in case data is missing skip point !\n if current_time is None:\n continue\n\n # the first valid element is processed, get distance\n if not (last_time is None):\n try:\n a = dt.strptime(last_time, \"%Y-%m-%d %H:%M:%S.%f\")\n b = dt.strptime(current_time, \"%Y-%m-%d %H:%M:%S.%f\")\n except ValueError:\n a = dt.strptime(last_time, \"%Y-%m-%d %H:%M:%S\")\n b = dt.strptime(current_time, \"%Y-%m-%d %H:%M:%S\")\n time_difference = b - a\n segment_time += time_difference.seconds\n\n last_time = current_time\n\n time += segment_time\n\n return time","def get_total_time(self):\n\t\treturn call_sdk_function('PrlStatCpu_GetTotalTime', self.handle)","def normalizeResults(results, independentVariable, basis):\n normValues = {}\n if basis == \"min\":\n reduction = min\n elif basis == \"mean\":\n reduction = mean\n elif basis == \"max\":\n reduction = max\n\n print(\"Normalising by \" + basis)\n for k in results.keys():\n ik = k.split(\",\")[0]\n if ik not in normValues.keys():\n normValues[ik] = []\n values = []\n for iv in results[k].keys():\n values += [results[k][iv].__dict__[\"Mean\"]]\n normValues[ik] += values\n for ik in normValues.keys():\n normValues[ik] = reduction(normValues[ik])\n\n # And now scale everything\n for k in results.keys():\n ik = k.split(\",\")[0]\n norm = normValues[ik]\n experiment = results[k]\n for line in experiment.values():\n for value in line.__dict__.keys():\n if value == independentVariable:\n continue\n line.__dict__[value] = line.__dict__[value] / norm","def _rescale(self, result):\n if hasattr(self, \"std_statistics\"):\n if result.shape[-1] != self.std_statistics.shape[-1]:\n raise RuntimeError(\"The size of the statistics is not the same as the stored standard deviations for \"\n \"rescaling! Please check that you initialized the statistics with the correct set \"\n \"of reference samples.\")\n\n result = result / self.std_statistics\n\n return result","def zeroise_results(self):\n \n self.result_total_peak.set(0.0)\n self.result_total_avge.set(0.0)\n self.result_total_sd.set(0.0)\n return","def _fast_normalise(self):\n if not self.is_unit():\n mag_squared = np.dot(self.q, self.q)\n if (mag_squared == 0):\n return\n if (abs(1.0 - mag_squared) < 2.107342e-08):\n mag = ((1.0 + mag_squared) / 2.0) # More efficient. Pade approximation valid if error is small\n else:\n mag = sqrt(mag_squared) # Error is too big, take the performance hit to calculate the square root properly\n\n self.q = self.q / mag","def normalize(self) -> NoReturn:\n self._ionic_fractions = self._ionic_fractions / np.sum(self._ionic_fractions)","def normalize(self, normalizationLevel=\"minute\", fusionMethod=\"mean\", interpolationMethod=\"linear\"):\n raise NotImplementedError","def _prepare_for_stats(self):\n clean = self._discard_value(None)\n total = float(clean.total())\n return clean, total","def _compute_normalised_scores(self):\n\n results = self.snapshot['results']\n assg = AssignmentConfig().get_assignment()\n\n if results:\n self.snapshot['best_average_bugs_detected'] = \\\n max([results[submitter]['average_bugs_detected'] for submitter in results])\n self.snapshot['best_average_tests_evaded'] = \\\n max([results[submitter]['average_tests_evaded'] for submitter in results])\n\n for submitter in results.keys():\n submitter_bugs_detected = float(results[submitter]['average_bugs_detected'])\n submitter_tests_escaped = float(results[submitter]['average_tests_evaded'])\n\n results[submitter]['normalised_test_score'] = assg.compute_normalised_test_score(\n submitter_bugs_detected, self.snapshot['best_average_bugs_detected'],\n self.snapshot['results'][submitter]['average_tests_per_suite']\n )\n\n results[submitter]['normalised_prog_score'] = assg.compute_normalised_prog_score(\n submitter_tests_escaped, self.snapshot['best_average_tests_evaded']\n )\n\n # The current scoring algo for tests doesn't give the best test suite a maximums score.\n # re-normalise to make this happen\n best_test_score = max([results[submitter]['normalised_test_score'] for submitter in results.keys()])\n if best_test_score == 0:\n best_test_score = 1\n for submitter in results.keys():\n new_score = round(results[submitter]['normalised_test_score'] * (2.5 / best_test_score), 2)\n results[submitter]['normalised_test_score'] = new_score","def normalize_times(time,dtstart,dtend):\n time=np.datetime64(time)\n dtstart=np.datetime64(dtstart)\n dtend=np.datetime64(dtend)\n time_range = (dtend - dtstart).astype('float64')\n seconds_from_t0 = (time - dtstart).astype('float64')\n return seconds_from_t0 / time_range","def track_tick_processing_performance(self, duration):\n\n self.parse_count += 1\n self.total_parse_time += duration\n self.mean_parse_time = self.total_parse_time / self.parse_count","def _normalize(self, inp):\n \n return inp/inp.sum()","def output_stats(self):\n elapsed = self.timer.elapsed.total_seconds()\n count = self.copied + self.errored\n total = self.total\n # Time per key in milliseconds\n avg = round(elapsed / count * 1000, 3)\n # Time remaining in seconds\n remaining = 1.0 * elapsed / count * (total - count)\n # Time remaining in minutes\n remaining = round(remaining / 60.0, 1)\n # Time taken in minutes\n elapsed = round(elapsed / 60.0, 1)\n\n self.log.info(f\"{self.prefix}: {avg}ms avg, {elapsed}min passed, \"\n f\"{remaining}min remaining. ({count:,}/{total:,})\")","def normalize_transition(self):\n self._t /= self._t.sum(1)[:, np.newaxis]","def count_results(self):\n for record in self._traced_records:\n if self._statistical_results.get(record.name) == None:\n self._statistical_results[record.name] = StatisticalResult(\n record.name)\n self._statistical_results[record.name].insert_record(\n record.kernel_time)\n self._total_time_ms += record.kernel_time\n self._statistical_results = {\n k: v\n for k, v in sorted(self._statistical_results.items(),\n key=lambda item: item[1],\n reverse=True)\n }","def normalized_total_time(p, max_time=3600000):\n if \"cdgp.wasTimeout\" in p and p[\"cdgp.wasTimeout\"] == \"true\":\n v = 3600000\n else:\n v = int(float(p[\"result.totalTimeSystem\"]))\n return max_time if v > max_time else v","def get_average_execution_time_value(execution_time):\n if all_results_are_merged:\n # There will be multiple branch coverage results. Take\n # whatever is considered to be the \"average\".\n assert isinstance(execution_time, list)\n _, execution_time, _ = timing_range_fn(execution_time)\n return execution_time","def update_running_totals_from_load_step_results(self, results: dict) -> None:\n for result in results[\"step_results\"].values():\n sobject_name = result[\"sobject\"]\n totals = self.sobject_counts[sobject_name]\n totals.errors += result[\"total_row_errors\"]\n totals.successes += result[\"records_processed\"] - result[\"total_row_errors\"]","def _normalize(self):\n\n n = len(self.e2[0])\n E = []\n\n for e2 in self.e2:\n if len(e2) != n:\n print 'WARNING: non consistent length in error statistics!!!'\n E.append(np.nansum(np.sqrt(e2))) # temporal aggregation\n\n E = np.asarray(E)\n EM = E.mean() # take square root, as e2 is still the squared error!\n self.e_norm = (E - EM) / EM # see Glecker et al, eq.2","def calculate(self):\n avg = self.sum / self.n if self.n != 0 else 0\n self.running_avg.append(avg)\n return avg","def compute_statistics(self):","def calculate_query_times(**kwargs):\n trim_size = int(kwargs[\"trim\"] * len(kwargs[\"total_times\"]))\n return {\n \"total_time_avg\": round(numpy.mean(kwargs[\"total_times\"]), 1),\n \"total_time_min\": round(numpy.min(kwargs[\"total_times\"]), 1),\n \"total_time_max\": round(numpy.max(kwargs[\"total_times\"]), 1),\n \"total_time_85\": round(numpy.percentile(kwargs[\"total_times\"], 85), 1),\n \"total_time_trimmed_avg\": round(\n numpy.mean(\n numpy.sort(kwargs[\"total_times\"])[trim_size:-trim_size]\n ),\n 1,\n )\n if trim_size\n else round(numpy.mean(kwargs[\"total_times\"]), 1),\n \"total_times\": kwargs[\"total_times\"],\n \"execution_time_avg\": round(numpy.mean(kwargs[\"execution_times\"]), 1),\n \"execution_time_min\": round(numpy.min(kwargs[\"execution_times\"]), 1),\n \"execution_time_max\": round(numpy.max(kwargs[\"execution_times\"]), 1),\n \"execution_time_85\": round(\n numpy.percentile(kwargs[\"execution_times\"], 85), 1\n ),\n \"execution_time_25\": round(\n numpy.percentile(kwargs[\"execution_times\"], 25), 1\n ),\n \"execution_time_std\": round(numpy.std(kwargs[\"execution_times\"]), 1),\n \"execution_time_trimmed_avg\": round(\n numpy.mean(\n numpy.sort(kwargs[\"execution_times\"])[trim_size:-trim_size]\n )\n )\n if trim_size > 0\n else round(numpy.mean(kwargs[\"execution_times\"]), 1),\n \"execution_time_trimmed_max\": round(\n numpy.max(\n numpy.sort(kwargs[\"execution_times\"])[trim_size:-trim_size]\n )\n )\n if trim_size > 0\n else round(numpy.max(kwargs[\"execution_times\"]), 1),\n \"execution_times\": kwargs[\"execution_times\"],\n \"connect_time_avg\": round(numpy.mean(kwargs[\"connect_times\"]), 1),\n \"connect_time_min\": round(numpy.min(kwargs[\"connect_times\"]), 1),\n \"connect_time_max\": round(numpy.max(kwargs[\"connect_times\"]), 1),\n \"connect_time_85\": round(\n numpy.percentile(kwargs[\"connect_times\"], 85), 1\n ),\n \"arrow_conversion_time_avg\": round(\n numpy.mean(kwargs[\"arrow_conversion_times\"]), 1\n ),\n \"arrow_conversion_time_min\": round(\n numpy.min(kwargs[\"arrow_conversion_times\"]), 1\n ),\n \"arrow_conversion_time_max\": round(\n numpy.max(kwargs[\"arrow_conversion_times\"]), 1\n ),\n \"arrow_conversion_time_85\": round(\n numpy.percentile(kwargs[\"arrow_conversion_times\"], 85), 1\n ),\n \"arrow_conversion_time_25\": round(\n numpy.percentile(kwargs[\"arrow_conversion_times\"], 25), 1\n ),\n \"arrow_conversion_time_std\": round(\n numpy.std(kwargs[\"arrow_conversion_times\"]), 1\n ),\n }","def calculate_query_times(**kwargs):\n trim_size = int(kwargs[\"trim\"] * len(kwargs[\"total_times\"]))\n return {\n \"total_time_avg\": round(numpy.mean(kwargs[\"total_times\"]), 1),\n \"total_time_min\": round(numpy.min(kwargs[\"total_times\"]), 1),\n \"total_time_max\": round(numpy.max(kwargs[\"total_times\"]), 1),\n \"total_time_85\": round(numpy.percentile(kwargs[\"total_times\"], 85), 1),\n \"total_time_trimmed_avg\": round(\n numpy.mean(\n numpy.sort(kwargs[\"total_times\"])[trim_size:-trim_size]\n ),\n 1,\n )\n if trim_size\n else round(numpy.mean(kwargs[\"total_times\"]), 1),\n \"total_times\": kwargs[\"total_times\"],\n \"execution_time_avg\": round(numpy.mean(kwargs[\"execution_times\"]), 1),\n \"execution_time_min\": round(numpy.min(kwargs[\"execution_times\"]), 1),\n \"execution_time_max\": round(numpy.max(kwargs[\"execution_times\"]), 1),\n \"execution_time_85\": round(\n numpy.percentile(kwargs[\"execution_times\"], 85), 1\n ),\n \"execution_time_25\": round(\n numpy.percentile(kwargs[\"execution_times\"], 25), 1\n ),\n \"execution_time_std\": round(numpy.std(kwargs[\"execution_times\"]), 1),\n \"execution_time_trimmed_avg\": round(\n numpy.mean(\n numpy.sort(kwargs[\"execution_times\"])[trim_size:-trim_size]\n )\n )\n if trim_size > 0\n else round(numpy.mean(kwargs[\"execution_times\"]), 1),\n \"execution_time_trimmed_max\": round(\n numpy.max(\n numpy.sort(kwargs[\"execution_times\"])[trim_size:-trim_size]\n )\n )\n if trim_size > 0\n else round(numpy.max(kwargs[\"execution_times\"]), 1),\n \"execution_times\": kwargs[\"execution_times\"],\n \"connect_time_avg\": round(numpy.mean(kwargs[\"connect_times\"]), 1),\n \"connect_time_min\": round(numpy.min(kwargs[\"connect_times\"]), 1),\n \"connect_time_max\": round(numpy.max(kwargs[\"connect_times\"]), 1),\n \"connect_time_85\": round(\n numpy.percentile(kwargs[\"connect_times\"], 85), 1\n ),\n \"results_iter_time_avg\": round(\n numpy.mean(kwargs[\"results_iter_times\"]), 1\n ),\n \"results_iter_time_min\": round(\n numpy.min(kwargs[\"results_iter_times\"]), 1\n ),\n \"results_iter_time_max\": round(\n numpy.max(kwargs[\"results_iter_times\"]), 1\n ),\n \"results_iter_time_85\": round(\n numpy.percentile(kwargs[\"results_iter_times\"], 85), 1\n ),\n }","def _normalize(self):\r\n self.dataframe['norm_intensity'] = self.dataframe['intensity']\r\n self.dataframe['norm_intensity'] -= self.dataframe['norm_intensity'].min()\r\n self.dataframe['norm_intensity'] /= self.dataframe['norm_intensity'].max() * 0.01","def compute_stats(self):\n if self.stats is not None:\n return\n self.stats = np.zeros(STEPS_MAX + 1)\n for m in self.missions:\n m.compute_stats()\n self.stats += 100 * m.stats\n self.stats /= len(self.missions)","def normalize(self, data: pd.DataFrame) -> pd.DataFrame:\n\n if self.method == \"task\":\n for task in data[\"task_name\"].unique():\n if task in self.data_range.keys():\n task_min = self.data_range[task][\"min\"]\n task_max = self.data_range[task][\"max\"]\n task_data = data.loc[\n data[\"task_name\"] == task, self.perf_measure\n ].to_numpy()\n\n if task_min == task_max:\n data.loc[data[\"task_name\"] == task, self.perf_measure] = (\n task_data * 0\n ) + self.offset\n logger.warning(\n f\"Performance for task ({task}) is constant - normalizing to 0\"\n )\n else:\n data.loc[data[\"task_name\"] == task, self.perf_measure] = (\n (task_data - task_min) / (task_max - task_min) * self.scale\n ) + self.offset\n else:\n raise KeyError(f\"Missing data range for task '{task}'\")\n return data\n elif self.method == \"run\":\n data.loc[:, self.perf_measure] = (\n (data[self.perf_measure].to_numpy() - self.run_min)\n / (self.run_max - self.run_min)\n * self.scale\n ) + self.offset\n return data","def normalize(self):\n total = float(sum(self.values()))\n for key in self:\n self[key] /= total","def normalize(self):\n self._data /= self.norm()","def _filtrate_result(self, raw_result):\n fields = []\n maximum = {}\n minimum = {}\n average = {}\n\n time_marker = re.compile(\"^([0-9]+):([0-9]+):([0-9]+)$\")\n ampm_marker = re.compile(\"(AM|PM)$\")\n\n # Parse network utilization stats\n for row in raw_result.split('\\n'):\n line = row.split()\n\n if line and re.match(time_marker, line[0]):\n if re.match(ampm_marker, line[1]):\n del line[:2]\n\n if line[0] == 'IFACE':\n # header fields\n fields = line[1:]\n if len(fields) != NetUtilization.\\\n NET_UTILIZATION_FIELD_SIZE:\n raise RuntimeError(\"network_utilization: unexpected\\\n field size\", fields)\n else:\n # value fields\n net_interface = line[0]\n values = line[1:]\n\n if values and len(values) == len(fields):\n temp_dict = dict(zip(fields, values))\n if net_interface not in maximum:\n maximum[net_interface] = temp_dict\n else:\n for item in temp_dict:\n if float(maximum[net_interface][item]) <\\\n float(temp_dict[item]):\n maximum[net_interface][item] = \\\n temp_dict[item]\n\n if net_interface not in minimum:\n minimum[net_interface] = temp_dict\n else:\n for item in temp_dict:\n if float(minimum[net_interface][item]) >\\\n float(temp_dict[item]):\n minimum[net_interface][item] = \\\n temp_dict[item]\n else:\n raise RuntimeError(\"network_utilization: parse error\",\n fields, line)\n\n elif line and line[0] == 'Average:':\n del line[:1]\n\n if line[0] == 'IFACE':\n # header fields\n fields = line[1:]\n if len(fields) != NetUtilization.\\\n NET_UTILIZATION_FIELD_SIZE:\n raise RuntimeError(\"network_utilization average: \\\n unexpected field size\", fields)\n else:\n # value fields\n net_interface = line[0]\n values = line[1:]\n if values and len(values) == len(fields):\n average[net_interface] = dict(zip(fields, values))\n else:\n raise RuntimeError(\"network_utilization average: \\\n parse error\", fields, line)\n\n return {'network_utilization_maximun': maximum,\n 'network_utilization_minimum': minimum,\n 'network_utilization_average': average}","def get_time_elapsed(self, pipeline_run):\n begin = pipeline_run[\"steps\"][0][\"method_calls\"][0][\"start\"]\n begin_val = parse(begin)\n end = pipeline_run[\"steps\"][-1][\"method_calls\"][-1][\"end\"]\n end_val = parse(end)\n total_time = (end_val - begin_val).total_seconds()\n return total_time","def update_average(self,result):\n a = 1/self.iters\n b = 1 - a\n self.average = a * result + b * self.average\n self.iters += 1","def normalize(self):\n norm_val = self.sum2/self.sum1\n self.sum1=0\n\n for sentence in self.data_set:\n sentence.weight *= norm_val\n self.sum1 += sentence.weight","def calculate(self):\n if self.sampling_timer.IsRunning():\n return\n if self.daq.data0 == []:\n average = 0.0\n else:\n average = mean(self.daq.data0)\n res_string = '%.2f' %average\n self.control_box.result_box.SetLabel(res_string)","def calculate(self):\n #runs = [ai\n # for ei in self.experiment_queues\n # for ai in ei.cleaned_automated_runs]\n #\n #ni = len(runs)\n #self.nruns = ni\n # for ei in self.experiment_queues:\n # dur=ei.stats.calculate_duration(ei.cleaned_automated_runs)\n # if\n\n\n tt = sum([ei.stats.calculate_duration(ei.cleaned_automated_runs)\n for ei in self.experiment_queues])\n self._total_time = tt\n offset = 0\n if self._start_time:\n offset = time.time() - self._start_time\n\n self.etf = self.format_duration(tt - offset)","def estimated_time(self):\n self._update()\n if not self.running_mode:\n return 0 if self._is_finished() else float(\"nan\")\n elif self.running_mode == \"local\":\n start = self.processes[0].create_time()\n elif self.running_mode == \"grid\":\n start = self.job[\"start_time\"]\n if start == 0:\n # Queued, but not started\n return float(\"nan\")\n else:\n logger.warning(\"Invalid running_mode attribute\")\n return float(\"nan\")\n current = self.current_step()\n if current <= 0: # If not dumped yet or error\n return float('nan')\n else:\n elapsed = time() - start\n return elapsed * (self.total_steps / current - 1)","def test_compute_unnormalized_scores(self):\n # todo: implement this test!\n pass","def normalize(self):\n total = float(sum(self.values()))\n for key in self:\n self[key] /= total","def total_seconds(self):\n return 0","def running_ratio(self) -> np.ndarray:\n result_array = self.result_array\n result = result_array.sum(axis=1) / result_array.sum()\n\n if isinstance(result, np.ndarray):\n result_out = result\n else:\n result_out = np.array(result)\n\n return result_out","def total_time(self):\n obs_times = self.clean_obs_times()\n return _np.sum(obs_times[:, 1] - obs_times[:, 0])","def _compute_normalization(self, normalize=True):\n if normalize:\n if self._img_norm is None:\n if np.sum(self._data) == 0:\n self._img_norm = 1\n else:\n self._img_norm = self._compute_raw_image_norm()\n\n if self._img_norm != 0.0 and np.isfinite(self._img_norm):\n self._data /= (self._img_norm * self._normalization_correction)\n self._normalization_status = 0\n else:\n self._normalization_status = 1\n self._img_norm = 1\n warnings.warn('Overflow encountered while computing '\n 'normalization constant. Normalization '\n 'constant will be set to 1.', NonNormalizable)\n else:\n self._normalization_status = 2","def _compute_duration(self):\n diff_float = 0\n for ts_line in self:\n if ts_line.x_start_date:\n st_datetime = fields.Datetime.from_string(\n ts_line.x_start_date)\n # autocomplete date from start date\n st_date_tz = fields.Datetime.context_timestamp(\n self, st_datetime).date()\n ts_line.date = st_date_tz\n\n # autocomplete name from start date\n st_datetime_tz = fields.Datetime.context_timestamp(\n self, st_datetime)\n string_st_dt_tz = fields.Datetime.to_string(st_datetime_tz)\n ts_line.name = ts_line.user_id.name + '/' + string_st_dt_tz\n\n en_datetime = fields.Datetime.from_string(\n ts_line.x_end_date)\n diff = en_datetime - st_datetime\n if(time(1, 00) <= st_datetime.time() <= time(5, 00)):\n if(time(6, 00) <= en_datetime.time() <= time(10, 00)):\n # del 1 hour for breaking lunch\n diff_float = round(diff.total_seconds() / 3600.0, 2)-1\n else:\n diff_float = round(diff.total_seconds() / 3600.0, 2)\n ts_line.unit_amount = diff_float","def evaluate(self, time) -> float:\n ...","def get_summarized_results(self):\n stats = [v.stats() for (k, v) in self.examples.items() if v.is_ready()]\n res = self.ExampleClass.average_stats(stats)\n\n res['loss'] = self.loss/self.loss_cnt\n res['recent_loss'] = sum(self.recent_loss_array) / sum(self.recent_loss_bs_array)\n\n return res","def reset_duration(self):\n self._duration_start = time.perf_counter()\n return self._duration_start","def _append_results(self) -> None:\n self._t_mps.compute_traces(self._step, self._process_tensors)\n time = self.time(self._step)\n norm = self._t_mps.get_norm()\n bond_dimensions = self._t_mps.get_bond_dimensions()\n self._results['time'].append(time)\n self._results['norm'].append(norm)\n self._results['bond_dimensions'].append(bond_dimensions)\n for sites, dynamics in self._results['dynamics'].items():\n if isinstance(sites, int):\n sites_list = [sites]\n else:\n sites_list = list(sites)\n dynamics.add(\n time,\n self._t_mps.get_density_matrix(sites_list))\n self._t_mps.clear_traces()","def avg_inference_time(self):\n return self._avg_inference_time","def get_post_stats(self):\n stats = self.stats\n stats.results = self.job.result().get_counts(stats.iteration)\n stats.datetime = str(datetime.now())","def test_cpu_total_work(self):\n import time\n from supvisors.statistics import instant_cpu_statistics, cpu_total_work\n # take 2 spaced instant cpu statistics\n ref_stats = instant_cpu_statistics()\n time.sleep(1)\n last_stats = instant_cpu_statistics()\n total_work = cpu_total_work(last_stats, ref_stats)\n # total work should be quite close to sleeping time\n self.assertAlmostEqual(1, total_work, 1)","def calculate(self):\n self.results['max'] = numpy.max(self.data)\n self.results['min'] = numpy.min(self.data)\n if self.type == 0:\n self.group_discrete_data()\n if self.type == 1:\n self.group_continuous_data()\n\n self.results['arithAvg'] = self.average([self.data[i] * self.occurrences[i] for i in range(len(self.data))],\n self.totalOccurrences)\n self.results['quadAvg'] = math.sqrt(\n self.average([(self.data[i] * self.data[i]) * self.occurrences[i] for i in range(len(self.data))],\n self.totalOccurrences))\n if self.results['min'] > 0:\n self.results['geoAvg'] = math.exp(\n self.average([numpy.log(self.data[i]) * self.occurrences[i] for i in range(len(self.data))],\n self.totalOccurrences))\n self.results['harmAvg'] = 1 / self.average(\n [(self.occurrences[i] / self.data[i]) for i in range(len(self.data))],\n self.totalOccurrences)\n else:\n self.results['geoAvg'] = self.results['harmAvg'] = \"N/A\"\n self.results['momentsR'] = self.moments(self.data, self.occurrences, 4)\n self.results['centralMomentsR'] = self.moments([(i - self.results['arithAvg']) for i in self.data],\n self.occurrences, 4)\n self.results['std'] = self.average(\n [self.occurrences[i] * abs(self.data[i] - self.results['arithAvg']) for i in range(len(self.data))],\n self.totalOccurrences)","def normalization_calculation(self) -> None:\n self.normalized_inventory = (\n self.normalization_matrix * self.characterized_inventory\n )","def __calculateNormalizedScores(self):\n year_scores = {0 : []}\n for venue in self.venue_scores:\n v_scores = []\n for year in self.venue_scores[venue]:\n v_scores.append(self.venue_scores[venue][year])\n if year not in year_scores:\n year_scores[year] = []\n year_scores[year].append(self.venue_scores[venue][year])\n x_year = np.average(np.array(v_scores))\n self.venue_scores[venue][0] = x_year\n year_scores[0].append(x_year)\n \n ##for standardization\n #year_metrics = {x : (np.average(np.array(year_scores[x])), np.std(np.array(year_scores[x]))) for x in year_scores}\n ##for normalization\n year_metrics = {x: (max(year_scores[x]), min(year_scores[x])) for x in year_scores}\n \n #print year_metrics\n \n for venue in self.venue_scores:\n self.normalized_scores[venue] = dict()\n for year in self.venue_scores[venue]:\n #self.standard_scores[venue][year] = round((self.venue_scores[venue][year] - year_metrics[year][0]) / year_metrics[year][1],5)\n #self.normalized_scores[venue][year] = (self.venue_scores[venue][year] - year_metrics[year][1]) / (year_metrics[year][0] - year_metrics[year][1]) + eps\n self.normalized_scores[venue][year] = (self.venue_scores[venue][year] - year_metrics[year][1] + self.epsilon) / (year_metrics[year][0] - year_metrics[year][1] + self.epsilon)","def sum(self):\n\n return time_stat(self, stat=\"sum\")","def __unwrapResults(self):\n if self.__cachedResults is None:\n if self.__rawInfo.results is not None:\n resultList = json.loads(self.__rawInfo.results)\n assert len(resultList) == 2, \\\n \"Expected 2 elements, but got %s (%s).\" % (\n len(resultList), resultList)\n self.__cachedResults = self.ModelResults(\n reportMetrics=resultList[0],\n optimizationMetrics=resultList[1])\n else:\n self.__cachedResults = self.ModelResults(\n reportMetrics={},\n optimizationMetrics={})\n\n\n return self.__cachedResults","def _compute_normalization(self, normalize=True):\n self._normalization_constant = 1.0 / self._normalization_correction\n\n if normalize:\n # compute normalization constant so that\n # N*C*sum(data) = 1:\n if self._img_norm is None:\n self._img_norm = self._compute_raw_image_norm()\n\n if self._img_norm != 0.0 and np.isfinite(self._img_norm):\n self._normalization_constant /= self._img_norm\n self._normalization_status = 0\n\n else:\n self._normalization_constant = 1.0\n self._normalization_status = 1\n warnings.warn(\"Overflow encountered while computing \"\n \"normalization constant. Normalization \"\n \"constant will be set to 1.\", NonNormalizable)\n\n else:\n self._normalization_status = 2","def slow_update_duration(self):\n for i in range(len(self.data_file.sorted_data)):\n if self.data_file.sorted_data[i]['type'] == 'slow':\n slow_upd = self.data_file.sorted_data[i]['timestamp']\n Config.ANALYSIS.write(f\"slow at: {slow_upd}\\n\")\n if i == 0:\n after_slow = self.data_file.sorted_data[i + 1]['timestamp']\n Config.ANALYSIS.write(f\"after slow: ({slow_upd}, {after_slow}) \"\n f\"= {after_slow - slow_upd}\\n\\n\")\n elif i == len(self.data_file.sorted_data) - 1:\n before_slow = self.data_file.sorted_data[i - 1]['timestamp']\n Config.ANALYSIS.write(f\"before slow: ({before_slow}, {slow_upd}) \"\n f\"= {slow_upd - before_slow}\\n\\n\")\n else:\n before_slow = self.data_file.sorted_data[i - 1]['timestamp']\n after_slow = self.data_file.sorted_data[i + 1]['timestamp']\n Config.ANALYSIS.write(f\"before slow: ({before_slow}, {slow_upd}) \"\n f\"= {slow_upd - before_slow}\\n\")\n Config.ANALYSIS.write(f\"after slow: ({slow_upd}, {after_slow}) \"\n f\"= {after_slow - slow_upd}\\n\\n\")\n Config.ANALYSIS.write(\"\\n\\n\")","def _calculate_runtime(self):\n lines = self.file_dic['output'].splitlines()\n start_time = datetime.strptime(lines[0].strip(), self.timestring_format)\n fin_time = datetime.strptime(lines[-1].strip(), self.timestring_format)\n dif = fin_time - start_time\n self.date = fin_time.strftime('%d %b %Y')\n self.runtime = dif.total_seconds()","def _GetNormalizedTimestamp(self):\n if self._normalized_timestamp is None:\n if (self._number_of_seconds is not None and\n self.fraction_of_second is not None):\n self._normalized_timestamp = (\n decimal.Decimal(self._number_of_seconds) + self.fraction_of_second)\n\n return self._normalized_timestamp","def Analyze(self):\n \n self._analyzeLogs()\n for user in self._start_times:\n self._result[user] = self._zipTimes(user)","def _do_subject_normalize(output_dir,\n segment_result=None,\n do_report=True,\n results_gallery=None,\n progress_logger=None,\n brain=\"EPI\",\n cmap=None,\n fwhm=0,\n **spm_normalize_kwargs):\n\n nipype_report_filenames = []\n\n # sanity\n def get_norm_apply_to_files(files):\n if isinstance(files, basestring):\n norm_apply_to_files = files\n file_types = 'string'\n else:\n file_types = []\n norm_apply_to_files = []\n for x in files:\n if isinstance(x, basestring):\n norm_apply_to_files.append(x)\n file_types.append('string')\n else:\n norm_apply_to_files += x\n file_types.append(('list', len(x)))\n\n return norm_apply_to_files, file_types\n\n if 'apply_to_files' in spm_normalize_kwargs:\n spm_normalize_kwargs['apply_to_files'], file_types = \\\n get_norm_apply_to_files(spm_normalize_kwargs['apply_to_files'])\n\n output = {}\n\n # prepare for smart caching\n cache_dir = os.path.join(output_dir, 'cache_dir')\n if not os.path.exists(cache_dir):\n os.makedirs(cache_dir)\n mem = Memory(base_dir=cache_dir)\n\n # run workflow\n normalize = mem.cache(spm.Normalize)\n norm_result = normalize(**spm_normalize_kwargs)\n\n # collect ouput\n output['result'] = norm_result\n if not norm_result.outputs is None:\n normalized_files = norm_result.outputs.normalized_files\n\n # define execution log html output filename\n execution_log_html_filename = os.path.join(\n output_dir,\n 'normalization_of_%s_execution_log.html' % brain,\n )\n\n # grab execution log\n execution_log = preproc_reporter.get_nipype_report(\n preproc_reporter.get_nipype_report_filename(normalized_files))\n\n # write execution log\n open(execution_log_html_filename, 'w').write(\n execution_log)\n\n # update progress bar\n if progress_logger:\n progress_logger.log(\n '<b>Normalization of %s</b><br/><br/>' % brain)\n progress_logger.log(execution_log)\n progress_logger.log('<hr/>')\n\n # do smoothing\n if np.sum(fwhm):\n smooth = mem.cache(spm.Smooth)\n smooth_result = smooth(\n in_files=output['result'].outputs.normalized_files,\n fwhm=fwhm)\n\n # collect ouput\n output['result'] = smooth_result\n if not smooth_result.outputs is None:\n normalized_files = smooth_result.outputs.smoothed_files\n output['normalized_files'] = normalized_files\n\n # grab execution log\n execution_log = preproc_reporter.get_nipype_report(\n preproc_reporter.get_nipype_report_filename(\n normalized_files))\n\n # write execution log\n open(execution_log_html_filename, 'w').write(\n execution_log)\n\n # update progress bar\n if progress_logger:\n progress_logger.log(\n '<b>Smoothening of %s</b><br/><br/>' % brain)\n progress_logger.log(execution_log)\n progress_logger.log('<hr/>')\n\n if 'apply_to_files' in spm_normalize_kwargs:\n if not isinstance(file_types, basestring):\n _tmp = []\n s = 0\n for x in file_types:\n if x == 'string':\n if isinstance(normalized_files, basestring):\n _tmp = normalized_files\n break\n else:\n _tmp.append(\n normalized_files[s])\n s += 1\n else:\n _tmp.append(\n normalized_files[s: s + x[1]])\n s += x[1]\n\n normalized_files = _tmp\n\n output['normalized_files'] = normalized_files\n\n # generate gallery for HTML report\n if do_report:\n if normalized_files:\n if segment_result:\n subject_gm_file = segment_result.outputs.modulated_gm_image\n subject_wm_file = segment_result.outputs.modulated_wm_image\n subject_csf_file = segment_result.outputs.modulated_csf_image\n else:\n subject_gm_file = None\n subject_wm_file = None\n subject_csf_file = None\n\n nipype_report_filenames = [\n preproc_reporter.get_nipype_report_filename(\n subject_gm_file)] + nipype_report_filenames\n\n # generate normalization thumbs\n output.update(preproc_reporter.generate_normalization_thumbnails(\n normalized_files,\n output_dir,\n brain=brain,\n execution_log_html_filename=execution_log_html_filename,\n results_gallery=results_gallery,\n ))\n\n # generate segmentation thumbs\n output.update(preproc_reporter.generate_segmentation_thumbnails(\n normalized_files,\n output_dir,\n subject_gm_file=subject_gm_file,\n subject_wm_file=subject_wm_file,\n subject_csf_file=subject_csf_file,\n brain=brain,\n execution_log_html_filename=execution_log_html_filename,\n cmap=cmap,\n results_gallery=results_gallery))\n\n # collect ouput\n output['result'] = norm_result\n\n return output","def execute_time(self, value):\n # unfied unit and rounded to two decimals\n unfied_execute_time = convert_execute_time_to_ms(value)\n self._execute_time = round(unfied_execute_time, 2)","def test_instant_cpu_statistics(self):\n import multiprocessing\n from supvisors.statistics import instant_cpu_statistics\n stats = instant_cpu_statistics()\n # test number of results (number of cores + average)\n self.assertEqual(multiprocessing.cpu_count() + 1, len(stats))\n # test average value\n total_work = total_idle = 0\n for cpu in stats[1:]:\n self.assertEqual(2, len(cpu))\n work, idle = cpu\n total_work += work\n total_idle += idle\n self.assertAlmostEqual(stats[0][0], total_work / multiprocessing.cpu_count())\n self.assertAlmostEqual(stats[0][1], total_idle / multiprocessing.cpu_count())","def normalized(self):\n return self / self.norm()","def compute_utilization(self) -> float:\r\n return self._compute_utilization","def measure(self):\n self.completed = False\n self.message = ''\n for res in self.results:\n self.results[res] = None\n return self","def runtime(self):\n return (self.time - self.start).total_seconds()","def compute_time_step():\n\n dt = Hydro.compute_time_step()\n\n return dt","async def compute(self, duration: Optional[Number]) -> None:\n await envs.sleep(duration)\n self.total_compute_time += duration","def compute_values(self, update_statistics=False):\n\n self.compute_iterations()\n self.axsec = sum([one.axsec for one in self])\n self.xsec = sum([one.xsec for one in self])\n self.xerrc = sum([one.xerrc for one in self])\n self.xerru = math.sqrt(sum([one.xerru**2 for one in self]))\n\n self.nevents = sum([one.nevents for one in self])\n self.nw = sum([one.nw for one in self])\n self.maxit = len(self.yerr_iter) # \n self.nunwgt = sum([one.nunwgt for one in self]) \n self.wgt = 0\n self.luminosity = min([0]+[one.luminosity for one in self])\n if update_statistics:\n self.run_statistics.aggregate_statistics([_.run_statistics for _ in self])","def _GetNormalizedTimestamp(self):\n if self._normalized_timestamp is None:\n if self._number_of_seconds is not None:\n self._normalized_timestamp = (\n decimal.Decimal(self._deciseconds) /\n definitions.DECISECONDS_PER_SECOND)\n self._normalized_timestamp += decimal.Decimal(self._number_of_seconds)\n\n if self._time_zone_offset:\n self._normalized_timestamp -= self._time_zone_offset * 60\n\n return self._normalized_timestamp","def __call__(self, results):\n for key in results.get('img_fields', ['img']):\n results[key] = general_ocr.imnormalize(results[key], self.mean, self.std,\n self.to_rgb)\n results['img_norm_cfg'] = dict(\n mean=self.mean, std=self.std, to_rgb=self.to_rgb)\n return results","def process(self, data):\n return data - np.mean(data)","def normalize(self):\n return Vector(self.args + []) / self.magnitude()","def cpu_time(self):","def measure(self):\n pass","def normalize_initial(self):\n self._i /= self._i.sum()","def divide_by_temporal_std(self):\n if not hasattr(self, 'mean_removed_data'):\n self.remove_temporal_mean()\n self.std_divided_data = self.mean_removed_data / \\\n np.std(self.mean_removed_data, axis=-1, keepdims=True)","def avg(self):\n return sum(self.times) / len(self.times)","def avg(self):\n return sum(self.times) / len(self.times)","def avg(self):\n return sum(self.times) / len(self.times)","def elapsed():\n global start_time\n return time.time() - start_time","def as_unit(self):\n new_vec = self.copy()\n new_vec.normalize()\n return new_vec","def computation_time(self) -> float:\r\n if self._computation_times is None:\r\n return None\r\n else:\r\n return self._computation_times[0]","def avg_extend_time(self):\r\n if self.total_extended:\r\n return self.total_extend_time/self.total_extended\r\n else: return 0"],"string":"[\n \"def normalize(self):\\n total = float(self.totalCount())\\n if total != 0:\\n self.divideAll(total)\",\n \"def mean_run_time(self) -> float:\\n return float(self.result_array.sum(axis=0).mean())\",\n \"def normalize(self):\\n total = self.total()\\n for x in self.d:\\n self.d[x] /= total\\n return total\",\n \"def _normalizeTime(self, t : float) -> float:\\n return (t - self.t0)/self.tau\",\n \"def finalize(self, trim):\\n self.perf_delta.sort()\\n if trim > 0:\\n self.perf_delta = self.perf_delta[trim:-trim]\\n self.perf_seconds = [v.total_seconds() for v in self.perf_delta]\\n self.mean = timedelta(seconds=statistics.mean(self.perf_seconds))\\n self.min = timedelta(seconds=min(self.perf_seconds))\\n self.max = timedelta(seconds=max(self.perf_seconds))\\n self.stdev = statistics.stdev(self.perf_seconds)\",\n \"def normalize(self):\\n total = float(self.totalCount())\\n if total == 0: return\\n for key in self.keys():\\n self[key] = self[key] / total\",\n \"def measure(self):\\n # --- perform repeated runs\\n for i_run in range(self.n_runs):\\n if self.verbosity > 0:\\n print(\\\"Run {0} / {1} ...\\\".format(i_run, self.n_runs), end = '')\\n tdelta = self._timed_execute()\\n self._run_times[i_run] = tdelta\\n\\t\\t\\t\\n if self.verbosity == 2:\\n print(tdelta)\\n \\n # calculate mean\\n self._tmean = np.mean(self._run_times)\\n # calculate standard deviation\\n self._tstdev = np.std(self._run_times)\\n # allow access to results\\n self.__hasrun = True\",\n \"def std_run_time(self) -> float:\\n return float(self.result_array.sum(axis=0).std())\",\n \"def averageTime(self):\\n \\n pass\",\n \"def _normalizeDeltaTime(self, dt : float) -> float:\\n return dt / self.tau\",\n \"def normalize_emission(self):\\n self._e /= self._e.sum(0)\",\n \"def calc_stats(results):\\r\\n all_res = []\\r\\n count = 0\\r\\n for values in results.status_code_counter.values():\\r\\n all_res += values\\r\\n count += len(values)\\r\\n\\r\\n cum_time = sum(all_res)\\r\\n\\r\\n if cum_time == 0 or len(all_res) == 0:\\r\\n rps = avg = min_ = max_ = amp = 0\\r\\n else:\\r\\n if results.total_time == 0:\\r\\n rps = 0\\r\\n else:\\r\\n rps = len(all_res) / float(results.total_time)\\r\\n avg = sum(all_res) / len(all_res)\\r\\n max_ = max(all_res)\\r\\n min_ = min(all_res)\\r\\n amp = max(all_res) - min(all_res)\\r\\n stdev = math.sqrt(sum((x-avg)**2 for x in all_res) / count)\\r\\n\\r\\n return (\\r\\n RunStats(count, results.total_time, rps, avg, min_, max_, amp, stdev)\\r\\n )\",\n \"def avgtime(self):\\n return (self._total_time['value'] / 1000) / self._total_time['count'] if self._total_time['count'] else 0\",\n \"def as_hms(self):\\n if self._raw_seconds < 0:\\n result = self._compute_positive_hms()\\n for i in xrange(len(result)):\\n if result[i]:\\n result[i] = -result[i]\\n break\\n return result\\n else:\\n return self._compute_positive_hms()\",\n \"def result (result = None):\\n if result is not None:\\n results.append (float (result))\\n\\n if len (results) < self.min_count:\\n return None, None\\n\\n result_mean = functools.reduce (operator.add, results, 0) / len (results)\\n result_error = (functools.reduce (operator.add,\\n ((result - result_mean)**2 for result in results), 0) / (len (results) - 1))\\n return result_mean, result_error\",\n \"def avg_record_time(self):\\n summed_time = 0\\n for time_rec in self:\\n try:\\n summed_time += float(sanitize(time_rec))\\n except Exception as err:\\n return err\\n return summed_time / len(self)\",\n \"def total_time(self):\\n time = 0\\n for segment in self.data:\\n segment_time = 0\\n\\n last_time = None\\n\\n for point in segment:\\n current_time = point[\\\"time\\\"]\\n\\n # in case data is missing skip point !\\n if current_time is None:\\n continue\\n\\n # the first valid element is processed, get distance\\n if not (last_time is None):\\n try:\\n a = dt.strptime(last_time, \\\"%Y-%m-%d %H:%M:%S.%f\\\")\\n b = dt.strptime(current_time, \\\"%Y-%m-%d %H:%M:%S.%f\\\")\\n except ValueError:\\n a = dt.strptime(last_time, \\\"%Y-%m-%d %H:%M:%S\\\")\\n b = dt.strptime(current_time, \\\"%Y-%m-%d %H:%M:%S\\\")\\n time_difference = b - a\\n segment_time += time_difference.seconds\\n\\n last_time = current_time\\n\\n time += segment_time\\n\\n return time\",\n \"def get_total_time(self):\\n\\t\\treturn call_sdk_function('PrlStatCpu_GetTotalTime', self.handle)\",\n \"def normalizeResults(results, independentVariable, basis):\\n normValues = {}\\n if basis == \\\"min\\\":\\n reduction = min\\n elif basis == \\\"mean\\\":\\n reduction = mean\\n elif basis == \\\"max\\\":\\n reduction = max\\n\\n print(\\\"Normalising by \\\" + basis)\\n for k in results.keys():\\n ik = k.split(\\\",\\\")[0]\\n if ik not in normValues.keys():\\n normValues[ik] = []\\n values = []\\n for iv in results[k].keys():\\n values += [results[k][iv].__dict__[\\\"Mean\\\"]]\\n normValues[ik] += values\\n for ik in normValues.keys():\\n normValues[ik] = reduction(normValues[ik])\\n\\n # And now scale everything\\n for k in results.keys():\\n ik = k.split(\\\",\\\")[0]\\n norm = normValues[ik]\\n experiment = results[k]\\n for line in experiment.values():\\n for value in line.__dict__.keys():\\n if value == independentVariable:\\n continue\\n line.__dict__[value] = line.__dict__[value] / norm\",\n \"def _rescale(self, result):\\n if hasattr(self, \\\"std_statistics\\\"):\\n if result.shape[-1] != self.std_statistics.shape[-1]:\\n raise RuntimeError(\\\"The size of the statistics is not the same as the stored standard deviations for \\\"\\n \\\"rescaling! Please check that you initialized the statistics with the correct set \\\"\\n \\\"of reference samples.\\\")\\n\\n result = result / self.std_statistics\\n\\n return result\",\n \"def zeroise_results(self):\\n \\n self.result_total_peak.set(0.0)\\n self.result_total_avge.set(0.0)\\n self.result_total_sd.set(0.0)\\n return\",\n \"def _fast_normalise(self):\\n if not self.is_unit():\\n mag_squared = np.dot(self.q, self.q)\\n if (mag_squared == 0):\\n return\\n if (abs(1.0 - mag_squared) < 2.107342e-08):\\n mag = ((1.0 + mag_squared) / 2.0) # More efficient. Pade approximation valid if error is small\\n else:\\n mag = sqrt(mag_squared) # Error is too big, take the performance hit to calculate the square root properly\\n\\n self.q = self.q / mag\",\n \"def normalize(self) -> NoReturn:\\n self._ionic_fractions = self._ionic_fractions / np.sum(self._ionic_fractions)\",\n \"def normalize(self, normalizationLevel=\\\"minute\\\", fusionMethod=\\\"mean\\\", interpolationMethod=\\\"linear\\\"):\\n raise NotImplementedError\",\n \"def _prepare_for_stats(self):\\n clean = self._discard_value(None)\\n total = float(clean.total())\\n return clean, total\",\n \"def _compute_normalised_scores(self):\\n\\n results = self.snapshot['results']\\n assg = AssignmentConfig().get_assignment()\\n\\n if results:\\n self.snapshot['best_average_bugs_detected'] = \\\\\\n max([results[submitter]['average_bugs_detected'] for submitter in results])\\n self.snapshot['best_average_tests_evaded'] = \\\\\\n max([results[submitter]['average_tests_evaded'] for submitter in results])\\n\\n for submitter in results.keys():\\n submitter_bugs_detected = float(results[submitter]['average_bugs_detected'])\\n submitter_tests_escaped = float(results[submitter]['average_tests_evaded'])\\n\\n results[submitter]['normalised_test_score'] = assg.compute_normalised_test_score(\\n submitter_bugs_detected, self.snapshot['best_average_bugs_detected'],\\n self.snapshot['results'][submitter]['average_tests_per_suite']\\n )\\n\\n results[submitter]['normalised_prog_score'] = assg.compute_normalised_prog_score(\\n submitter_tests_escaped, self.snapshot['best_average_tests_evaded']\\n )\\n\\n # The current scoring algo for tests doesn't give the best test suite a maximums score.\\n # re-normalise to make this happen\\n best_test_score = max([results[submitter]['normalised_test_score'] for submitter in results.keys()])\\n if best_test_score == 0:\\n best_test_score = 1\\n for submitter in results.keys():\\n new_score = round(results[submitter]['normalised_test_score'] * (2.5 / best_test_score), 2)\\n results[submitter]['normalised_test_score'] = new_score\",\n \"def normalize_times(time,dtstart,dtend):\\n time=np.datetime64(time)\\n dtstart=np.datetime64(dtstart)\\n dtend=np.datetime64(dtend)\\n time_range = (dtend - dtstart).astype('float64')\\n seconds_from_t0 = (time - dtstart).astype('float64')\\n return seconds_from_t0 / time_range\",\n \"def track_tick_processing_performance(self, duration):\\n\\n self.parse_count += 1\\n self.total_parse_time += duration\\n self.mean_parse_time = self.total_parse_time / self.parse_count\",\n \"def _normalize(self, inp):\\n \\n return inp/inp.sum()\",\n \"def output_stats(self):\\n elapsed = self.timer.elapsed.total_seconds()\\n count = self.copied + self.errored\\n total = self.total\\n # Time per key in milliseconds\\n avg = round(elapsed / count * 1000, 3)\\n # Time remaining in seconds\\n remaining = 1.0 * elapsed / count * (total - count)\\n # Time remaining in minutes\\n remaining = round(remaining / 60.0, 1)\\n # Time taken in minutes\\n elapsed = round(elapsed / 60.0, 1)\\n\\n self.log.info(f\\\"{self.prefix}: {avg}ms avg, {elapsed}min passed, \\\"\\n f\\\"{remaining}min remaining. ({count:,}/{total:,})\\\")\",\n \"def normalize_transition(self):\\n self._t /= self._t.sum(1)[:, np.newaxis]\",\n \"def count_results(self):\\n for record in self._traced_records:\\n if self._statistical_results.get(record.name) == None:\\n self._statistical_results[record.name] = StatisticalResult(\\n record.name)\\n self._statistical_results[record.name].insert_record(\\n record.kernel_time)\\n self._total_time_ms += record.kernel_time\\n self._statistical_results = {\\n k: v\\n for k, v in sorted(self._statistical_results.items(),\\n key=lambda item: item[1],\\n reverse=True)\\n }\",\n \"def normalized_total_time(p, max_time=3600000):\\n if \\\"cdgp.wasTimeout\\\" in p and p[\\\"cdgp.wasTimeout\\\"] == \\\"true\\\":\\n v = 3600000\\n else:\\n v = int(float(p[\\\"result.totalTimeSystem\\\"]))\\n return max_time if v > max_time else v\",\n \"def get_average_execution_time_value(execution_time):\\n if all_results_are_merged:\\n # There will be multiple branch coverage results. Take\\n # whatever is considered to be the \\\"average\\\".\\n assert isinstance(execution_time, list)\\n _, execution_time, _ = timing_range_fn(execution_time)\\n return execution_time\",\n \"def update_running_totals_from_load_step_results(self, results: dict) -> None:\\n for result in results[\\\"step_results\\\"].values():\\n sobject_name = result[\\\"sobject\\\"]\\n totals = self.sobject_counts[sobject_name]\\n totals.errors += result[\\\"total_row_errors\\\"]\\n totals.successes += result[\\\"records_processed\\\"] - result[\\\"total_row_errors\\\"]\",\n \"def _normalize(self):\\n\\n n = len(self.e2[0])\\n E = []\\n\\n for e2 in self.e2:\\n if len(e2) != n:\\n print 'WARNING: non consistent length in error statistics!!!'\\n E.append(np.nansum(np.sqrt(e2))) # temporal aggregation\\n\\n E = np.asarray(E)\\n EM = E.mean() # take square root, as e2 is still the squared error!\\n self.e_norm = (E - EM) / EM # see Glecker et al, eq.2\",\n \"def calculate(self):\\n avg = self.sum / self.n if self.n != 0 else 0\\n self.running_avg.append(avg)\\n return avg\",\n \"def compute_statistics(self):\",\n \"def calculate_query_times(**kwargs):\\n trim_size = int(kwargs[\\\"trim\\\"] * len(kwargs[\\\"total_times\\\"]))\\n return {\\n \\\"total_time_avg\\\": round(numpy.mean(kwargs[\\\"total_times\\\"]), 1),\\n \\\"total_time_min\\\": round(numpy.min(kwargs[\\\"total_times\\\"]), 1),\\n \\\"total_time_max\\\": round(numpy.max(kwargs[\\\"total_times\\\"]), 1),\\n \\\"total_time_85\\\": round(numpy.percentile(kwargs[\\\"total_times\\\"], 85), 1),\\n \\\"total_time_trimmed_avg\\\": round(\\n numpy.mean(\\n numpy.sort(kwargs[\\\"total_times\\\"])[trim_size:-trim_size]\\n ),\\n 1,\\n )\\n if trim_size\\n else round(numpy.mean(kwargs[\\\"total_times\\\"]), 1),\\n \\\"total_times\\\": kwargs[\\\"total_times\\\"],\\n \\\"execution_time_avg\\\": round(numpy.mean(kwargs[\\\"execution_times\\\"]), 1),\\n \\\"execution_time_min\\\": round(numpy.min(kwargs[\\\"execution_times\\\"]), 1),\\n \\\"execution_time_max\\\": round(numpy.max(kwargs[\\\"execution_times\\\"]), 1),\\n \\\"execution_time_85\\\": round(\\n numpy.percentile(kwargs[\\\"execution_times\\\"], 85), 1\\n ),\\n \\\"execution_time_25\\\": round(\\n numpy.percentile(kwargs[\\\"execution_times\\\"], 25), 1\\n ),\\n \\\"execution_time_std\\\": round(numpy.std(kwargs[\\\"execution_times\\\"]), 1),\\n \\\"execution_time_trimmed_avg\\\": round(\\n numpy.mean(\\n numpy.sort(kwargs[\\\"execution_times\\\"])[trim_size:-trim_size]\\n )\\n )\\n if trim_size > 0\\n else round(numpy.mean(kwargs[\\\"execution_times\\\"]), 1),\\n \\\"execution_time_trimmed_max\\\": round(\\n numpy.max(\\n numpy.sort(kwargs[\\\"execution_times\\\"])[trim_size:-trim_size]\\n )\\n )\\n if trim_size > 0\\n else round(numpy.max(kwargs[\\\"execution_times\\\"]), 1),\\n \\\"execution_times\\\": kwargs[\\\"execution_times\\\"],\\n \\\"connect_time_avg\\\": round(numpy.mean(kwargs[\\\"connect_times\\\"]), 1),\\n \\\"connect_time_min\\\": round(numpy.min(kwargs[\\\"connect_times\\\"]), 1),\\n \\\"connect_time_max\\\": round(numpy.max(kwargs[\\\"connect_times\\\"]), 1),\\n \\\"connect_time_85\\\": round(\\n numpy.percentile(kwargs[\\\"connect_times\\\"], 85), 1\\n ),\\n \\\"arrow_conversion_time_avg\\\": round(\\n numpy.mean(kwargs[\\\"arrow_conversion_times\\\"]), 1\\n ),\\n \\\"arrow_conversion_time_min\\\": round(\\n numpy.min(kwargs[\\\"arrow_conversion_times\\\"]), 1\\n ),\\n \\\"arrow_conversion_time_max\\\": round(\\n numpy.max(kwargs[\\\"arrow_conversion_times\\\"]), 1\\n ),\\n \\\"arrow_conversion_time_85\\\": round(\\n numpy.percentile(kwargs[\\\"arrow_conversion_times\\\"], 85), 1\\n ),\\n \\\"arrow_conversion_time_25\\\": round(\\n numpy.percentile(kwargs[\\\"arrow_conversion_times\\\"], 25), 1\\n ),\\n \\\"arrow_conversion_time_std\\\": round(\\n numpy.std(kwargs[\\\"arrow_conversion_times\\\"]), 1\\n ),\\n }\",\n \"def calculate_query_times(**kwargs):\\n trim_size = int(kwargs[\\\"trim\\\"] * len(kwargs[\\\"total_times\\\"]))\\n return {\\n \\\"total_time_avg\\\": round(numpy.mean(kwargs[\\\"total_times\\\"]), 1),\\n \\\"total_time_min\\\": round(numpy.min(kwargs[\\\"total_times\\\"]), 1),\\n \\\"total_time_max\\\": round(numpy.max(kwargs[\\\"total_times\\\"]), 1),\\n \\\"total_time_85\\\": round(numpy.percentile(kwargs[\\\"total_times\\\"], 85), 1),\\n \\\"total_time_trimmed_avg\\\": round(\\n numpy.mean(\\n numpy.sort(kwargs[\\\"total_times\\\"])[trim_size:-trim_size]\\n ),\\n 1,\\n )\\n if trim_size\\n else round(numpy.mean(kwargs[\\\"total_times\\\"]), 1),\\n \\\"total_times\\\": kwargs[\\\"total_times\\\"],\\n \\\"execution_time_avg\\\": round(numpy.mean(kwargs[\\\"execution_times\\\"]), 1),\\n \\\"execution_time_min\\\": round(numpy.min(kwargs[\\\"execution_times\\\"]), 1),\\n \\\"execution_time_max\\\": round(numpy.max(kwargs[\\\"execution_times\\\"]), 1),\\n \\\"execution_time_85\\\": round(\\n numpy.percentile(kwargs[\\\"execution_times\\\"], 85), 1\\n ),\\n \\\"execution_time_25\\\": round(\\n numpy.percentile(kwargs[\\\"execution_times\\\"], 25), 1\\n ),\\n \\\"execution_time_std\\\": round(numpy.std(kwargs[\\\"execution_times\\\"]), 1),\\n \\\"execution_time_trimmed_avg\\\": round(\\n numpy.mean(\\n numpy.sort(kwargs[\\\"execution_times\\\"])[trim_size:-trim_size]\\n )\\n )\\n if trim_size > 0\\n else round(numpy.mean(kwargs[\\\"execution_times\\\"]), 1),\\n \\\"execution_time_trimmed_max\\\": round(\\n numpy.max(\\n numpy.sort(kwargs[\\\"execution_times\\\"])[trim_size:-trim_size]\\n )\\n )\\n if trim_size > 0\\n else round(numpy.max(kwargs[\\\"execution_times\\\"]), 1),\\n \\\"execution_times\\\": kwargs[\\\"execution_times\\\"],\\n \\\"connect_time_avg\\\": round(numpy.mean(kwargs[\\\"connect_times\\\"]), 1),\\n \\\"connect_time_min\\\": round(numpy.min(kwargs[\\\"connect_times\\\"]), 1),\\n \\\"connect_time_max\\\": round(numpy.max(kwargs[\\\"connect_times\\\"]), 1),\\n \\\"connect_time_85\\\": round(\\n numpy.percentile(kwargs[\\\"connect_times\\\"], 85), 1\\n ),\\n \\\"results_iter_time_avg\\\": round(\\n numpy.mean(kwargs[\\\"results_iter_times\\\"]), 1\\n ),\\n \\\"results_iter_time_min\\\": round(\\n numpy.min(kwargs[\\\"results_iter_times\\\"]), 1\\n ),\\n \\\"results_iter_time_max\\\": round(\\n numpy.max(kwargs[\\\"results_iter_times\\\"]), 1\\n ),\\n \\\"results_iter_time_85\\\": round(\\n numpy.percentile(kwargs[\\\"results_iter_times\\\"], 85), 1\\n ),\\n }\",\n \"def _normalize(self):\\r\\n self.dataframe['norm_intensity'] = self.dataframe['intensity']\\r\\n self.dataframe['norm_intensity'] -= self.dataframe['norm_intensity'].min()\\r\\n self.dataframe['norm_intensity'] /= self.dataframe['norm_intensity'].max() * 0.01\",\n \"def compute_stats(self):\\n if self.stats is not None:\\n return\\n self.stats = np.zeros(STEPS_MAX + 1)\\n for m in self.missions:\\n m.compute_stats()\\n self.stats += 100 * m.stats\\n self.stats /= len(self.missions)\",\n \"def normalize(self, data: pd.DataFrame) -> pd.DataFrame:\\n\\n if self.method == \\\"task\\\":\\n for task in data[\\\"task_name\\\"].unique():\\n if task in self.data_range.keys():\\n task_min = self.data_range[task][\\\"min\\\"]\\n task_max = self.data_range[task][\\\"max\\\"]\\n task_data = data.loc[\\n data[\\\"task_name\\\"] == task, self.perf_measure\\n ].to_numpy()\\n\\n if task_min == task_max:\\n data.loc[data[\\\"task_name\\\"] == task, self.perf_measure] = (\\n task_data * 0\\n ) + self.offset\\n logger.warning(\\n f\\\"Performance for task ({task}) is constant - normalizing to 0\\\"\\n )\\n else:\\n data.loc[data[\\\"task_name\\\"] == task, self.perf_measure] = (\\n (task_data - task_min) / (task_max - task_min) * self.scale\\n ) + self.offset\\n else:\\n raise KeyError(f\\\"Missing data range for task '{task}'\\\")\\n return data\\n elif self.method == \\\"run\\\":\\n data.loc[:, self.perf_measure] = (\\n (data[self.perf_measure].to_numpy() - self.run_min)\\n / (self.run_max - self.run_min)\\n * self.scale\\n ) + self.offset\\n return data\",\n \"def normalize(self):\\n total = float(sum(self.values()))\\n for key in self:\\n self[key] /= total\",\n \"def normalize(self):\\n self._data /= self.norm()\",\n \"def _filtrate_result(self, raw_result):\\n fields = []\\n maximum = {}\\n minimum = {}\\n average = {}\\n\\n time_marker = re.compile(\\\"^([0-9]+):([0-9]+):([0-9]+)$\\\")\\n ampm_marker = re.compile(\\\"(AM|PM)$\\\")\\n\\n # Parse network utilization stats\\n for row in raw_result.split('\\\\n'):\\n line = row.split()\\n\\n if line and re.match(time_marker, line[0]):\\n if re.match(ampm_marker, line[1]):\\n del line[:2]\\n\\n if line[0] == 'IFACE':\\n # header fields\\n fields = line[1:]\\n if len(fields) != NetUtilization.\\\\\\n NET_UTILIZATION_FIELD_SIZE:\\n raise RuntimeError(\\\"network_utilization: unexpected\\\\\\n field size\\\", fields)\\n else:\\n # value fields\\n net_interface = line[0]\\n values = line[1:]\\n\\n if values and len(values) == len(fields):\\n temp_dict = dict(zip(fields, values))\\n if net_interface not in maximum:\\n maximum[net_interface] = temp_dict\\n else:\\n for item in temp_dict:\\n if float(maximum[net_interface][item]) <\\\\\\n float(temp_dict[item]):\\n maximum[net_interface][item] = \\\\\\n temp_dict[item]\\n\\n if net_interface not in minimum:\\n minimum[net_interface] = temp_dict\\n else:\\n for item in temp_dict:\\n if float(minimum[net_interface][item]) >\\\\\\n float(temp_dict[item]):\\n minimum[net_interface][item] = \\\\\\n temp_dict[item]\\n else:\\n raise RuntimeError(\\\"network_utilization: parse error\\\",\\n fields, line)\\n\\n elif line and line[0] == 'Average:':\\n del line[:1]\\n\\n if line[0] == 'IFACE':\\n # header fields\\n fields = line[1:]\\n if len(fields) != NetUtilization.\\\\\\n NET_UTILIZATION_FIELD_SIZE:\\n raise RuntimeError(\\\"network_utilization average: \\\\\\n unexpected field size\\\", fields)\\n else:\\n # value fields\\n net_interface = line[0]\\n values = line[1:]\\n if values and len(values) == len(fields):\\n average[net_interface] = dict(zip(fields, values))\\n else:\\n raise RuntimeError(\\\"network_utilization average: \\\\\\n parse error\\\", fields, line)\\n\\n return {'network_utilization_maximun': maximum,\\n 'network_utilization_minimum': minimum,\\n 'network_utilization_average': average}\",\n \"def get_time_elapsed(self, pipeline_run):\\n begin = pipeline_run[\\\"steps\\\"][0][\\\"method_calls\\\"][0][\\\"start\\\"]\\n begin_val = parse(begin)\\n end = pipeline_run[\\\"steps\\\"][-1][\\\"method_calls\\\"][-1][\\\"end\\\"]\\n end_val = parse(end)\\n total_time = (end_val - begin_val).total_seconds()\\n return total_time\",\n \"def update_average(self,result):\\n a = 1/self.iters\\n b = 1 - a\\n self.average = a * result + b * self.average\\n self.iters += 1\",\n \"def normalize(self):\\n norm_val = self.sum2/self.sum1\\n self.sum1=0\\n\\n for sentence in self.data_set:\\n sentence.weight *= norm_val\\n self.sum1 += sentence.weight\",\n \"def calculate(self):\\n if self.sampling_timer.IsRunning():\\n return\\n if self.daq.data0 == []:\\n average = 0.0\\n else:\\n average = mean(self.daq.data0)\\n res_string = '%.2f' %average\\n self.control_box.result_box.SetLabel(res_string)\",\n \"def calculate(self):\\n #runs = [ai\\n # for ei in self.experiment_queues\\n # for ai in ei.cleaned_automated_runs]\\n #\\n #ni = len(runs)\\n #self.nruns = ni\\n # for ei in self.experiment_queues:\\n # dur=ei.stats.calculate_duration(ei.cleaned_automated_runs)\\n # if\\n\\n\\n tt = sum([ei.stats.calculate_duration(ei.cleaned_automated_runs)\\n for ei in self.experiment_queues])\\n self._total_time = tt\\n offset = 0\\n if self._start_time:\\n offset = time.time() - self._start_time\\n\\n self.etf = self.format_duration(tt - offset)\",\n \"def estimated_time(self):\\n self._update()\\n if not self.running_mode:\\n return 0 if self._is_finished() else float(\\\"nan\\\")\\n elif self.running_mode == \\\"local\\\":\\n start = self.processes[0].create_time()\\n elif self.running_mode == \\\"grid\\\":\\n start = self.job[\\\"start_time\\\"]\\n if start == 0:\\n # Queued, but not started\\n return float(\\\"nan\\\")\\n else:\\n logger.warning(\\\"Invalid running_mode attribute\\\")\\n return float(\\\"nan\\\")\\n current = self.current_step()\\n if current <= 0: # If not dumped yet or error\\n return float('nan')\\n else:\\n elapsed = time() - start\\n return elapsed * (self.total_steps / current - 1)\",\n \"def test_compute_unnormalized_scores(self):\\n # todo: implement this test!\\n pass\",\n \"def normalize(self):\\n total = float(sum(self.values()))\\n for key in self:\\n self[key] /= total\",\n \"def total_seconds(self):\\n return 0\",\n \"def running_ratio(self) -> np.ndarray:\\n result_array = self.result_array\\n result = result_array.sum(axis=1) / result_array.sum()\\n\\n if isinstance(result, np.ndarray):\\n result_out = result\\n else:\\n result_out = np.array(result)\\n\\n return result_out\",\n \"def total_time(self):\\n obs_times = self.clean_obs_times()\\n return _np.sum(obs_times[:, 1] - obs_times[:, 0])\",\n \"def _compute_normalization(self, normalize=True):\\n if normalize:\\n if self._img_norm is None:\\n if np.sum(self._data) == 0:\\n self._img_norm = 1\\n else:\\n self._img_norm = self._compute_raw_image_norm()\\n\\n if self._img_norm != 0.0 and np.isfinite(self._img_norm):\\n self._data /= (self._img_norm * self._normalization_correction)\\n self._normalization_status = 0\\n else:\\n self._normalization_status = 1\\n self._img_norm = 1\\n warnings.warn('Overflow encountered while computing '\\n 'normalization constant. Normalization '\\n 'constant will be set to 1.', NonNormalizable)\\n else:\\n self._normalization_status = 2\",\n \"def _compute_duration(self):\\n diff_float = 0\\n for ts_line in self:\\n if ts_line.x_start_date:\\n st_datetime = fields.Datetime.from_string(\\n ts_line.x_start_date)\\n # autocomplete date from start date\\n st_date_tz = fields.Datetime.context_timestamp(\\n self, st_datetime).date()\\n ts_line.date = st_date_tz\\n\\n # autocomplete name from start date\\n st_datetime_tz = fields.Datetime.context_timestamp(\\n self, st_datetime)\\n string_st_dt_tz = fields.Datetime.to_string(st_datetime_tz)\\n ts_line.name = ts_line.user_id.name + '/' + string_st_dt_tz\\n\\n en_datetime = fields.Datetime.from_string(\\n ts_line.x_end_date)\\n diff = en_datetime - st_datetime\\n if(time(1, 00) <= st_datetime.time() <= time(5, 00)):\\n if(time(6, 00) <= en_datetime.time() <= time(10, 00)):\\n # del 1 hour for breaking lunch\\n diff_float = round(diff.total_seconds() / 3600.0, 2)-1\\n else:\\n diff_float = round(diff.total_seconds() / 3600.0, 2)\\n ts_line.unit_amount = diff_float\",\n \"def evaluate(self, time) -> float:\\n ...\",\n \"def get_summarized_results(self):\\n stats = [v.stats() for (k, v) in self.examples.items() if v.is_ready()]\\n res = self.ExampleClass.average_stats(stats)\\n\\n res['loss'] = self.loss/self.loss_cnt\\n res['recent_loss'] = sum(self.recent_loss_array) / sum(self.recent_loss_bs_array)\\n\\n return res\",\n \"def reset_duration(self):\\n self._duration_start = time.perf_counter()\\n return self._duration_start\",\n \"def _append_results(self) -> None:\\n self._t_mps.compute_traces(self._step, self._process_tensors)\\n time = self.time(self._step)\\n norm = self._t_mps.get_norm()\\n bond_dimensions = self._t_mps.get_bond_dimensions()\\n self._results['time'].append(time)\\n self._results['norm'].append(norm)\\n self._results['bond_dimensions'].append(bond_dimensions)\\n for sites, dynamics in self._results['dynamics'].items():\\n if isinstance(sites, int):\\n sites_list = [sites]\\n else:\\n sites_list = list(sites)\\n dynamics.add(\\n time,\\n self._t_mps.get_density_matrix(sites_list))\\n self._t_mps.clear_traces()\",\n \"def avg_inference_time(self):\\n return self._avg_inference_time\",\n \"def get_post_stats(self):\\n stats = self.stats\\n stats.results = self.job.result().get_counts(stats.iteration)\\n stats.datetime = str(datetime.now())\",\n \"def test_cpu_total_work(self):\\n import time\\n from supvisors.statistics import instant_cpu_statistics, cpu_total_work\\n # take 2 spaced instant cpu statistics\\n ref_stats = instant_cpu_statistics()\\n time.sleep(1)\\n last_stats = instant_cpu_statistics()\\n total_work = cpu_total_work(last_stats, ref_stats)\\n # total work should be quite close to sleeping time\\n self.assertAlmostEqual(1, total_work, 1)\",\n \"def calculate(self):\\n self.results['max'] = numpy.max(self.data)\\n self.results['min'] = numpy.min(self.data)\\n if self.type == 0:\\n self.group_discrete_data()\\n if self.type == 1:\\n self.group_continuous_data()\\n\\n self.results['arithAvg'] = self.average([self.data[i] * self.occurrences[i] for i in range(len(self.data))],\\n self.totalOccurrences)\\n self.results['quadAvg'] = math.sqrt(\\n self.average([(self.data[i] * self.data[i]) * self.occurrences[i] for i in range(len(self.data))],\\n self.totalOccurrences))\\n if self.results['min'] > 0:\\n self.results['geoAvg'] = math.exp(\\n self.average([numpy.log(self.data[i]) * self.occurrences[i] for i in range(len(self.data))],\\n self.totalOccurrences))\\n self.results['harmAvg'] = 1 / self.average(\\n [(self.occurrences[i] / self.data[i]) for i in range(len(self.data))],\\n self.totalOccurrences)\\n else:\\n self.results['geoAvg'] = self.results['harmAvg'] = \\\"N/A\\\"\\n self.results['momentsR'] = self.moments(self.data, self.occurrences, 4)\\n self.results['centralMomentsR'] = self.moments([(i - self.results['arithAvg']) for i in self.data],\\n self.occurrences, 4)\\n self.results['std'] = self.average(\\n [self.occurrences[i] * abs(self.data[i] - self.results['arithAvg']) for i in range(len(self.data))],\\n self.totalOccurrences)\",\n \"def normalization_calculation(self) -> None:\\n self.normalized_inventory = (\\n self.normalization_matrix * self.characterized_inventory\\n )\",\n \"def __calculateNormalizedScores(self):\\n year_scores = {0 : []}\\n for venue in self.venue_scores:\\n v_scores = []\\n for year in self.venue_scores[venue]:\\n v_scores.append(self.venue_scores[venue][year])\\n if year not in year_scores:\\n year_scores[year] = []\\n year_scores[year].append(self.venue_scores[venue][year])\\n x_year = np.average(np.array(v_scores))\\n self.venue_scores[venue][0] = x_year\\n year_scores[0].append(x_year)\\n \\n ##for standardization\\n #year_metrics = {x : (np.average(np.array(year_scores[x])), np.std(np.array(year_scores[x]))) for x in year_scores}\\n ##for normalization\\n year_metrics = {x: (max(year_scores[x]), min(year_scores[x])) for x in year_scores}\\n \\n #print year_metrics\\n \\n for venue in self.venue_scores:\\n self.normalized_scores[venue] = dict()\\n for year in self.venue_scores[venue]:\\n #self.standard_scores[venue][year] = round((self.venue_scores[venue][year] - year_metrics[year][0]) / year_metrics[year][1],5)\\n #self.normalized_scores[venue][year] = (self.venue_scores[venue][year] - year_metrics[year][1]) / (year_metrics[year][0] - year_metrics[year][1]) + eps\\n self.normalized_scores[venue][year] = (self.venue_scores[venue][year] - year_metrics[year][1] + self.epsilon) / (year_metrics[year][0] - year_metrics[year][1] + self.epsilon)\",\n \"def sum(self):\\n\\n return time_stat(self, stat=\\\"sum\\\")\",\n \"def __unwrapResults(self):\\n if self.__cachedResults is None:\\n if self.__rawInfo.results is not None:\\n resultList = json.loads(self.__rawInfo.results)\\n assert len(resultList) == 2, \\\\\\n \\\"Expected 2 elements, but got %s (%s).\\\" % (\\n len(resultList), resultList)\\n self.__cachedResults = self.ModelResults(\\n reportMetrics=resultList[0],\\n optimizationMetrics=resultList[1])\\n else:\\n self.__cachedResults = self.ModelResults(\\n reportMetrics={},\\n optimizationMetrics={})\\n\\n\\n return self.__cachedResults\",\n \"def _compute_normalization(self, normalize=True):\\n self._normalization_constant = 1.0 / self._normalization_correction\\n\\n if normalize:\\n # compute normalization constant so that\\n # N*C*sum(data) = 1:\\n if self._img_norm is None:\\n self._img_norm = self._compute_raw_image_norm()\\n\\n if self._img_norm != 0.0 and np.isfinite(self._img_norm):\\n self._normalization_constant /= self._img_norm\\n self._normalization_status = 0\\n\\n else:\\n self._normalization_constant = 1.0\\n self._normalization_status = 1\\n warnings.warn(\\\"Overflow encountered while computing \\\"\\n \\\"normalization constant. Normalization \\\"\\n \\\"constant will be set to 1.\\\", NonNormalizable)\\n\\n else:\\n self._normalization_status = 2\",\n \"def slow_update_duration(self):\\n for i in range(len(self.data_file.sorted_data)):\\n if self.data_file.sorted_data[i]['type'] == 'slow':\\n slow_upd = self.data_file.sorted_data[i]['timestamp']\\n Config.ANALYSIS.write(f\\\"slow at: {slow_upd}\\\\n\\\")\\n if i == 0:\\n after_slow = self.data_file.sorted_data[i + 1]['timestamp']\\n Config.ANALYSIS.write(f\\\"after slow: ({slow_upd}, {after_slow}) \\\"\\n f\\\"= {after_slow - slow_upd}\\\\n\\\\n\\\")\\n elif i == len(self.data_file.sorted_data) - 1:\\n before_slow = self.data_file.sorted_data[i - 1]['timestamp']\\n Config.ANALYSIS.write(f\\\"before slow: ({before_slow}, {slow_upd}) \\\"\\n f\\\"= {slow_upd - before_slow}\\\\n\\\\n\\\")\\n else:\\n before_slow = self.data_file.sorted_data[i - 1]['timestamp']\\n after_slow = self.data_file.sorted_data[i + 1]['timestamp']\\n Config.ANALYSIS.write(f\\\"before slow: ({before_slow}, {slow_upd}) \\\"\\n f\\\"= {slow_upd - before_slow}\\\\n\\\")\\n Config.ANALYSIS.write(f\\\"after slow: ({slow_upd}, {after_slow}) \\\"\\n f\\\"= {after_slow - slow_upd}\\\\n\\\\n\\\")\\n Config.ANALYSIS.write(\\\"\\\\n\\\\n\\\")\",\n \"def _calculate_runtime(self):\\n lines = self.file_dic['output'].splitlines()\\n start_time = datetime.strptime(lines[0].strip(), self.timestring_format)\\n fin_time = datetime.strptime(lines[-1].strip(), self.timestring_format)\\n dif = fin_time - start_time\\n self.date = fin_time.strftime('%d %b %Y')\\n self.runtime = dif.total_seconds()\",\n \"def _GetNormalizedTimestamp(self):\\n if self._normalized_timestamp is None:\\n if (self._number_of_seconds is not None and\\n self.fraction_of_second is not None):\\n self._normalized_timestamp = (\\n decimal.Decimal(self._number_of_seconds) + self.fraction_of_second)\\n\\n return self._normalized_timestamp\",\n \"def Analyze(self):\\n \\n self._analyzeLogs()\\n for user in self._start_times:\\n self._result[user] = self._zipTimes(user)\",\n \"def _do_subject_normalize(output_dir,\\n segment_result=None,\\n do_report=True,\\n results_gallery=None,\\n progress_logger=None,\\n brain=\\\"EPI\\\",\\n cmap=None,\\n fwhm=0,\\n **spm_normalize_kwargs):\\n\\n nipype_report_filenames = []\\n\\n # sanity\\n def get_norm_apply_to_files(files):\\n if isinstance(files, basestring):\\n norm_apply_to_files = files\\n file_types = 'string'\\n else:\\n file_types = []\\n norm_apply_to_files = []\\n for x in files:\\n if isinstance(x, basestring):\\n norm_apply_to_files.append(x)\\n file_types.append('string')\\n else:\\n norm_apply_to_files += x\\n file_types.append(('list', len(x)))\\n\\n return norm_apply_to_files, file_types\\n\\n if 'apply_to_files' in spm_normalize_kwargs:\\n spm_normalize_kwargs['apply_to_files'], file_types = \\\\\\n get_norm_apply_to_files(spm_normalize_kwargs['apply_to_files'])\\n\\n output = {}\\n\\n # prepare for smart caching\\n cache_dir = os.path.join(output_dir, 'cache_dir')\\n if not os.path.exists(cache_dir):\\n os.makedirs(cache_dir)\\n mem = Memory(base_dir=cache_dir)\\n\\n # run workflow\\n normalize = mem.cache(spm.Normalize)\\n norm_result = normalize(**spm_normalize_kwargs)\\n\\n # collect ouput\\n output['result'] = norm_result\\n if not norm_result.outputs is None:\\n normalized_files = norm_result.outputs.normalized_files\\n\\n # define execution log html output filename\\n execution_log_html_filename = os.path.join(\\n output_dir,\\n 'normalization_of_%s_execution_log.html' % brain,\\n )\\n\\n # grab execution log\\n execution_log = preproc_reporter.get_nipype_report(\\n preproc_reporter.get_nipype_report_filename(normalized_files))\\n\\n # write execution log\\n open(execution_log_html_filename, 'w').write(\\n execution_log)\\n\\n # update progress bar\\n if progress_logger:\\n progress_logger.log(\\n '<b>Normalization of %s</b><br/><br/>' % brain)\\n progress_logger.log(execution_log)\\n progress_logger.log('<hr/>')\\n\\n # do smoothing\\n if np.sum(fwhm):\\n smooth = mem.cache(spm.Smooth)\\n smooth_result = smooth(\\n in_files=output['result'].outputs.normalized_files,\\n fwhm=fwhm)\\n\\n # collect ouput\\n output['result'] = smooth_result\\n if not smooth_result.outputs is None:\\n normalized_files = smooth_result.outputs.smoothed_files\\n output['normalized_files'] = normalized_files\\n\\n # grab execution log\\n execution_log = preproc_reporter.get_nipype_report(\\n preproc_reporter.get_nipype_report_filename(\\n normalized_files))\\n\\n # write execution log\\n open(execution_log_html_filename, 'w').write(\\n execution_log)\\n\\n # update progress bar\\n if progress_logger:\\n progress_logger.log(\\n '<b>Smoothening of %s</b><br/><br/>' % brain)\\n progress_logger.log(execution_log)\\n progress_logger.log('<hr/>')\\n\\n if 'apply_to_files' in spm_normalize_kwargs:\\n if not isinstance(file_types, basestring):\\n _tmp = []\\n s = 0\\n for x in file_types:\\n if x == 'string':\\n if isinstance(normalized_files, basestring):\\n _tmp = normalized_files\\n break\\n else:\\n _tmp.append(\\n normalized_files[s])\\n s += 1\\n else:\\n _tmp.append(\\n normalized_files[s: s + x[1]])\\n s += x[1]\\n\\n normalized_files = _tmp\\n\\n output['normalized_files'] = normalized_files\\n\\n # generate gallery for HTML report\\n if do_report:\\n if normalized_files:\\n if segment_result:\\n subject_gm_file = segment_result.outputs.modulated_gm_image\\n subject_wm_file = segment_result.outputs.modulated_wm_image\\n subject_csf_file = segment_result.outputs.modulated_csf_image\\n else:\\n subject_gm_file = None\\n subject_wm_file = None\\n subject_csf_file = None\\n\\n nipype_report_filenames = [\\n preproc_reporter.get_nipype_report_filename(\\n subject_gm_file)] + nipype_report_filenames\\n\\n # generate normalization thumbs\\n output.update(preproc_reporter.generate_normalization_thumbnails(\\n normalized_files,\\n output_dir,\\n brain=brain,\\n execution_log_html_filename=execution_log_html_filename,\\n results_gallery=results_gallery,\\n ))\\n\\n # generate segmentation thumbs\\n output.update(preproc_reporter.generate_segmentation_thumbnails(\\n normalized_files,\\n output_dir,\\n subject_gm_file=subject_gm_file,\\n subject_wm_file=subject_wm_file,\\n subject_csf_file=subject_csf_file,\\n brain=brain,\\n execution_log_html_filename=execution_log_html_filename,\\n cmap=cmap,\\n results_gallery=results_gallery))\\n\\n # collect ouput\\n output['result'] = norm_result\\n\\n return output\",\n \"def execute_time(self, value):\\n # unfied unit and rounded to two decimals\\n unfied_execute_time = convert_execute_time_to_ms(value)\\n self._execute_time = round(unfied_execute_time, 2)\",\n \"def test_instant_cpu_statistics(self):\\n import multiprocessing\\n from supvisors.statistics import instant_cpu_statistics\\n stats = instant_cpu_statistics()\\n # test number of results (number of cores + average)\\n self.assertEqual(multiprocessing.cpu_count() + 1, len(stats))\\n # test average value\\n total_work = total_idle = 0\\n for cpu in stats[1:]:\\n self.assertEqual(2, len(cpu))\\n work, idle = cpu\\n total_work += work\\n total_idle += idle\\n self.assertAlmostEqual(stats[0][0], total_work / multiprocessing.cpu_count())\\n self.assertAlmostEqual(stats[0][1], total_idle / multiprocessing.cpu_count())\",\n \"def normalized(self):\\n return self / self.norm()\",\n \"def compute_utilization(self) -> float:\\r\\n return self._compute_utilization\",\n \"def measure(self):\\n self.completed = False\\n self.message = ''\\n for res in self.results:\\n self.results[res] = None\\n return self\",\n \"def runtime(self):\\n return (self.time - self.start).total_seconds()\",\n \"def compute_time_step():\\n\\n dt = Hydro.compute_time_step()\\n\\n return dt\",\n \"async def compute(self, duration: Optional[Number]) -> None:\\n await envs.sleep(duration)\\n self.total_compute_time += duration\",\n \"def compute_values(self, update_statistics=False):\\n\\n self.compute_iterations()\\n self.axsec = sum([one.axsec for one in self])\\n self.xsec = sum([one.xsec for one in self])\\n self.xerrc = sum([one.xerrc for one in self])\\n self.xerru = math.sqrt(sum([one.xerru**2 for one in self]))\\n\\n self.nevents = sum([one.nevents for one in self])\\n self.nw = sum([one.nw for one in self])\\n self.maxit = len(self.yerr_iter) # \\n self.nunwgt = sum([one.nunwgt for one in self]) \\n self.wgt = 0\\n self.luminosity = min([0]+[one.luminosity for one in self])\\n if update_statistics:\\n self.run_statistics.aggregate_statistics([_.run_statistics for _ in self])\",\n \"def _GetNormalizedTimestamp(self):\\n if self._normalized_timestamp is None:\\n if self._number_of_seconds is not None:\\n self._normalized_timestamp = (\\n decimal.Decimal(self._deciseconds) /\\n definitions.DECISECONDS_PER_SECOND)\\n self._normalized_timestamp += decimal.Decimal(self._number_of_seconds)\\n\\n if self._time_zone_offset:\\n self._normalized_timestamp -= self._time_zone_offset * 60\\n\\n return self._normalized_timestamp\",\n \"def __call__(self, results):\\n for key in results.get('img_fields', ['img']):\\n results[key] = general_ocr.imnormalize(results[key], self.mean, self.std,\\n self.to_rgb)\\n results['img_norm_cfg'] = dict(\\n mean=self.mean, std=self.std, to_rgb=self.to_rgb)\\n return results\",\n \"def process(self, data):\\n return data - np.mean(data)\",\n \"def normalize(self):\\n return Vector(self.args + []) / self.magnitude()\",\n \"def cpu_time(self):\",\n \"def measure(self):\\n pass\",\n \"def normalize_initial(self):\\n self._i /= self._i.sum()\",\n \"def divide_by_temporal_std(self):\\n if not hasattr(self, 'mean_removed_data'):\\n self.remove_temporal_mean()\\n self.std_divided_data = self.mean_removed_data / \\\\\\n np.std(self.mean_removed_data, axis=-1, keepdims=True)\",\n \"def avg(self):\\n return sum(self.times) / len(self.times)\",\n \"def avg(self):\\n return sum(self.times) / len(self.times)\",\n \"def avg(self):\\n return sum(self.times) / len(self.times)\",\n \"def elapsed():\\n global start_time\\n return time.time() - start_time\",\n \"def as_unit(self):\\n new_vec = self.copy()\\n new_vec.normalize()\\n return new_vec\",\n \"def computation_time(self) -> float:\\r\\n if self._computation_times is None:\\r\\n return None\\r\\n else:\\r\\n return self._computation_times[0]\",\n \"def avg_extend_time(self):\\r\\n if self.total_extended:\\r\\n return self.total_extend_time/self.total_extended\\r\\n else: return 0\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63369775","0.62145233","0.5956927","0.5839907","0.5755588","0.57369196","0.57129204","0.57077837","0.56347495","0.55887246","0.5531663","0.5496262","0.54943055","0.54918367","0.54862154","0.5455096","0.54451555","0.5443062","0.54175466","0.53954595","0.53879154","0.535716","0.5348161","0.53412974","0.53336304","0.5327263","0.532273","0.5312825","0.5310807","0.5292084","0.5287873","0.5282217","0.5276205","0.5273859","0.52725387","0.5261763","0.5251837","0.52326167","0.5216093","0.5216093","0.5214528","0.52140653","0.52029926","0.5182269","0.5176808","0.51682365","0.5166567","0.5146472","0.514593","0.5126488","0.5119972","0.51166767","0.51089483","0.50995845","0.5099501","0.5098861","0.5087033","0.5084139","0.5083147","0.506848","0.5065798","0.5056391","0.5053805","0.50521594","0.50411433","0.50406265","0.50390714","0.50385946","0.5031541","0.5026875","0.50258","0.5023785","0.5023753","0.5019766","0.5018874","0.5017128","0.5011029","0.5006232","0.50053835","0.50047225","0.49959278","0.499427","0.4989518","0.4978058","0.49760193","0.4975989","0.4972703","0.49722862","0.49712658","0.49683446","0.49657595","0.49606165","0.4960535","0.49465653","0.49444783","0.49444783","0.49444783","0.49395752","0.49357662","0.49350664","0.4934557"],"string":"[\n \"0.63369775\",\n \"0.62145233\",\n \"0.5956927\",\n \"0.5839907\",\n \"0.5755588\",\n \"0.57369196\",\n \"0.57129204\",\n \"0.57077837\",\n \"0.56347495\",\n \"0.55887246\",\n \"0.5531663\",\n \"0.5496262\",\n \"0.54943055\",\n \"0.54918367\",\n \"0.54862154\",\n \"0.5455096\",\n \"0.54451555\",\n \"0.5443062\",\n \"0.54175466\",\n \"0.53954595\",\n \"0.53879154\",\n \"0.535716\",\n \"0.5348161\",\n \"0.53412974\",\n \"0.53336304\",\n \"0.5327263\",\n \"0.532273\",\n \"0.5312825\",\n \"0.5310807\",\n \"0.5292084\",\n \"0.5287873\",\n \"0.5282217\",\n \"0.5276205\",\n \"0.5273859\",\n \"0.52725387\",\n \"0.5261763\",\n \"0.5251837\",\n \"0.52326167\",\n \"0.5216093\",\n \"0.5216093\",\n \"0.5214528\",\n \"0.52140653\",\n \"0.52029926\",\n \"0.5182269\",\n \"0.5176808\",\n \"0.51682365\",\n \"0.5166567\",\n \"0.5146472\",\n \"0.514593\",\n \"0.5126488\",\n \"0.5119972\",\n \"0.51166767\",\n \"0.51089483\",\n \"0.50995845\",\n \"0.5099501\",\n \"0.5098861\",\n \"0.5087033\",\n \"0.5084139\",\n \"0.5083147\",\n \"0.506848\",\n \"0.5065798\",\n \"0.5056391\",\n \"0.5053805\",\n \"0.50521594\",\n \"0.50411433\",\n \"0.50406265\",\n \"0.50390714\",\n \"0.50385946\",\n \"0.5031541\",\n \"0.5026875\",\n \"0.50258\",\n \"0.5023785\",\n \"0.5023753\",\n \"0.5019766\",\n \"0.5018874\",\n \"0.5017128\",\n \"0.5011029\",\n \"0.5006232\",\n \"0.50053835\",\n \"0.50047225\",\n \"0.49959278\",\n \"0.499427\",\n \"0.4989518\",\n \"0.4978058\",\n \"0.49760193\",\n \"0.4975989\",\n \"0.4972703\",\n \"0.49722862\",\n \"0.49712658\",\n \"0.49683446\",\n \"0.49657595\",\n \"0.49606165\",\n \"0.4960535\",\n \"0.49465653\",\n \"0.49444783\",\n \"0.49444783\",\n \"0.49444783\",\n \"0.49395752\",\n \"0.49357662\",\n \"0.49350664\",\n \"0.4934557\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84794,"cells":{"query":{"kind":"string","value":"generate the '''dvfs.csv''' with the state, frequency and cores"},"document":{"kind":"string","value":"def generate_csv(self, context): # pylint: disable=R0912,R0914\n temp = self.percentage()\n total_state = self.unique_freq()\n offline_value = -1\n ghz_conversion = 1000000\n mhz_conversion = 1000\n with open(self.outfile, 'a+') as f:\n writer = csv.writer(f, delimiter=',')\n reader = csv.reader(f)\n # Create the header in the format below\n # workload name, iteration, state, A7 CPU0,A7 CPU1,A7 CPU2,A7 CPU3,A15 CPU4,A15 CPU5\n if sum(1 for row in reader) == 0:\n header_row = ['workload', 'iteration', 'state']\n count = 0\n for cluster, states_list in enumerate(self.currentstates_of_clusters):\n for dummy_index in range(len(states_list)):\n header_row.append(\"{} CPU{}\".format(self.corename_of_clusters[cluster], count))\n count += 1\n writer.writerow(header_row)\n if offline_value in total_state:\n total_state.remove(offline_value) # remove the offline state\n for i in sorted(total_state):\n temprow = []\n temprow.extend([context.result.spec.label, context.result.iteration])\n if \"state{}\".format(i) in self.idlestate_description:\n temprow.append(self.idlestate_description[\"state{}\".format(i)])\n else:\n state_value = float(i)\n if state_value / ghz_conversion >= 1:\n temprow.append(\"{} Ghz\".format(state_value / ghz_conversion))\n else:\n temprow.append(\"{} Mhz\".format(state_value / mhz_conversion))\n for j in range(self.device.number_of_cores * self.multiply_factor):\n temprow.append(\"{0:.3f}\".format(temp[\"cpu{}\".format(j)][i]))\n writer.writerow(temprow)\n check_off = True # Checking whether core is OFFLINE\n for i in range(self.device.number_of_cores * self.multiply_factor):\n temp_val = \"{0:.3f}\".format(temp[\"cpu{}\".format(i)][offline_value])\n if float(temp_val) > 1:\n check_off = False\n break\n if check_off is False:\n temprow = []\n temprow.extend([context.result.spec.label, context.result.iteration])\n temprow.append(\"OFFLINE\")\n for i in range(self.device.number_of_cores * self.multiply_factor):\n temprow.append(\"{0:.3f}\".format(temp[\"cpu{}\".format(i)][offline_value]))\n writer.writerow(temprow)"},"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 writeRawFCD():\n global vehId, vehIdDict\n vehIdDict = {}\n vehId = 0\n day = 0\n\n def getVehId(orgId):\n \"\"\"creates new vehicle id's which consists only numerics\"\"\"\n global vehId, vehIdDict\n value = vehIdDict.get(orgId, vehId)\n if value is vehId:\n vehIdDict[orgId] = vehId\n vehId = (vehId + 1) % 65500\n return value\n\n outputFile = open(path.FQrawFCD, 'w')\n\n for period, quota, vtypeDictR, taxiSum in generatePeriodQuotaSets():\n day += 86400\n # reset dict so that every taxi (even if the vehicle is chosen several\n # times) gets its own id\n vehIdDict = {}\n # dataset=0\n sortedKeys = vtypeDictR.keys()\n sortedKeys.sort()\n for timestep in sortedKeys:\n taxiList = vtypeDictR[timestep]\n for tup in taxiList: # all elements in this timestep\n # calc timestep ->for every period /quota set a new day\n time = timestep + day\n time = calcTime.getDateFromDepart(time)\n # dataset+=1\n # print ouptut\n # veh_id date (time to simDate+time) x (remove and\n # set comma new)\n outputFile.write(str(getVehId(tup[0])) + '\\t' + time + '\\t' + tup[3][0:2] + '.' + tup[3][2:7] + tup[3][8:] +\n # y (remove and set comma new)\n # status speed form m/s in km/h\n '\\t' + tup[4][0:2] + '.' + tup[4][2:7] + tup[4][8:] + '\\t' + \"90\" + '\\t' + str(int(round(tup[2] * 3.6))) + '\\n')\n # print dataset, time\n print(vehId)\n outputFile.close()","def run(self):\n\t\tself._data_updater_thread.start()\n\t\tf = open('output.csv', 'w') #TODO: handle output file correctly (cfg)\n\t\tf.write('(datetime;valve;thin_temp;thin_pres;out_temp)\\n')\n\t\tf.close()","def _write_csv(self):\n\n # add the label to the header\n if self.input_data.get_value(InputType.TIME_PERIOD) == 'all':\n self.header.append('Date')\n else:\n self.header.append('sample id')\n\n key_list = []\n\n for i, cube in enumerate(self.cube_list):\n if self.input_data.get_value(InputType.TIME_PERIOD) == 'all':\n self._write_sample_with_date(cube, i, key_list)\n else:\n self._write_sample(cube, i, key_list)\n\n output_data_file_path = self._get_full_file_name()\n self._write_data_dict(output_data_file_path, key_list)\n\n return [output_data_file_path]","def write_current_voltage_csv(dir_name, file_name, all_data_raw, freqs_explicit, samples, periods, curr_range,\n batt_volt, serial_n, start_time, log):\n k = samples * periods\n all_data = []\n times = []\n delimiter = ','\n\n for end_time, data_set in all_data_raw: #: Step 1\n voltage = data_set[:k]\n current = data_set[k:]\n\n times.append(end_time)\n\n all_data.append([\"%.7f\" % x for x in voltage])\n all_data[-1] += [(\"%\" + \".%if\" % (6 - curr_range)) % x for x in current]\n\n final_name = file_name\n suffix = 0\n\n while exists(join(dir_name, '%s.csv' % final_name)): #: Step 2\n if suffix == 0:\n final_name += '0'\n\n suffix += 1\n final_name = re.sub(r'[0-9]*$', str(suffix), final_name)\n\n full_path = join(dir_name, '%s.csv' % final_name) #: Step 3\n f = open(full_path, 'wb')\n\n n_freqs = len(freqs_explicit)\n per_sweep_data_names = ['File Name', 'Device Serial Number', 'Start Date and Time', 'Number of Frequencies',\n 'Current Resolution (Amps)', 'Battery OCV (Volts)']\n current_voltage_data_str = []\n\n first_column_l = -float('inf')\n\n for data_name in per_sweep_data_names: #: Step 4\n first_column_l = max(first_column_l, len(data_name))\n\n column_widths = [first_column_l]\n\n for freq_id in range(len(all_data)):\n column_widths.append(10 if freq_id != 0 else 17)\n column_widths.append(10)\n\n data_type_line = [(first_column_l, 'Data Type')] #: Step 5.a\n\n for freq_id in range(len(all_data)):\n column_l = column_widths[(freq_id + 1) * 2]\n data_type_line.append((max(column_l, 10 if freq_id != 0 else 17), 'V'))\n data_type_line.append((max(column_l, 10), 'I'))\n\n frequencies = [(first_column_l, 'Frequency (Hz)')] #: Step 5.b\n\n for freq_id in range(len(all_data)):\n column_l = column_widths[(freq_id + 1) * 2]\n freq_explicit = \"%.2E\" % (Decimal(freqs_explicit[freq_id]) / 1000)\n frequencies.append((max(column_l, 10 if freq_id != 0 else 17), freq_explicit))\n frequencies.append((max(column_l, 10), freq_explicit))\n\n times_line = [(first_column_l, 'Time from start (s)')] #: Step 5.c\n\n for freq_id in range(len(all_data)):\n if freq_id == 0:\n time_diff = 0\n else:\n end_time = times[freq_id - 1]\n column_l = column_widths[(freq_id + 1) * 2]\n time_diff = (end_time - start_time).seconds\n\n times_line.append((max(column_l, 10 if freq_id != 0 else 17), str(time_diff)))\n times_line.append((max(column_l, 10), str(time_diff)))\n\n samples_line = [(first_column_l, 'Samples per period')] #: Step 5.d\n\n for freq_id in range(len(all_data)):\n column_l = column_widths[(freq_id + 1) * 2]\n freq_bit = int(np.round(np.log2(float(freqs_explicit[freq_id]) / F_MIN))) & 23\n freq_explicit = 2 ** (27 - freq_bit) if freq_bit >= 21 else 128\n\n samples_line.append((max(column_l, 10 if freq_id != 0 else 17), str(freq_explicit)))\n samples_line.append((max(column_l, 10), str(freq_explicit)))\n\n second_column_l = column_widths[1]\n\n #: Step 5.e\n per_sweep_data_vals = map(str, ['%s.csv' % file_name, serial_n, '%02i/%02i/%02i %02i:%02i:%02i' %\n (start_time.month, start_time.day,\n start_time.year - 2000, start_time.hour,\n start_time.minute, start_time.second),\n n_freqs, CURRENT_RANGE_VALS[curr_range], \"%.3f\" % batt_volt])\n\n per_sweep_data = [build_line([(first_column_l, per_sweep_data_names[i]),\n (second_column_l, per_sweep_data_vals[i])], delimiter) for i in\n range(len(per_sweep_data_names))]\n\n #: Step 5.f\n for i in range(k):\n line = [(first_column_l, str(i + 1))]\n\n for freq_id in range(len(all_data)):\n column_l = column_widths[(freq_id + 1) * 2]\n voltage = str(all_data[freq_id][i])\n current = str(all_data[freq_id][i + k])\n\n line.append((max(column_l, 10 if freq_id != 0 else 17), voltage))\n line.append((max(column_l, 10), current))\n\n current_voltage_data_str.append(build_line(line, delimiter))\n\n f.write(\"\\n\".join(per_sweep_data) + '\\n\\n') #: Step 6\n f.write(build_line(data_type_line, delimiter) + '\\n')\n f.write(build_line(frequencies, delimiter) + '\\n')\n f.write(build_line(times_line, delimiter) + '\\n')\n f.write(build_line(samples_line, delimiter) + '\\n')\n f.write(\"\\n\".join(current_voltage_data_str))\n f.close()\n\n log([(\"Successfully wrote file '%s.csv' to path %s.\" % (final_name, dir_name), 0)]) #: Step 7","def _csvWriter(self):\r\n # Initialize Header\r\n table = []\r\n voltageRow = []\r\n for i in range(len(self._voltages)):\r\n voltageRow.append(self._voltages[i][0])\r\n voltageRow.append(\" \")\r\n if self._vna.isTwoComponents():\r\n voltageRow.append(\" \")\r\n table.append(voltageRow)\r\n \r\n # Fill table with data\r\n # if self._vna.isTwoComponents():\r\n # for i in range(len(self._frequency[0])):\r\n # row = []\r\n # for j in range(len(self._frequency)):\r\n # row.append(self._frequency[j][i])\r\n # row.append(self._intensity[j][2*i])\r\n # row.append(self._intensity[j][2*i + 1])\r\n # table.append(row)\r\n # else: \r\n for i in range(len(self._frequency[0])):\r\n row = []\r\n for j in range(len(self._frequency)):\r\n row.append(self._frequency[j][i])\r\n row.append(self._intensity[j][i])\r\n table.append(row)\r\n\r\n # Write to CSV\r\n filename = 'CSVs/' + self._vna.getDateFormatted() + '.csv'\r\n with open(filename, 'w', newline='') as csvfile:\r\n dataWriter = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_MINIMAL)\r\n for i in range(len(table)):\r\n dataWriter.writerow(table[i])","def csvOutput(cycle, fctimes, beachdata, offshoredata, surfdata, fname='isurf_output.csv', outdir='.'):\n\n datestr = cycle.strftime('%Y%m%d00')\n\n with open(outdir+'/%s' %fname,'w') as outp:\n outp.write(datestr+'\\r\\n')\n for isite in range(len(beachdata['name'])):\n outp.write('\\r\\n')\n outp.write('%s' %beachdata['name'][isite] + '\\r\\n')\n outp.write('%d' %beachdata['type'][isite] + '\\r\\n')\n #outp.write('TI Hsmo Tpmo Dmo Hseq Tpeq DmEq Hsbr Dpbr\\r\\n')\n #outp.write('LT,Wspd,Wdir,Hsmo,Tpmo,Dmo,Tide,Hseq,Tpeq,DmEq,Hsbr,Dpbr,Hlbr,Hhbr,BT\\r\\n')\n outp.write('LT,Wspd,Wdir,Hsmo,Tpmo,Dmo,Hseq,Tpeq,DmEq,Hsbr,Dpbr,Hlbr,Hhbr,BT\\r\\n')\n\n\t # write out to file\n for itime in range(len(fctimes)):\n\n # write out the data values to file\n\t #outp.write ('%02d' %fctimes[lp] + ' %4.2f %4.1f %3d' %tuple([hm0[lp,isite], tp[lp,isite], dirn[lp,isite]]) + \\\n # ' %4.2f %4.1f %3d' %tuple([hsshwd[lp,isite], tpshwd[lp,isite], reldir[lp,isite]]) + ' %4.2f %4.2f' %tuple([hsbkinit[lp,isite], dpsat[lp,isite]]) + '\\r\\n')\n\t outp.write('%02d' %fctimes[itime] + \\\n ',%4.1f' %offshoredata['wspd'][itime,isite] + \\\n #',%3d' %offshoredata['wdir'][itime,isite] + \\\n ',%4.2f' %offshoredata['hm0'][itime,isite] + \\\n ',%4.1f' %offshoredata['tp'][itime,isite] + \\\n ',%3d' %offshoredata['dirn'][itime,isite] + \\\n ',%4.2f' %surfdata['shorewardHs'][itime,isite] + \\\n ',%4.1f' %surfdata['shorewardT'][itime,isite] + \\\n ',%3d' %surfdata['relativeDirn'][itime,isite] + \\\n ',%4.2f' %surfdata['breakerHs'][itime,isite] + \\\n ',%4.2f' %surfdata['saturatedDepth'][itime,isite] + \\\n ',%4.2f' %surfdata['Hb1in3'][itime,isite] + \\\n ',%4.2f' %surfdata['Hb1in10'][itime,isite] + \\\n ',%1d' %surfdata['breakerType'][itime,isite] + '\\r\\n')\n outp.close()","def genScheduleCSV():\r\n try: \r\n printSchedule()\r\n save_class_list()\r\n print(\"\\nSchedule generated, check working directory\")\r\n except Exception as e:\r\n print(\"Exception found\" + str(e))","def generate_csv(results, path):\n csvpath = path + '/results.csv'\n\n if os.path.exists(csvpath):\n os.remove(csvpath)\n\n csvf = open(csvpath, 'w')\n\n # Header\n csvf.write(\"Powerpoint, Mean, Mode\\n\")\n\n # Results\n for power in results:\n mean = 0\n count = 0\n mode = 0\n maxc = 0\n for freq in results[power]:\n freqc = results[power][freq]\n\n mean += freq * freqc\n count += freqc\n\n if freqc > maxc:\n mode = freq\n\n mean /= count\n\n csvf.write(f\"{power}, {mean}, {mode}\\n\")\n\n csvf.close()","def createOutput():\n\n firstPeriod = True\n # get edge No\n edgesNo = 0\n edgesSet = set()\n for timestep, taxiList in vtypeDict.iteritems():\n for tup in taxiList:\n edgesSet.add(tup[1])\n edgesNo = len(edgesSet)\n\n outputFile = open(path.FQoutput, 'w')\n outputFile.write('<?xml version=\"1.0\"?>\\n')\n outputFile.write('<paramEffects aggregationInterval=\"%d\" vehicles=\"%d\" edges=\"%d\">\\n' % (\n aggInterval, vehSum, edgesNo))\n for period, quota, vtypeDictR, taxiSum in generatePeriodQuotaSets(True):\n if quota is None:\n if not firstPeriod:\n outputFile.write(\"\\t</periods>\\n\")\n else:\n firstPeriod = False\n outputFile.write('\\t<periods period=\"%d\">\\n' % (period))\n else:\n simpleTaxiMeanVList = [0, 1]\n simpleEdgeMeanVList = [0, 1]\n drivenEdgesSet = set()\n\n if len(vtypeDictR) == 0: # if the processed FCD returns no Values\n print(\"noData p\", period, \" q\", quota)\n drivenEdgesSet.add(0)\n else: # create mean from all taxi speed values\n for timestep, taxiList in vtypeDictR.iteritems():\n for tup in taxiList: # all elements in this timestep\n simpleTaxiMeanVList[0] += tup[2]\n simpleTaxiMeanVList[1] += 1\n drivenEdgesSet.add(tup[1])\n # create mean from all edge speed values which are driven by the\n # chosen taxis\n drivenEdgesList = list(drivenEdgesSet)\n drivenEdgesList.sort()\n # print \"dataSets \",simpleTaxiMeanVList[1]\n\n # --edgeDump-- #\n \"\"\"\n for i in edgeDumpDict.keys(): #all intervals\n for edge,v in edgeDumpDict[i]:\n if BinarySearch.isElmInList(drivenEdgesList,edge):\n simpleEdgeMeanVList[0]+=v\n simpleEdgeMeanVList[1]+=1\n \"\"\"\n # --vtype-- #\n\n for timestep, taxiList in vtypeDict.iteritems():\n for tup in taxiList:\n if BinarySearch.isElmInList(drivenEdgesList, tup[1]):\n simpleEdgeMeanVList[0] += tup[2]\n simpleEdgeMeanVList[1] += 1\n\n # calc values for output\n detectedEdges = len(drivenEdgesSet)\n relDetectedEdges = detectedEdges * 100.0 / edgesNo\n vSim = simpleEdgeMeanVList[0] / simpleEdgeMeanVList[1]\n vSimFCD = simpleTaxiMeanVList[0] / simpleTaxiMeanVList[1]\n vAbsDiff = vSimFCD - vSim\n if vSim != 0:\n vRelDiff = vAbsDiff / vSim * 100\n else:\n vRelDiff = 100\n if vRelDiff < -40:\n vRelDiff = -35\n\n outputFile.write('\\t\\t<values taxiQuota=\"%f\" taxis=\"%d\" simMeanSpeed=\"%f\" simFcdMeanSpeed=\"%f\" ' % (\n quota, taxiSum, vSim, vSimFCD,))\n outputFile.write('detectedEdges=\"%d\" notDetectedEdges=\"%d\" ' % (\n detectedEdges, edgesNo - detectedEdges))\n outputFile.write('absSpeedDiff=\"%f\" relSpeedDiff=\"%f\" relDetectedEdges=\"%f\" relNotDetectedEdges=\"%f\"/>\\n' %\n (vAbsDiff, vRelDiff, relDetectedEdges, 100 - relDetectedEdges))\n outputFile.write(\"\\t</periods>\\n</paramEffects>\")\n outputFile.close()","def output():\n\n if args.top and not args.tfidf and not args.svd:\n most_frequent(vector).to_csv(path_or_buf=\"top{}_vectorfile.csv\".format(args.top))\n\n elif args.top and args.tfidf and not args.svd:\n tfidf_transform(most_frequent(vector)).to_csv(path_or_buf=\"tfidf_top{}.csv\".format(args.top))\n\n elif args.top and args.tfidf and args.svd:\n svd_transform(tfidf_transform(most_frequent(vector)), indexes).to_csv(path_or_buf=\"svd{}_tfidf_topn.csv\".format(args.svd))\n\n elif args.tfidf and not args.top and not args.svd:\n tfidf_transform(vector).to_csv(path_or_buf=\"tfidf.csv\")\n\n elif args.svd and not args.top and not args.tfidf:\n svd_transform(vector, indexes).to_csv(path_or_buf=\"svd{}_vector.csv\".format(args.svd))\n\n elif args.tfidf and args.svd and not args.top:\n svd_transform(tfidf_transform(vector), indexes).to_csv(path_or_buf=\"svd{}_tfidf.csv\".format(args.svd))\n\n else:\n vector.to_csv(path_or_buf=\"vectorfile.csv\")","def output_selectivities(run_name):\n\tf = open(toggles.OUTPUT_PATH + run_name + '_sample_selectivites.csv', 'a')\n\tfor p in toggles.CHOSEN_PREDS:\n\t\tpred = Predicate.objects.all().get(pk=p+1)\n\t\tf.write(str(pred.calculatedSelectivity) + \", \" + str(pred.totalTasks) + \", \" + str(pred.num_ip_complete) + \"; \")\n\tf.write('\\n')\n\tf.close()","def write_csv_pairwise(self, agent_num):\n # self.last_timestep_data = []\n for task_num, i in enumerate(self.tasks):\n current_task_data = []\n task_loc = i.getloc()\n vectorized_task_loc = self.get_vectorized_location(task_loc)\n current_task_data.append(self.t)\n current_task_data.append(self.w_EDR)\n current_task_data.append(self.w_RESOURCE)\n current_task_data.append(self.w_DISTANCE)\n current_task_data.append(agent_num)\n\n current_task_data.append(task_num)\n current_task_data.extend(self.is_agent_idle[agent_num]) # Feature 6\n current_task_data.append((self.is_task_finished[0][task_num])) # Feature 2\n current_task_data.append((self.is_task_enabled[0][task_num])) # Feature 3\n current_task_data.append((self.is_task_alive[0][task_num])) # Feature 4\n current_task_data.append((self.travel_time_constraint_satisfied[agent_num][task_num])) # Feature 5\n is_occupied = self.agent_locations[0][vectorized_task_loc] # if 1 agent is there, 0 is unoccupied\n current_task_data.append((is_occupied)) # Feature 1\n current_task_data.append((self.agent_distances[agent_num][task_num])) # Feature 7\n current_task_data.append((self.orientation[agent_num][task_num])) # Feature 9\n current_task_data.append((self.task_deadlines[0][task_num])) # Feature 10\n current_task_data.append((self.is_task_in_progress[0][task_num])) # Feature 11\n current_task_data.append((\n self.orientation[agent_num][task_num] * self.agent_distances[agent_num][task_num])) # Feature 12\n current_task_data.append((self.how_many_tasks_in_each_square[0][vectorized_task_loc])) # Feature 8\n if self.task_to_schedule == -1:\n null_task = 1\n else:\n null_task = 0\n current_task_data.append(null_task)\n current_task_data.append(self.task_to_schedule[0]) # Output\n self.pairwise_total_data.append(current_task_data)\n # self.last_timestep_data.append(current_task_data)\n # with open('11_schedule.csv', 'a') as outfile:\n # writer = csv.writer(outfile)\n # writer.writerow(current_task_data)","def export_csv( self, db_device_adapters, db_start, db_end, min_points = 10, csv_file_name = \"data.csv\" ):\n msg = f\"Export data to csv file {csv_file_name}...\"\n AppGlobal.gui.display_info_string( msg )\n sep = \"\\t\"\n for i_device_adapter in db_device_adapters:\n #time_data, inst_pw_data, total_power_data, = self._prep_data( i_device_adapter, db_start, db_end, min_points )\n i_device_adapter.retrived_data_cache = self._prep_data( i_device_adapter, db_start, db_end, min_points )\n time_data, inst_pw_data, total_power_data, = i_device_adapter.retrived_data_cache\n\n device_name = i_device_adapter.name\n\n if time_data is None:\n msg = f\"No data for {device_name}.\"\n AppGlobal.gui.display_info_string( msg )\n else:\n with open( csv_file_name, \"a\" ) as a_file: # we are appending\n a_file.write( f'\"device\"{sep}\"time_data\"{sep}\"inst_pw_data\"{sep}\"total_power_data\"\\n' )\n for ix_list, i_time in enumerate( time_data ):\n a_file.write( f\"{device_name}{sep}{time_data[ ix_list ]}{sep}{inst_pw_data[ ix_list ]}{sep}{total_power_data[ ix_list ]}\\n\" )\n\n msg = f\"...CSV file complete.\"\n AppGlobal.gui.display_info_string( msg )","def start_rec(self):\r\n if not os.path.exists(MEASUREMENTS_DIR):\r\n os.makedirs(MEASUREMENTS_DIR)\r\n self._csv_file = open(MEASUREMENTS_DIR.child('data.csv'), 'wb')\r\n self._csv_writer = csv.DictWriter(\r\n self._csv_file, fieldnames=list(self._data.keys()))\r\n self._csv_writer.writeheader()","def generate_sdfs(timing_data, sdf_path):\n\n def make_speed_model(data):\n \"\"\"\n Makes a speed model structure for the SDF writer\n \"\"\"\n model = dict()\n\n # Create entry for sdf writer\n iport = dict()\n iport['port'] = data[\"input\"]\n iport['port_edge'] = None\n oport = dict()\n oport['port'] = data[\"output\"]\n oport['port_edge'] = None\n\n paths = dict()\n paths = add_timing_paths_entry(\n paths, 'slow', [data['SLOW_MIN'], None, data['SLOW_MAX']])\n paths = add_timing_paths_entry(\n paths, 'fast', [data['FAST_MIN'], None, data['FAST_MAX']])\n\n # Net delay\n if data[\"is_net\"]:\n model = utils.add_interconnect(iport, oport, paths)\n model[\"is_absolute\"] = True\n\n # Routing bel delay\n else:\n model = utils.add_iopath(iport, oport, paths)\n model[\"is_absolute\"] = True\n\n return model\n\n # Build SDF structures\n sdf_data = dict()\n for site_name, site_data in timing_data.items():\n\n # New SDF\n if site_name not in sdf_data:\n sdf_data[site_name] = dict()\n sdf_data[site_name][\"cells\"] = dict()\n\n for cell_type, cell_data in site_data.items():\n\n # New celltype\n if cell_type not in sdf_data[site_name][\"cells\"]:\n sdf_data[site_name][\"cells\"][cell_type] = dict()\n\n for instance, instance_data in cell_data.items():\n\n # New cell instance\n if instance not in sdf_data[site_name][\"cells\"][cell_type]:\n sdf_data[site_name][\"cells\"][cell_type][instance] = dict()\n\n # Add speed models\n for speed_model, speed_data in instance_data.items():\n sdf_data[site_name][\"cells\"][cell_type][instance][\n speed_model] = make_speed_model(speed_data)\n\n # Emit SDFs\n for name, data in sdf_data.items():\n fname = os.path.join(sdf_path, name.upper() + \".sdf\")\n fdata = sdfparse.emit(data, timescale='1ns')\n\n with open(fname, \"w\") as fp:\n fp.write(fdata)","def print(self):\n df = self.gen_test()\n # print(df)\n df.to_csv('some_dated_file.csv', index=False)\n return df","def create_csv(start: object, end: object):\n data_frame = web.DataReader(\"^DJI\", \"yahoo\", start, end)\n data_frame.to_csv(\"dow.csv\")","def dump_all_binaries_to_CSV():\n ## TODO\n timenow = datetime.now()","def analysis_dev_sec(self):\n #calc the date\n time_now = int(time.time())\n time_local = time.localtime(time_now)\n date = time.strftime(\"%Y-%m-%d\",time_local)\n sum_cpu_ratio = 0\n sum_gpu_mem_size = 0\n # key: time key\n key_re_time = \"[0-9]+ [0-9]+:[0-9]+:[0-9]+ 20[12][][0-9]\"\n # key: temperature key\n key_re_temper = \"[0-9]+C\"\n # key: gpu percent key\n key_re_percent = \"[0-9]+%\"\n # key: gpu mem key\n key_re_mem = \"%s\" % self.pid\n key_re_mem_null = \"No running processes found\"\n # key: line ending key\n key_ending = \"====ending====\"\n\n new_gpu_data_count = 0\n sum_gpu_usage_percent_all = 0\n for line in self.file_gpu.readlines():\n if re.search(key_re_time, line):\n # time own unit\n # 1. colect the gpu time info\n final_time = date + \" \" + line.split()[3]\n self.gpu_pertime.append(final_time)\n elif re.search(key_re_temper, line) and re.search(key_re_percent, line):\n #print \"2222, data_line: %s\" % line\n # 2. colect the gpu temperature info\n # 3. colect the gpu usage percentage info\n temper = float(line.split()[2].rstrip(\"C\"))\n gpu_usage = float(line.split()[12].rstrip(\"%\"))\n if new_gpu_data_count == 0:\n self.gpu_temper_1.append(temper)\n self.gpu_usage_percent_1.append(gpu_usage)\n elif new_gpu_data_count == 1:\n self.gpu_temper_2.append(temper)\n self.gpu_usage_percent_2.append(gpu_usage)\n elif new_gpu_data_count == 2:\n self.gpu_temper_3.append(temper)\n self.gpu_usage_percent_3.append(gpu_usage)\n elif new_gpu_data_count == 3:\n self.gpu_temper_4.append(temper)\n self.gpu_usage_percent_4.append(gpu_usage)\n new_gpu_data_count += 1\n elif re.search(key_re_mem, line) or re.search(key_re_mem_null, line):\n # 4. colect the gpu mem info\n this_gpu_num = line.split()[1]\n if \"MiB\" in line.split()[5]:\n this_gpu_mem = float(line.split()[5].strip(\"MiB\"))\n # TODO_this: if there have other unit\n\n if this_gpu_num == \"0\":\n self.gpu_mem_1.append(this_gpu_mem)\n elif this_gpu_num == \"1\":\n self.gpu_mem_2.append(this_gpu_mem)\n elif this_gpu_num == \"2\":\n self.gpu_mem_3.append(this_gpu_mem)\n elif this_gpu_num == \"3\":\n self.gpu_mem_4.append(this_gpu_mem)\n elif this_gpu_num == \"No\":\n self.gpu_mem_1.append(0)\n self.gpu_mem_2.append(0)\n self.gpu_mem_3.append(0)\n self.gpu_mem_4.append(0)\n \n elif re.search(key_ending, line):\n # control unit\n # 1.complete the gpu_mem list\n max_len_gpu_mem = max(len(self.gpu_mem_4), len(self.gpu_mem_3), len(self.gpu_mem_2), len(self.gpu_mem_1))\n min_len_gpu_mem = min(len(self.gpu_mem_4), len(self.gpu_mem_3), len(self.gpu_mem_2), len(self.gpu_mem_1))\n if max_len_gpu_mem != min_len_gpu_mem:\n if len(self.gpu_mem_1) != max_len_gpu_mem:\n self.gpu_mem_1.append(0)\n if len(self.gpu_mem_2) != max_len_gpu_mem:\n self.gpu_mem_2.append(0)\n if len(self.gpu_mem_3) != max_len_gpu_mem:\n self.gpu_mem_3.append(0)\n if len(self.gpu_mem_4) != max_len_gpu_mem:\n self.gpu_mem_4.append(0)\n new_gpu_data_count = 0\n\n # ! because all the list is equal\n for i in range(len(self.gpu_mem_1)):\n self.gpu_usage_percent_all.append(self.gpu_usage_percent_1[i] + self.gpu_usage_percent_2[i] + self.gpu_usage_percent_3[i] + self.gpu_usage_percent_4[i])\n\n #self.gpu_mem_all.append(self.gpu_mem_1[i] + self.gpu_mem_2[i] + self.gpu_mem_3[i] + self.gpu_mem_4[i])\n self.gpu_mem_all.append(self.gpu_mem_1[i] + self.gpu_mem_2[i] + self.gpu_mem_3[i] + self.gpu_mem_4[i])\n sum_gpu_mem_size += max(self.gpu_mem_1[i], self.gpu_mem_2[i], self.gpu_mem_3[i], self.gpu_mem_4[i])\n\n self.gpu_temper_max.append(max(self.gpu_temper_1[i] ,self.gpu_temper_2[i] ,self.gpu_temper_3[i] ,self.gpu_temper_4[i]))\n\n version_gpu_usage_percent_all = max(self.gpu_usage_percent_all)\n\n version_gpu_mem_all = max(self.gpu_mem_all)\n version_gpu_mem_avg = round(sum_gpu_mem_size/len(self.gpu_mem_all), 2)\n\n version_gpu_temper_max = max(self.gpu_temper_max)\n\n print \"version_gpu_usage_percent_all: %s\" % version_gpu_usage_percent_all\n print \"version_gpu_mem_all: %s\" % version_gpu_mem_all\n print \"version_gpu_mem_avg: %s\" % version_gpu_mem_avg\n print \"version_gpu_temper_max: %s\" % version_gpu_temper_max\n\n # insert into database: nvidia_list_1sec\n if self.db_onoff == \"on\":\n # insert into database: nvidia_list_1sec_avg\n self.mysql.insert_table_sql_nvidia_version(self.time_sql, version_gpu_usage_percent_all, version_gpu_mem_avg, version_gpu_temper_max)\n # insert into database: nvidia_list_1sec_max\n #self.mysql.insert_table_sql_nvidia_version(self.time_sql, version_gpu_usage_percent_all, version_gpu_mem_all, version_gpu_temper_max)","def csv(self):\n result = \"\"\n for cpu in self.cpus_current:\n result += str(cpu) + \",\"\n return result","def create_csv_file(self):\r\n # Create a new csv-file\r\n with open(self.fname, 'w') as f:\r\n writer = csv.writer(f, dialect='excel')\r\n writer.writerow(['set_time',\r\n 'read_time_P_ac',\r\n 'read_time_P_bat',\r\n 'soc',\r\n 'set_value',\r\n 'P_ac',\r\n 'P_bat'])","def print_v(self, filename, gather=True):\n global controller\n timeStep = (controller.dao.machineTimeStep*1.0)/1000.0\n v = self.get_v(gather, compatible_output=True)\n utility_calls.check_directory_exists(filename)\n fileHandle = open(filename, \"w\")\n first_id = 0\n num_neurons = self.vertex.atoms\n dimensions = self.vertex.atoms\n fileHandle.write(\"# first_id = %d\\n\" % first_id)\n fileHandle.write(\"# n = %d\\n\" % num_neurons)\n fileHandle.write(\"# dt = %f\\n\" % timeStep)\n fileHandle.write(\"# dimensions = [%d]\\n\" % dimensions)\n fileHandle.write(\"# last_id = %d\\n\" % (num_neurons-1))\n for (neuronId, time, value) in v:\n fileHandle.write(\"%f\\t%d\\n\" % (value, neuronId))\n fileHandle.close()","def dbtocsv():\n connection = sqlite3.connect(\"sensordata.db\")\n cursor = connection.cursor()\n cursor.execute(\"Select * from sensordata\")\n roadstationdata = cursor.fetchall()\n\n with open('roadstationdata.csv', 'w') as f:\n writer = csv.writer(f)\n writer.writerow(['id','name','value','unit','time'])\n writer.writerows(roadstationdata)","def calibration(date):\r\n\r\n l = []\r\n for _ in range(NUM_OF_CALIBRATION_BLOCKS):\r\n block = q.get()\r\n block = block.flatten()\r\n energy = np.sum(block ** 2)\r\n l.append(energy)\r\n std_dev = np.std(l)\r\n mean = np.mean(l)\r\n l = []\r\n l.extend((date, mean, std_dev))\r\n\r\n with open('calibration.csv', mode = 'a') as file:\r\n create = csv.writer(file)\r\n create.writerow(l)\r\n print(mean, std_dev)\r\n return mean, std_dev","def lv_analysis():\r\n\r\n global params\r\n n = params['n']\r\n lvmin = params['lvmin']\r\n lvmax = params['lvmax']\r\n lvstep = params['lvstep']\r\n ns = params['ns']\r\n nt = params['nt']\r\n no = params['no']\r\n ne = params['ne']\r\n nf = params['nf']\r\n lv_dir = create_dir(TIMES_PATH + 'lv')\r\n filename = datetime.datetime.now().strftime(DATE_FORMAT) + '.csv'\r\n with open(lv_dir + filename, 'wb') as csvfile:\r\n fw = csv.writer(csvfile)\r\n fw.writerow(('lv', 'ns', 'nt', 'no', 'ne', 'nf',\r\n 'method1', 'method2', 'method3_1', 'method3_2'))\r\n lv = lvmin\r\n while lv <= lvmax:\r\n times = [0] * 4\r\n for i in range(n):\r\n times = map(sum, zip(times, get_times(lv, ns, nt, no, ne, nf)))\r\n show_progress('lv', lv, lvmin, lvmax, lvstep, i, n)\r\n times = map(lambda x : float(x) / n, times)\r\n fw.writerow((lv, ns, nt, no, ne, nf) + tuple(times))\r\n lv += lvstep\r\n csvfile.close()","def dt():\n wheels = [-2, -1, 0, 1, 2]\n stations = [1,2,3,4]\n sectors = range(1,13)\n sectors4 = range(1,15) # more sectors for station 4\n\n dt_info = {\n \"wheels\":wheels,\n \"stations\":stations,\n \"sectors\": sectors,\n \"sectors4\":sectors4}\n\n return dt_info","def enter_data_to_running_index():\n print('{:~^20}'.format('VDOT Table'))\n return get_distance(), get_time()","def pf_analysis():\r\n\r\n global params\r\n n = params['n']\r\n level = params['level']\r\n pfmin = params['pfmin']\r\n pfmax = params['pfmax']\r\n pfstep = params['pfstep']\r\n ns = params['ns']\r\n nt = params['nt']\r\n po = params['po']\r\n pe = params['pe']\r\n pf_dir = create_dir(TIMES_PATH + 'pf')\r\n filename = datetime.datetime.now().strftime(DATE_FORMAT) + '.csv'\r\n with open(pf_dir + filename, 'wb') as csvfile:\r\n fw = csv.writer(csvfile)\r\n fw.writerow(('lv', 'ns', 'nt', 'no', 'ne', 'pf', 'nf',\r\n 'method1', 'method2', 'method3_1', 'method3_2'))\r\n pf = pfmin\r\n while pf <= pfmax:\r\n no = max(int(round(po * nt)), 1)\r\n ne = max(int(round(pe * no)), 1)\r\n nf = max(int(round(pf * nt)), 1)\r\n times = [0] * 4\r\n for i in range(n):\r\n times = map(sum, zip(times, get_times(level, ns, nt, no, ne, nf)))\r\n show_progress('pf', pf, pfmin, pfmax, pfstep, i, n)\r\n times = map(lambda x: float(x) / n, times)\r\n fw.writerow((level, ns, nt, no, ne, pf, nf) + tuple(times))\r\n pf += pfstep\r\n csvfile.close()","def gen_csv_line(dt, data_type, ss_code, ss_config, bin_num, beam_num, blank, bin_size, value):\n #dt_str = dt.strftime(Ensemble.CSV_DATETIME_FORMAT)\n dt_str = dt.isoformat()\n\n bin_depth = Ensemble.get_bin_depth(blank, bin_size, bin_num)\n\n return \"{},{},{},{},{},{},{},{}\".format(dt_str, data_type, ss_code, ss_config, bin_num, beam_num, bin_depth, value)","def gen_fps():\n global data_src ,output_dir \n logger = TaskFileLogger(\"GenFP\")\n\n h_vars = load_hydro_var()\n if not os.path.exists(output_dir):\n os.mkdir(output_dir)\n\n for h_type,var_d in h_vars.items():\n print \"considering %s\" %h_type\n\n t_output_dir = os.path.join(output_dir,h_type)\n if not os.path.exists(t_output_dir):\n print \"creating path %s\" %t_output_dir\n os.mkdir(t_output_dir)\n logger.log(\"%s started\" %(h_type))\n\n for fname in glob.glob(data_src):\n complex_id = os.path.basename(fname).split('.')[0] \n fp_path = os.path.join(t_output_dir,complex_id + \".fp\" )\n if os.path.exists(fp_path):\n #print \"%s processed\" %complex_id\n continue\n print \"processing %s,fp saved as %s\" %(fname , fp_path )\n c = Complex(fname,hydro_dict = var_d)\n c.get_fp()\n c.write_fp_to_file(fp_path)\n\n logger.log(\"%s finished\" %(h_type))","def build_csv(path):\n # find unique param pairs in folder :\n num_ptrn = '[-+]?\\d*\\.\\d+|\\d+'\n all_files = glob.glob(path)\n param_strings = [f.split('_')[4] for f in all_files]\n params1 = set([tuple(re.findall(num_ptrn,s)) for s in param_strings])\n iters = [str(i) for i in range(2)]\n params2 = list(product(list(params1),iters))\n params2 = [(p[0][0],p[0][1],p[1]) for p in params2 if type(p[0]) == tuple] + list(params1)\n rows = []\n deviation_rows = []\n for i,prms in enumerate(params2):\n print(prms)\n t1 = time.time()\n files = [f for f in all_files if '_' + prms[0] + 'M' in f and 'X' + prms[1] + '_' in f]\n if len(prms) == 3:\n files = [f for f in files if 'iter'+prms[2] in f]\n itr = int(prms[2])\n else:\n files = [f for f in files if 'iter' not in f]\n itr = 2\n files.sort(reverse = True,key = lambda x: int(re.findall(num_ptrn,x)[-1]))\n # only take first 100 cells for faster analysis :\n\n # extract tracks from files :\n tracks = [np.loadtxt(f) for f in files]\n tracks = [handle_boundaries(t) for t in tracks]\n print('number of cells for paramset : ',len(tracks))\n\n vec_tracks = np.array([to_vecs(t) for t in tracks])\n speeds = [[norm(v) for v in vec_track] for vec_track in vec_tracks]\n speeds = [item for sublist in speeds for item in sublist]\n speed = np.mean(speeds)\n std_speed = np.std(speeds)\n print('Speed calculated')\n\n # pooled persistance : \n t2 = time.time()\n averages2 = pool_ac(np.array([autocor2(t) for t in tracks]))\n t3 = time.time()\n pooled_pers = Persist_tracks([averages2])\n t4 = time.time()\n\n rows.append([prms[0],prms[1],itr,speed,std_speed,np.mean(pooled_pers),np.std(pooled_pers)])\n print(rows[-1])\n print('computing time :',time.time() - t1)\n print('dots per dts time : ',t3 - t2)\n print('half time :',t4 - t3)\n df1 = pd.DataFrame(data = rows,\n columns = ['Lambda', 'Max_act','iter','speed','speed_std','persistance','std_persit'])\n df1.to_csv('FITFULL/4ACT_all.csv')","def write_log(self):\n with open(self.trav_stat_file, 'a') as stat_file:\n travel_writer = csv.writer(stat_file)\n # Every row starts with the start and destnation\n row = [self.start, self.dest]\n # This uses a static list so that the order is fixed\n for state in [\"waiting\", \"riding\", \"transferring\"]:\n state_total = sum(self.time_record[state])\n row.append(state_total)\n travel_writer.writerow(row)","def init_csv_file(self):\n folder = \"/home/pi/data/\" + datetime.now().strftime(\"%Y_%m_%d\") + \"/\"\n if not os.path.isdir(folder):\n # append 'a' to the folder name until we find a name that does not exist\n while os.path.exists(folder):\n folder = folder[:-1] + \"a\" + \"/\"\n os.mkdir(folder)\n filename = folder + 'particledata_' + datetime.now().strftime (\"%H-%M-%S\") \n while os.path.exists(filename):\n filename = filename + '_a'\n filename += '.csv'\n log.info('Writing data to: ' + filename)\n self.file = open(filename, \"w\")\n self.file.write('Unix Time;Human Readable Time;pm 2.5;pm 10;Has Fix;Longitude;Latitude;Altitude;GPS Unix Time\\n')\n self.file.flush()\n self.synced_time = False","def df():\n fs.df()","def __create_output_csv(self, df, score_list, elapsed_list):\n df['Similar']=score_list\n df['Elapsed']=elapsed_list\n df.to_csv('Output.csv',index=False)\n return df","def RWC_table(datasource, output, time):\n with open(output + '_' + time + '.csv', 'wb') as destination:\n writer = csv.writer(destination)\n if time == 'day':\n writer.writerow(['file'] + lod)\n elif time == 'week':\n writer.writerow(['file'] + weeks)\n \n for file in os.listdir(datasource):\n rowlist = []\n if file.endswith(\".csv\"):\n rowlist.append(file)\n print(file)\n\n # Check timeinterval and run pipeline with those settings\n if time == 'day':\n for day in tqdm(lod):\n rowlist.append(pipeline(datasource + file, [day], False, False))\n writer.writerow(rowlist)\n\n if time == 'week':\n for week in tqdm(weeks):\n rowlist.append(pipeline(datasource + file, week, False, False))\n writer.writerow(rowlist)","def save_component_csv (self, directory):\n #~ return\n if not self.was_run:\n #~ fname = os.path.join(directory,\n #~ self.component_name + \"_output.csv\")\n #~ fname = fname.replace(\" \",\"_\")\n\n #~ fd = open(fname, 'w')\n #~ fd.write(\"Wind Power minimum requirements not met\\n\")\n #~ fd.close()\n return\n\n\n years = np.array(range(self.project_life)) + self.start_year\n\n # ??? +/-\n # ???\n df = DataFrame({\n 'Wind: Capacity (kW)':self.load_offset_proposed,\n \"Wind: Generation (kWh/year)\": self.net_generation_wind,\n 'Wind: Energy Captured by Secondary Load'\n ' (gallons of heating oil equivalent)':\n self.diesel_equiv_captured,\n 'Wind: Assumed capacity factor':\n float(self.comp_specs['capacity factor']),\n 'Wind: Utility Diesel Displaced (gallons/year)':\n self.electric_diesel_reduction,\n 'Wind: Heat Recovery Lost (gallons/year)':\n self.loss_heat_recovery,\n \"Wind: Heat Recovery Cost Savings ($/year)\":\n self.get_heating_savings_costs(),\n \"Wind: Electricity Cost Savings ($/year)\":\n self.get_electric_savings_costs(),\n \"Wind: Project Capital Cost ($/year)\":\n self.get_capital_costs(),\n \"Wind: Total Cost Savings ($/year)\":\n self.get_total_savings_costs(),\n \"Wind: Net Benefit ($/year)\": self.get_net_benefit(),\n }, years)\n\n df[\"Community\"] = self.cd['name']\n\n ol = [\"Community\",\n 'Wind: Capacity (kW)',\n 'Wind: Energy Captured by Secondary Load'\n ' (gallons of heating oil equivalent)',\n 'Wind: Assumed capacity factor',\n 'Wind: Utility Diesel Displaced (gallons/year)',\n 'Wind: Heat Recovery Lost (gallons/year)',\n \"Wind: Generation (kWh/year)\",\n \"Wind: Heat Recovery Cost Savings ($/year)\",\n \"Wind: Electricity Cost Savings ($/year)\",\n \"Wind: Project Capital Cost ($/year)\",\n \"Wind: Total Cost Savings ($/year)\",\n \"Wind: Net Benefit ($/year)\"]\n fname = os.path.join(directory,\n self.cd['name'] + '_' + \\\n self.component_name.lower() + \"_output.csv\")\n fname = fname.replace(\" \",\"_\")\n\n df[ol].ix[:self.actual_end_year].to_csv(fname, index_label=\"Year\")","def print_dfs_output(G, d, f, pi):\n V = G[0]\n print (\" d f pi\")\n for v in V:\n print (\" {: <5}{: <5}{: <5}{: <5}\".format(v, d[v], f[v], pi[v]))","def coregister_formatted():\r\n\r\n print(\"begin coregister_formatted\")\r\n\r\n # check all records for pairs using the recordBegin time\r\n pair_records()\r\n\r\n # establish the beginning and end of the coregistered records\r\n define_pairedRecords()\r\n\r\n # coregister paired data in a single csv\r\n format_coregister()\r\n\r\n\r\n print(\"completed segment_formatted\")","def df():\n path, _ = os.path.split(os.path.abspath(__file__))\n project_path = os.path.join(path, os.pardir, os.pardir)\n\n values_path = os.path.join(project_path, \"data\", \"raw\", \"pumps_train_values.csv\")\n labels_path = os.path.join(project_path, \"data\", \"raw\", \"pumps_train_labels.csv\")\n\n train = pd.read_csv(values_path, index_col='id', parse_dates=[\"date_recorded\"])\n labels = pd.read_csv(labels_path, index_col='id')\n\n return train.join(labels)","def courant_processor(self):\n with open(join(self.logs_dir, \"courant.dat\"), 'w') as fh:\n fh.write(\"Time CoMean CoMax\\n\")\n while True:\n rexp = (yield)\n fh.write(self.time_str + \"\\t\" +\n \"\\t\".join(x for x in rexp.groups()) + \"\\n\")","def write_csv(self, agent_num):\n data = []\n data.append(self.t)\n data.append(self.w_EDR)\n data.append(self.w_RESOURCE)\n data.append(self.w_DISTANCE)\n data.append(agent_num)\n for task_num, task in enumerate(self.tasks):\n vectorized_task_loc = self.get_vectorized_location(task.getloc())\n is_occupied = self.agent_locations[0][vectorized_task_loc] # 1 if occupied\n data.append(is_occupied)\n # data.extend(np.ndarray.tolist(self.agent_locations)) # Feature 1\n data.extend(np.ndarray.tolist(self.is_task_finished)) # Feature 2\n data.extend(np.ndarray.tolist(self.is_task_enabled)) # Feature 3\n data.extend(np.ndarray.tolist(self.is_task_alive)) # Feature 4\n data.extend(np.ndarray.tolist(self.travel_time_constraint_satisfied[agent_num])) # Feature 5\n data.extend(self.is_agent_idle[agent_num]) # Feature 6\n data.extend(np.ndarray.tolist(self.agent_distances[agent_num])) # Feature 7\n for task_num, task in enumerate(self.tasks):\n vectorized_task_loc = self.get_vectorized_location(task.getloc())\n tasks_in_each_square = self.how_many_tasks_in_each_square[0][vectorized_task_loc] # 1 if occupied\n data.append(tasks_in_each_square)\n # data.extend(np.ndarray.tolist(self.how_many_tasks_in_each_square)) # Feature 8\n data.extend(np.ndarray.tolist(self.orientation[agent_num])) # Feature 9\n data.extend(np.ndarray.tolist(self.task_deadlines)) # Feature 10\n data.extend(np.ndarray.tolist(self.is_task_in_progress)) # Feature 11\n data.extend(np.ndarray.tolist(self.orientation[agent_num] * self.agent_distances[agent_num])) # Feature 12\n data.append(self.task_to_schedule) # Output\n self.naive_total_data.append(data)\n # with open('1_schedule.csv', 'a') as outfile:\n # writer = csv.writer(outfile)\n # writer.writerow(data)","def create_display_data_table():\n\n for ccd in range(0, 10):\n for node in range(0, 4):\n file = 'ccd' + str(ccd) + '_' + str(node)\n infile = data_dir + file\n outfile = web_dir + 'Data/' + file\n\n f = open(infile, 'r')\n data = [line.strip() for line in f.readlines()]\n f.close()\n\n fo = open(outfile, 'w')\n#\n#--- adding heading\n#\n line = \"#\\n#Date Mn K alpha Al K alpha Ti K alpha Slope Sigma Int Sigma\\n#\\n\"\n fo.write(line)\n for ent in data:\n atemp = re.split('\\s+', ent)\n stime = int(atemp[0])\n#\n#--- converting the date into <mon> <year> form (e.g. May 2013)\n#\n ltime = tcnv.axTimeMTA(stime)\n btemp = re.split(':', ltime)\n year = btemp[0]\n [mon, mdate] = tcnv.changeYdateToMonDate(int(year), int(btemp[1]))\n lmon = tcnv.changeMonthFormat(mon)\n line = lmon + ' ' + year \n for j in range(1, len(atemp)):\n line = line + '\\t' + atemp[j]\n\n line = line + '\\n'\n fo.write(line)\n fo.close()","def get_clk_spr_df(self) -> pd.DataFrame:\n return pd.read_feather(self.figure_data_paths.clk_spr_path)","def create_query_csv(self):\n\n self.query_df.to_csv(self.query_output_file)","def print_mod_factors_csv(df: pd.DataFrame):\n delimiter = ';'\n\n file_path = os.path.join(os.getcwd(), 'modelfactors.csv')\n with open(file_path, 'w') as output:\n for columnname, data in df.iteritems():\n line = f\"{columnname}\"\n for value in data:\n try:\n line += delimiter + '{0:.{prec}f}'.format(value, prec=__DECIMAL_PRECISION)\n except ValueError:\n line += '{}'.format(value)\n output.write(line + '\\n')\n if columnname == MOD_FACTORS_DOC['freq']:\n output.write(\"#\\n\")\n print(f'==INFO== Modelfactors written into {file_path}')","def export_tc_to_csv(self, xs, xe, ys, ye, dt=0.1):\n df = self.norm_stack[xs:xe, ys:ye, :]\n df_avg = df.mean((0, 1))\n df_std = df.std((0, 1))\n s_path = self.path.parent / (self.path.stem + '_timecourse.csv')\n save_path = self.get_file(s_path, 'csv')\n np.savetxt(save_path,\n np.vstack((np.arange(1, df_avg.shape[0]+1, dtype=np.intp), df_avg, df_std)).T,\n [\"%d\", \"%.4f\", \"%.4f\"], delimiter=\",\", header='frame, average, std')\n return save_path","def _output_performance(self):\n self.portfolio.create_equity_curve_dataframe()\n\n print(\"Creating summary statistics...\")\n stats = self.portfolio.output_summary_stats()\n\n print(\"Creating equity curve...\")\n print(self.portfolio.equity_curve.tail(10))\n pprint.pprint(stats)\n\n print(\"Signals: %s\" % self.signals)\n print(\"Orders: %s\" % self.orders)\n print(\"Fills: %s\" % self.fills)","def _cmd_export_cdt(args):\n sample_ids = list(map(core.fbase, args.filenames))\n table = export.merge_samples(args.filenames)\n formatter = export.EXPORT_FORMATS[\"cdt\"]\n outheader, outrows = formatter(sample_ids, table)\n write_tsv(args.output, outrows, colnames=outheader)","def write_to_csv(self, log_dir, run_dir, hmc=False):\n _, run_str = os.path.split(run_dir)\n avg_data = {\n 'log_dir': log_dir,\n 'run_dir': run_str,\n 'hmc': hmc,\n }\n\n for key, val in dict(sorted(self.data.items())).items():\n tensor = tf.convert_to_tensor(val)\n arr, steps = therm_arr(tensor.numpy(), therm_frac=0.2)\n if 'steps' not in avg_data:\n avg_data['steps'] = len(steps)\n avg_data[key] = np.mean(arr)\n\n # avg_data[key] = tf.reduce_mean(arr)\n\n avg_df = pd.DataFrame(avg_data, index=[0])\n outdir = os.path.join(BASE_DIR, 'logs', 'GaugeModel_logs')\n csv_file = os.path.join(outdir, 'inference.csv')\n head, tail = os.path.split(csv_file)\n io.check_else_make_dir(head)\n io.log(f'Appending inference results to {csv_file}.')\n if not os.path.isfile(csv_file):\n avg_df.to_csv(csv_file, header=True, index=False, mode='w')\n else:\n avg_df.to_csv(csv_file, header=False, index=False, mode='a')","def make_time_series(rics: list, fields: list, start_date: str, end_date: str, name: str) -> None:\n df = get_time_series(rics, fields, start_date, end_date)\n df.dropna(inplace=True)\n to_csv(df, name, time_series=True)","def write_plot(self):\n with open(self._graph_data_path, \"w+\") as f:\n run_time = self.start_time\n f.write(\"Time, Temperature\\n\")\n temperature = 0\n for step in self.profile[\"steps\"]:\n keys = list(step)\n if len(keys) > 0:\n if keys[0] == \"start\":\n temperature = step[\"start\"]\n if keys[0] == \"rest\":\n run_time += timedelta(minutes = step[\"rest\"])\n if keys[0] == \"ramp\":\n run_time += timedelta(minutes = step[\"ramp\"])\n temperature = step[\"to\"]\n if keys[0] == \"mashout\":\n temperature = step[\"mashout\"]\n time = run_time.strftime(\"%H:%M:%S, \")\n f.write(time + str(temperature) + \"\\n\")\n run_time += timedelta(minutes = 10)\n if keys[0] == \"jump\":\n temperature = step[\"jump\"]\n\n time = run_time.strftime(\"%H:%M:%S, \")\n f.write(time + str(temperature) + \"\\n\")\n else:\n logger.error(\"Can't make sense of \" + str(step))","def compile_data():\r\n with open('sp500_tickers.pickle', 'rb') as file:\r\n tickers = pickle.load(file)\r\n metasp = pd.DataFrame()\r\n for count, ticker in enumerate(tickers):\r\n df = pd.read_csv('sp500_data\\{}.csv'.format(ticker))\r\n df.set_index('Date', inplace=True)\r\n df.rename(columns={'Adj Close': ticker}, inplace=True)\r\n df.drop(['Open', 'High', 'Low', 'Close', 'Volume'], 1, inplace=True)\r\n if metasp.empty:\r\n metasp = df\r\n else:\r\n metasp = metasp.join(df, how = 'outer')\r\n if count % 10 == 0:\r\n print(count)\r\n metasp.to_csv('sp500_meta.csv')","def generate_day_header():\n cf = config.Config()\n outstr = \"total_rotation,total_acceleration,total_distance,number_missing,\"\n outstr += \"oc1_time,oc2_time,oc3_time,oc4_time,oc5_time,oc6_time,oc7_time,\"\n outstr += \"oc8_time,oc9_time,oc10_time,oc11_time,oc12_time,oc13_time,\"\n outstr += \"oc14_time,oc15_time,oc16_time,oc17_time,oc18_time,oc19_time,\"\n outstr += \"oc20_time,oc21_time,oc22_time,oc23_time,oc24_time,oc25_time,\"\n outstr += \"oc26_time,oc27_time,oc28_time,oc29_time,oc30_time,oc31_time,\"\n outstr += \"oc32_time,oc33_time,\"\n anames = cf.activity_list\n for i in range(len(anames)):\n outstr += anames[i] + \"_time,\"\n outstr += \"oc1_first,oc2_first,\"\n outstr += \"oc3_first,oc4_first,oc5_first,oc6_first,oc7_first,oc8_first,\"\n outstr += \"oc9_first,oc10_first,oc11_first,oc12_first,oc13_first,\"\n outstr += \"oc14_first,oc15_first,oc16_first,oc17_first,oc18_first,\"\n outstr += \"oc19_first,oc20_first,oc21_first,oc22_first,oc23_first,\"\n outstr += \"oc24_first,oc25_first,oc26_first,oc27_first,oc28_first,\"\n outstr += \"oc29_first,oc30_first,oc31_first,oc32_first,oc33_first,\"\n for i in range(len(anames)):\n outstr += anames[i] + \"_first,\"\n outstr += \"attraction_time,house_time,restaurant_time,\"\n outstr += \"road_time,service_time,store_time,work_time,other_time,\"\n outstr += \"attraction_first,house_first,restaurant_first,road_first,\"\n outstr += \"service_first,store_first,work_first,other_first\"\n return outstr","def create_csv_runtime(analysis, paths, csv_parameters):\n\n run_times = analysis.get_runtimes(paths)\n runs = max(run_times.keys()) + 1\n\n output_csv_runtime = csv_parameters\n runtimes = ['Runtimes']\n for run in range(runs):\n runtimes.append(run_times[run])\n output_csv_runtime.append(runtimes)\n\n return output_csv_runtime","def outputFunc(filename, parks,roading,private):\n #assert len(parks) == 3\n \n f = open(filename, 'wt')\n \n try:\n writer = csv.writer(f)\n writer.writerow(days)\n writer.writerow(parks)\n writer.writerow(roading)\n writer.writerow(private)\n finally:\n f.close()","def run():\n\twrite_fuel_data()","def csv(self):\n return '{:.6f},{},{}'.format(self.sample_time, self.value, self.status)","def process_iteration_result(self, result, context):\n self.infile = os.path.join(context.output_directory, 'trace.txt')\n if os.path.isfile(self.infile):\n self.logger.debug('Running result_processor \"dvfs\"')\n self.outfile = os.path.join(settings.output_directory, 'dvfs.csv')\n self.flush_parse_initialize()\n self.calculate()\n self.percentage()\n self.generate_csv(context)\n self.logger.debug('Completed result_processor \"dvfs\"')\n else:\n self.logger.debug('trace.txt not found.')","def read_cospectrum(path,d):\r\n spec = []\r\n timeseries = []\r\n for i in range(len(d)):\r\n filename = path + d[i]\r\n\r\n with open(filename, \"r\") as f:\r\n reader = csv.reader(f,delimiter=',')\r\n ct=1\r\n for row in reader:\r\n if ct==6:\r\n Hz = float(row[0].split('_')[-1])\r\n elif ct==7:\r\n height = float(row[0].split('_')[-1])\r\n elif ct==8:\r\n ws = float(row[0].split('_')[-1])\r\n elif ct==9:\r\n avg_period = float(row[0].split('_')[-1])\r\n elif ct==13:\r\n header = row\r\n elif ct>13:\r\n break\r\n ct+=1\r\n \r\n meta = [Hz,height,ws,avg_period]\r\n \r\n thisspec = np.genfromtxt(filename,delimiter=',',skip_header=13)\r\n spec.append(thisspec)\r\n thistime = re.findall('\\d{8}-\\d{4}',filename)[0]\r\n thisdate = datetime.strptime(thistime,'%Y%m%d-%H%M')\r\n timeseries.append(thisdate) \r\n \r\n return spec, timeseries, header, meta","def _output_performance(self):\n self.portfolio.create_equity_curve_dataframe()\n \n print(\"Creating summary statistics...\")\n stats = self.portfolio.output_summary_stats()\n \n print(\"Creating equity curve...\")\n print(self.portfolio.equity_curve.tail(10))\n pprint.pprint(stats)\n \n print(\"Signals: %s\" % self.signals)\n print(\"Orders: %s\" % self.orders)\n print(\"Fills: %s\" % self.fills)","def create_csv(self):\n try:\n # Convert List of Lists to DataFrame and write it to a CSV\n pd.DataFrame(self.data, columns=self.header) \\\n .to_csv(os.path.join(self.file_path, self.file_name), index=False)\n self.successful_run = True\n except:\n # TODO create Exception Handling\n raise","def output_daily_files(dataframe, path, filename):\n\n days = dataframe.groupby('date_time_day')\n dataframe.groupby('date_time_day').size().reset_index(name='data points per day')\n\n for day in days.groups:\n print(day.date())\n output_path = path + filename + \"_\" + str(day.date()) + '.csv'\n print(\"Creating intermediate flagged data file: \", output_path)\n days.get_group(day).to_csv(output_path, index=False)","def generate(start_date, episodes, steps, output_file):\n header = ','.join(FIELDS) + '\\n'\n with open(output_file, 'w') as fd:\n fd.write(header)\n data_arrays = []\n first_dp = generate_data_point(start_date)\n data_arrays.append(first_dp)\n\n interval = int(1440/steps)\n cur_ts = increment_ts(start_date, interval)\n\n while step_diff(start_date, cur_ts, interval) < steps*episodes:\n dp_tmp = generate_data_point(cur_ts)\n data_arrays.append(dp_tmp)\n cur_ts = increment_ts(cur_ts, interval)\n\n for dp in data_arrays:\n row = ','.join(dp) + '\\n'\n fd.write(row)","def download_multimonth_csv(out_dir, year_start, month_start, year_end, month_end, station, product='water_level', datum='STND', time_zone='GMT'):\n\n # add trailing slash to directory name, if necessary\n if out_dir[-1] is not ('/' or '\\\\'):\n out_dir = out_dir+'/'\n\n # create directory if necessary\n if not os.path.isdir(out_dir):\n os.mkdir(out_dir)\n\n file_prefix = station+'_'+product+'_'\n\n years = range(int(year_start),int(year_end)+1)\n\n for year in years:\n if year == years[0]:\n mon_range = range(month_start,13)\n elif year == years[-1]:\n mon_range = range(1,month_end+1)\n else:\n mon_range = range(1,13)\n\n for mon in mon_range:\n mon_str = str(mon).zfill(2)\n\n # file to write\n filename = file_prefix+str(year)+mon_str+'.csv'\n out_file = os.path.join(out_dir,filename)\n\n # determine number of days in month\n ndays = monthrange(year, mon)[1]\n ndays_str = str(ndays).zfill(2)\n\n begin_date = str(year)+mon_str+'01'\n end_date = str(year)+mon_str+ndays_str\n\n download_6min_csv(out_file, begin_date, end_date, station, product, datum, time_zone)","def create_csvfile(options_path, recept_info,df):\n df_csv = df.copy()\n df_csv.index.names = ['Interacting positions']\n\n #Change dynX by full name of receptor, adding the dynid if there is more than a simulation for that receptor\n df_csv.columns = df_csv.columns.map(lambda x: recept_info[x][13])\n\n #Sorting by ballesteros Id's (helixloop column) and clustering order\n df_csv['Interacting positions'] = df_csv.index\n df_csv['helixloop'] = df_csv['Interacting positions'].apply(lambda x: re.sub(r'^(\\d)x',r'\\g<1>0x',x)) \n df_csv = df_csv.sort_values([\"helixloop\"])\n\n #Change jumplines by 'x' to avoid formatting problems\n def new_index(cell):\n cell = cell.replace('\\n\\n', ' ')\n cell = cell.replace('\\n', 'x')\n cell = cell.replace('xx', 'x')\n return cell\n\n df_csv['Interacting positions'] = df_csv['Interacting positions'].apply(lambda x: new_index(x))\n df_csv.index = df_csv['Interacting positions']\n\n #Drop columns\n df_csv.drop(columns = ['helixloop','Interacting positions'], inplace = True)\n\n #Store dataframe as csv\n df_csv.to_csv(path_or_buf = options_path+\"dataframe.csv\", float_format='%.1f')","def serdes_dump_state(fpgaid,verbose=1):\n lines=[]\n\n lines.append(\"Group : AEQ\")\n lines.append(\" Logic Channel : %d\" % reconfig_AEQ_get_logical_channel_address(fpgaid,verbose))\n lines.append(\" adapt_done : %d\" % reconfig_AEQ_get_adapt_done(fpgaid,verbose))\n lines.append(\" equalization_results : %d\" % reconfig_AEQ_get_equalization_results(fpgaid,verbose))\n lines.append(\" mode : %d\" % reconfig_AEQ_get_mode(fpgaid,verbose))\n lines.append(\"Group : DFE\")\n lines.append(\" Logic Channel : %d\" % reconfig_DFE_get_logical_channel_address(fpgaid,verbose))\n lines.append(\" adaptation_engine_enable : %d\" % reconfig_DFE_get_adaptation_engine_enable(fpgaid,verbose))\n lines.append(\" power_on : %d\" % reconfig_DFE_get_power_on(fpgaid,verbose))\n lines.append(\" tap_1 : %d\" % reconfig_DFE_get_tap_1(fpgaid,verbose))\n lines.append(\" tap_2 : %d\" % reconfig_DFE_get_tap_2(fpgaid,verbose))\n lines.append(\" tap_2_polarity : %d\" % reconfig_DFE_get_tap_2_polarity(fpgaid,verbose))\n lines.append(\" tap_3 : %d\" % reconfig_DFE_get_tap_3(fpgaid,verbose))\n lines.append(\" tap_3_polarity : %d\" % reconfig_DFE_get_tap_3_polarity(fpgaid,verbose))\n lines.append(\" tap_4 : %d\" % reconfig_DFE_get_tap_4(fpgaid,verbose))\n lines.append(\" tap_4_polarity : %d\" % reconfig_DFE_get_tap_4_polarity(fpgaid,verbose))\n lines.append(\" tap_5 : %d\" % reconfig_DFE_get_tap_5(fpgaid,verbose))\n lines.append(\" tap_5_polarity : %d\" % reconfig_DFE_get_tap_5_polarity(fpgaid,verbose))\n lines.append(\"Group : EyeQ\")\n lines.append(\" Logic Channel : %d\" % reconfig_EyeQ_get_logical_channel_address(fpgaid,verbose))\n lines.append(\" 1D_Eye : %d\" % reconfig_EyeQ_get_1D_Eye(fpgaid,verbose))\n lines.append(\" BERB_Enable : %d\" % reconfig_EyeQ_get_BERB_Enable(fpgaid,verbose))\n lines.append(\" BERB_Snap_Shot_and_Reset : %d\" % reconfig_EyeQ_get_BERB_Snap_Shot_and_Reset(fpgaid,verbose))\n lines.append(\" Bit_Counter31_0 : %d\" % reconfig_EyeQ_get_Bit_Counter31_0(fpgaid,verbose))\n lines.append(\" Bit_Counter63_32 : %d\" % reconfig_EyeQ_get_Bit_Counter63_32(fpgaid,verbose))\n lines.append(\" Counter_Enable : %d\" % reconfig_EyeQ_get_Counter_Enable(fpgaid,verbose))\n lines.append(\" Enable_Eye_Monitor : %d\" % reconfig_EyeQ_get_Enable_Eye_Monitor(fpgaid,verbose))\n lines.append(\" Err_Conter63_32 : %d\" % reconfig_EyeQ_get_Err_Conter63_32(fpgaid,verbose))\n lines.append(\" Err_Counter31_0 : %d\" % reconfig_EyeQ_get_Err_Counter31_0(fpgaid,verbose))\n lines.append(\" Horizontal_phase : %d\" % reconfig_EyeQ_get_Horizontal_phase(fpgaid,verbose))\n lines.append(\" Polarity : %d\" % reconfig_EyeQ_get_Polarity(fpgaid,verbose))\n lines.append(\" Vertical_height : %d\" % reconfig_EyeQ_get_Vertical_height(fpgaid,verbose))\n lines.append(\"Group : PMA\")\n lines.append(\" Logic Channel : %d\" % reconfig_PMA_get_logical_channel_address(fpgaid,verbose))\n lines.append(\" Pre_emphasis_first_post_tap : %d\" % reconfig_PMA_get_Pre_emphasis_first_post_tap(fpgaid,verbose))\n lines.append(\" Pre_emphasis_pre_tap : %d\" % tapformat(reconfig_PMA_get_Pre_emphasis_pre_tap(fpgaid,verbose)))\n lines.append(\" Pre_emphasis_second_post_tap : %d\" % tapformat(reconfig_PMA_get_Pre_emphasis_second_post_tap(fpgaid,verbose)))\n lines.append(\" RX_equalization_control : %d\" % reconfig_PMA_get_RX_equalization_control(fpgaid,verbose))\n lines.append(\" RX_equalization_DC_gain : %d\" % reconfig_PMA_get_RX_equalization_DC_gain(fpgaid,verbose))\n lines.append(\" VOD : %d\" % reconfig_PMA_get_VOD(fpgaid,verbose))\n print \"\\n\".join(lines)\n return lines","def write_fenth_out4fp(fname,dH,vol):\n with open(fname,'w') as f:\n cmd = ' '.join(s for s in sys.argv)\n f.write('# Output at {0:s} from,\\n'.format(datetime.now().strftime('%Y-%m-%d %H:%M:%S')))\n f.write('# {0:s}\\n'.format(cmd))\n #...Num of data, weight for the data\n f.write(' {0:6d} {1:7.3f}\\n'.format(2, 1.0))\n f.write(' {0:8.3f} {1:8.3f}\\n'.format(dH,vol))\n return None","def get_meter_list():\n f = sorted(os.listdir(OUT_METER))[-1]\n df = pd.read_csv(os.path.join(OUT_METER, f))\n return df","def write_output_csv(filename, **kwargs):\n import csv\n import time\n\n intermediate = kwargs.pop(\"intermediate\", False)\n\n keys = sorted(kwargs.keys())\n num_vars = len(keys)\n\n if intermediate:\n full_filename = filename + \"_interm\"\n else:\n dot_index = filename.rfind('.')\n if dot_index != -1:\n full_filename = (filename[:dot_index]\n + time.strftime(\"%Y-%m-%d-%H.%M.%S\")\n + filename[dot_index:])\n else:\n full_filename = filename + time.strftime(\"%Y-%m-%d-%H.%M.%S\")\n\n # add current time to filename as an identifier\n with open(full_filename, 'w', newline='') as csvfile:\n\n writer = csv.writer(csvfile)\n\n # write header\n writer.writerow(keys)\n\n num_entries = len(kwargs[keys[0]])\n for i in range(num_entries):\n writer.writerow(kwargs[keys[j]][i] for j in range(num_vars))","def csv(self):\n return '{:.6f},{:.6f},{},{}'.format(\n self.sample_time, self.value_time, self.value, self.status)","def gen_final_df(res_fname, dat_sel, dname):\n res_file = open(res_fname, \"r\")\n rdict = {}\n pdict = {}\n for p in res_file:\n i, c, g, rate = p.split(\",\")\n rdict[i] = rate\n pdict[i] = [c, g]\n res_file.close()\n\n opti_feat = min([key for key in rdict.keys() if rdict[key] == max(rdict.values())])\n opti_c, opti_g = pdict[opti_feat][0], pdict[opti_feat][1]\n opti_df = df_transformer(dat_sel, opti_feat)\n opti_df = opti_df.replace(to_replace=-1, value=2)\n opti_df.to_csv(dname+\".res\", sep=\" \", header=None, index=None)\n return dname+\".res\", opti_c, opti_g","def _read_trajectory_files(self):\n dflist = []\n self.Ntimes = {}\n for downD in self.case.downstreamD:\n outputs = self.case.get_outputs(self.method,downD)\n print(outputs['trajectory_file'])\n df = pd.read_csv(outputs['trajectory_file'],\n header=None,\n usecols=[0,1,2])\n df.columns = ['t','y','z']\n df['x'] = downD * self.case.turbine.D\n df['z'] -= self.case.turbine.zhub\n df = df.set_index(['t','x'])[['y','z']]\n self.Ntimes[downD] = len(df.index.levels[0])\n dflist.append(df)\n self.df = pd.concat(dflist).sort_index()","def dump_lots(args: argparse.Namespace) -> None:\n engine = create_engine()\n dump_csv(\n engine,\n dtstart=args.dtstart,\n dtend=args.dtend,\n dtstart_gains=datetime.max,\n consolidate=args.consolidate,\n lotloadfile=args.loadcsv,\n lotdumpfile=args.file,\n )","def write_stats(self):\n with open(self.log_file,'a') as output:\n writer = csv.writer(output)\n n_comps,comp_size = self.connected_component() # Calculate number of connected components (sub-colonies)\n writer.writerow([self.pop_size,\n self.get_average_age(),\n self.get_average_survival(),\n # Nearest neighbor logging disabled for speed\n # Use c++ tool to calculate nearest neighbors after runs\n # or uncomment line below to calculate in python (slower)\n # self.get_average_repro()] + [self.get_average_neighbors(r) for r in range(0,16)] +\n self.get_average_repro()] +\n [n_comps,\",\".join(map(str,comp_size))])","def create_main_csv(data_list):\n path = \"camelot/clean/CWC_National-Register-of-Large-Dams_2019.csv\"\n if not os.path.exists(\"camelot/clean\"):\n os.makedirs(\"camelot/clean\")\n data_concat = pd.concat(data_list)\n data_concat.reset_index(drop=True).to_csv(path, index=True)","def gatherStationData():\n flist = list_files()\n station_dics = {}\n print(\"Reading in csv data...\")\n for f_in in flist:\n start,end = find_timespan(f_in)\n station = station_name(f=f_in)\n print(\"File: {0} Station: {1} {2}--{3}\".format(f_in, \n station, start, end))\n station_dics[station] = read_precip(fname=f_in, \n label=station, start_year=start, end_year=end)\n data_list = []\n for s in station_dics:\n data_list.append(station_dics[s]) \n return pd.concat(data_list,axis=1)","def output_wait_time_cdf(self):\r\n results_dirname = get_param(\"results_dir\")\r\n job_filename = os.path.join(results_dirname, \"%s_job_wait_cdf\" %\r\n get_param(\"file_prefix\"))\r\n job_file = open(job_filename, \"w\")\r\n task_filename = os.path.join(results_dirname, \"%s_task_wait_cdf\" %\r\n get_param(\"file_prefix\"))\r\n task_file = open(task_filename, \"w\")\r\n \r\n # Dictionary mapping loads (as returned by probes) to a list of wait\r\n # times for the corresponding tasks.\r\n wait_times_per_load = {}\r\n # Wait times for the last task in each job.\r\n longest_wait_times_per_load = {}\r\n for job in self.completed_jobs:\r\n longest_task_wait = -1\r\n longest_task_load = -1\r\n for task_id in range(job.num_tasks):\r\n load = job.probe_results[task_id]\r\n wait = job.wait_times[task_id]\r\n if wait > longest_task_wait:\r\n longest_task_wait = wait\r\n longest_task_load = load\r\n if load not in wait_times_per_load:\r\n wait_times_per_load[load] = []\r\n wait_times_per_load[load].append(wait)\r\n if longest_task_load not in longest_wait_times_per_load:\r\n longest_wait_times_per_load[longest_task_load] = []\r\n longest_wait_times_per_load[longest_task_load].append(\r\n longest_task_wait)\r\n \r\n task_file.write(\"Percentile\\t\")\r\n job_file.write(\"Percentile\\t\")\r\n for load in sorted(wait_times_per_load.keys()):\r\n wait_times_per_load[load].sort()\r\n task_file.write(\"%f(%d)\\t\" %\r\n (load, len(wait_times_per_load[load])))\r\n task_file.write(\"\\n\")\r\n for load in sorted(longest_wait_times_per_load.keys()):\r\n longest_wait_times_per_load[load].sort()\r\n job_file.write(\"%f(%d)\\t\" %\r\n (load, len(longest_wait_times_per_load[load])))\r\n job_file.write(\"\\n\")\r\n\r\n percentile_granularity = 200\r\n for i in range(percentile_granularity):\r\n percentile = float(i) / percentile_granularity\r\n job_file.write(\"%f\" % percentile)\r\n task_file.write(\"%f\" % percentile)\r\n for load in sorted(longest_wait_times_per_load.keys()):\r\n job_file.write(\"\\t%f\" % self.percentile(\r\n longest_wait_times_per_load[load], percentile))\r\n job_file.write(\"\\n\")\r\n for load in sorted(wait_times_per_load.keys()):\r\n task_file.write(\"\\t%f\" %\r\n self.percentile(wait_times_per_load[load],\r\n percentile))\r\n task_file.write(\"\\n\")\r\n job_file.close()","def process(self, inputs):\n df = cudf.read_csv(self.conf['path'])\n # extract the year, month, day\n ymd = df['DTE'].astype('str').str.extract(r'(\\d\\d\\d\\d)(\\d\\d)(\\d\\d)')\n # construct the standard datetime str\n df['DTE'] = ymd[0].str.cat(ymd[1],\n '-').str.cat(ymd[2],\n '-').astype('datetime64[ms]')\n df = df[['DTE', 'OPEN', 'CLOSE', 'HIGH', 'LOW', 'SM_ID', 'VOLUME']]\n df['VOLUME'] /= 1000\n # change the names\n df.columns = ['datetime', 'open', 'close',\n 'high', 'low', \"asset\", 'volume']\n return df","def print(self):\n print(\"-----\", self.name, \"-----\")\n print(\"Enable index\", self.enable_index)\n print(\"End index:\", self.stop_index)\n print(\"Measurement length (from the very beginning to the end index):\", self.time_vec[self.stop_index])\n print()\n print(\"Start temperature (hot):\", self.temp_hot_start)\n print(\"Start temperature (cold):\", self.temp_cold_start)\n print(\"Start temperature (mean):\", self.temp_start)\n print(\"End temperature (hot):\", self.temp_hot[self.stop_index])\n print(\"End temperature (cold)\", self.temp_cold[self.stop_index])\n print()\n print(\"Max temperature\", self.temp_max)\n print(\"Min temperature\", self.temp_min)\n print()\n print(\"Heat pump\")\n print(\"Energy input:\", self.work_inp)\n print(\"Q_hot\", self.qhot_pump)\n print(\"Q_cold\", self.qcold_pump)\n print(\"Q_cold + W\", self.qcold_pump + self.work_inp)\n print(\"E_lost\", self.qcold_pump + self.work_inp - self.qhot_pump)\n print(\"Coefficient of performance COP_hot\", self.qhot_pump / self.work_inp)\n print(\"Coefficient of performance COP_cold\", self.qcold_pump / self.work_inp)\n print(\"Ideal COP_hot with the setup\", self.qhot_pump/(self.qhot_pump-self.qcold_pump))\n print(\"Ideal COP_cold with the setup\", self.qcold_pump / (self.qhot_pump - self.qcold_pump))\n print(\"Ideal Carnot COP_hot\", (self.temp_max+273.15)/(self.temp_max-self.temp_min))\n print(\"Ideal Carnot COP_cold\", (self.temp_min+273.15)/(self.temp_max-self.temp_min))\n print(\"Efficiency fraction out of ideal Carnot cooler\", (self.qcold_pump / self.work_inp)/((self.temp_min+273.15)/(self.temp_max-self.temp_min)))\n\n if self.not_air:\n print(\"Heat transfer through insulator, hot side\", self.heat_loss_pump_hot)\n print(\"Heat transfer through insulator, cold side\", self.heat_loss_pump_cold)\n print(\"Estimated Q_hot with resistor\", self.qhot_resistor)\n else:\n print(\"Estimated Q_hot with resistor (=energy input)\", self.qhot_resistor)\n #\n # I think it should be defined for Q_hot too. Yep, TODO that\n # Also calculate heatloss due to conduction TODO remove these comments when ready\n # Todo implement resistive heater calculations\n print()\n print(\"Heat engine\")\n print(\"Energy generated:\", self.work_gen)\n print(\"Q_hot\", self.qhot_engine)\n print(\"Q_cold\", self.qcold_engine)\n print(\"Q_hot - Q_cold\", self.qhot_engine - self.qcold_engine)\n print(\"E_lost\", -self.qcold_engine - self.work_gen + self.qhot_engine)\n print(\"\\\"Heat transfer efficiency\\\" (%)\", self.work_gen / (self.qhot_engine - self.qcold_engine) * 100)\n print(\"Efficiency e\", self.work_gen / self.qhot_engine)\n print(\"Ideal efficiency with the setup\", 1 - (self.qcold_engine / self.qhot_engine))\n print(\"Ideal Carnot efficiency\", (self.temp_max-self.temp_min)/(self.temp_max+273.15))\n if self.not_air:\n print(\"Heat transfer through insulator, hot side\", self.heat_loss_gen_hot)\n print(\"Heat transfer through insulator, cold side\", self.heat_loss_gen_cold)\n print()\n print(\"Total efficiency of cycle\", self.work_gen/self.work_inp)\n # About the efficiency of peltier elements (#telok@IRCnet, 2016-07-27)\n # 19:10 < AgenttiX> Oletteko kokeilleet TECin ohjaamista Arduinolla? Toimisiko tämä kytkentä? http://garagelab.com/profiles/blogs/how-to-use-a-peltier-with-arduino\n # --\n # 20:21 <@hrst> Ei toimi. Peltieriä ei voi ohjata PWM:llä.\n # 20:22 <@hrst> Hyötysuhde on PWM:llä paska, mikä on ongelma koska se on muutenkin liian paska, ja sen lisäksi se hajoaa mekaaniseen värähtelyyn ennemmin tai myöhemmin.\n print(\"-----\\n\")","def __init__(self):\n super().__init__()\n self.dmdParams = {} # dmd settings container\n self.printTag = 'DMD' # print tag\n self._dynamicHandling = True # This ROM is able to manage the time-series on its own. No need for special treatment outside\n self.pivotParameterID = None # pivot parameter\n # variables filled up in the training stages\n self._amplitudes = {} # {'target1': vector of amplitudes,'target2':vector of amplitudes, etc.}\n self._eigs = {} # {'target1': vector of eigenvalues,'target2':vector of eigenvalues, etc.}\n self._modes = {} # {'target1': matrix of dynamic modes,'target2':matrix of dynamic modes, etc.}\n self.__Atilde = {} # {'target1': matrix of lowrank operator from the SVD,'target2':matrix of lowrank operator from the SVD, etc.}\n self.pivotValues = None # pivot values (e.g. time)\n self.KDTreeFinder = None # kdtree weighting model\n self.timeScales = {} # time-scales (training and dmd). {'training' and 'dmd':{t0:float,'dt':float,'intervals':int}}\n self.featureVals = None # feature values","def file_output(output_directory, distance, relative_dose, scan_curvetype, scan_depth):\n # Determines the filepaths for the output\n filepaths = determine_output_filepaths(output_directory, scan_curvetype, scan_depth)\n\n columns = [\"distance (mm)\", \"relative dose\"]\n\n # Loop over each curvetype and save the data to csv\n for i, _ in enumerate(scan_curvetype):\n # Stacks the data into one array and transposes into column orientation\n data = np.vstack([distance[i], relative_dose[i]]).T\n\n # Use pandas to save data to csv\n df = pd.DataFrame(data, columns=columns)\n df.to_csv(filepaths[i])","def execute(self, args: Namespace):\n data = {}\n\n with open(args.data, 'r') as file:\n reader = csv.reader(file, delimiter=';')\n\n for row in reader:\n if reader.line_num == 1:\n if 'Timestamp, Decimal, TriState, State' != ','.join(row):\n print('Not a valid CSV file!')\n return\n\n else:\n dt = datetime.strptime(row[0], '%Y-%m-%d %H:%M:%S.%f')\n value = tri_state_value(row[2])\n device = data.setdefault(tri_state_device(row[2].strip()), {})\n device.setdefault(dt.date(),[]).append((dt.strftime('%H:%M'), value))\n\n for k in sorted(data.keys()):\n device = data[k]\n print('Device {}:'.format(tint_yellow(k)))\n\n for d in sorted(device.keys()):\n device[d].sort(key=lambda x: x[0])\n print('\\t{}:'.format(tint_blue(d)))\n\n for (t, v) in device[d]:\n if v:\n print('\\t\\tAt {} the device was turned {}.'.format(tint_blue(t),\n tint_green('ON')))\n else:\n print('\\t\\tAt {} the device was turned {}.'.format(tint_blue(t),\n tint_red('OFF')))","def generate_device_tree(self, outdir: str) -> None:\n\n state = FdtState(addr_cells=2, size_cells=2, cpu_cells=1)\n root = FdtNode(\"/\")\n root.append(state.addrCellsProperty())\n root.append(state.sizeCellsProperty())\n root.appendCompatible([\"riscv-virtio\"])\n\n for mem_range in self.mem_ranges:\n node = FdtNode(f\"memory@{int(mem_range.start):x}\")\n node.append(FdtPropertyStrings(\"device_type\", [\"memory\"]))\n node.append(\n FdtPropertyWords(\n \"reg\",\n state.addrCells(mem_range.start)\n + state.sizeCells(mem_range.size()),\n )\n )\n root.append(node)\n\n # See Documentation/devicetree/bindings/riscv/cpus.txt for details.\n cpus_node = FdtNode(\"cpus\")\n cpus_state = FdtState(addr_cells=1, size_cells=0)\n cpus_node.append(cpus_state.addrCellsProperty())\n cpus_node.append(cpus_state.sizeCellsProperty())\n # Used by the CLINT driver to set the timer frequency. Value taken from\n # RISC-V kernel docs (Note: freedom-u540 is actually 1MHz)\n cpus_node.append(FdtPropertyWords(\"timebase-frequency\", [100000000]))\n\n for i, core in enumerate(self.get_processor().get_cores()):\n node = FdtNode(f\"cpu@{i}\")\n node.append(FdtPropertyStrings(\"device_type\", \"cpu\"))\n node.append(FdtPropertyWords(\"reg\", state.CPUAddrCells(i)))\n node.append(FdtPropertyStrings(\"mmu-type\", \"riscv,sv48\"))\n node.append(FdtPropertyStrings(\"status\", \"okay\"))\n node.append(FdtPropertyStrings(\"riscv,isa\", \"rv64imafdc\"))\n # TODO: Should probably get this from the core.\n freq = self.clk_domain.clock[0].frequency\n node.append(FdtPropertyWords(\"clock-frequency\", freq))\n node.appendCompatible([\"riscv\"])\n int_phandle = state.phandle(f\"cpu@{i}.int_state\")\n node.appendPhandle(f\"cpu@{i}\")\n\n int_node = FdtNode(\"interrupt-controller\")\n int_state = FdtState(interrupt_cells=1)\n int_phandle = int_state.phandle(f\"cpu@{i}.int_state\")\n int_node.append(int_state.interruptCellsProperty())\n int_node.append(FdtProperty(\"interrupt-controller\"))\n int_node.appendCompatible(\"riscv,cpu-intc\")\n int_node.append(FdtPropertyWords(\"phandle\", [int_phandle]))\n\n node.append(int_node)\n cpus_node.append(node)\n\n root.append(cpus_node)\n\n soc_node = FdtNode(\"soc\")\n soc_state = FdtState(addr_cells=2, size_cells=2)\n soc_node.append(soc_state.addrCellsProperty())\n soc_node.append(soc_state.sizeCellsProperty())\n soc_node.append(FdtProperty(\"ranges\"))\n soc_node.appendCompatible([\"simple-bus\"])\n\n # CLINT node\n clint = self.platform.clint\n clint_node = clint.generateBasicPioDeviceNode(\n soc_state, \"clint\", clint.pio_addr, clint.pio_size\n )\n int_extended = list()\n for i, core in enumerate(self.get_processor().get_cores()):\n phandle = soc_state.phandle(f\"cpu@{i}.int_state\")\n int_extended.append(phandle)\n int_extended.append(0x3)\n int_extended.append(phandle)\n int_extended.append(0x7)\n clint_node.append(\n FdtPropertyWords(\"interrupts-extended\", int_extended)\n )\n clint_node.appendCompatible([\"riscv,clint0\"])\n soc_node.append(clint_node)\n\n # PLIC node\n plic = self.platform.plic\n plic_node = plic.generateBasicPioDeviceNode(\n soc_state, \"plic\", plic.pio_addr, plic.pio_size\n )\n\n int_state = FdtState(addr_cells=0, interrupt_cells=1)\n plic_node.append(int_state.addrCellsProperty())\n plic_node.append(int_state.interruptCellsProperty())\n\n phandle = int_state.phandle(plic)\n plic_node.append(FdtPropertyWords(\"phandle\", [phandle]))\n plic_node.append(FdtPropertyWords(\"riscv,ndev\", [plic.n_src - 1]))\n\n int_extended = list()\n for i, core in enumerate(self.get_processor().get_cores()):\n phandle = state.phandle(f\"cpu@{i}.int_state\")\n int_extended.append(phandle)\n int_extended.append(0xB)\n int_extended.append(phandle)\n int_extended.append(0x9)\n\n plic_node.append(FdtPropertyWords(\"interrupts-extended\", int_extended))\n plic_node.append(FdtProperty(\"interrupt-controller\"))\n plic_node.appendCompatible([\"riscv,plic0\"])\n\n soc_node.append(plic_node)\n\n # PCI\n pci_state = FdtState(\n addr_cells=3, size_cells=2, cpu_cells=1, interrupt_cells=1\n )\n pci_node = FdtNode(\"pci\")\n\n if int(self.platform.pci_host.conf_device_bits) == 8:\n pci_node.appendCompatible(\"pci-host-cam-generic\")\n elif int(self.platform.pci_host.conf_device_bits) == 12:\n pci_node.appendCompatible(\"pci-host-ecam-generic\")\n else:\n m5.fatal(\"No compatibility string for the set conf_device_width\")\n\n pci_node.append(FdtPropertyStrings(\"device_type\", [\"pci\"]))\n\n # Cell sizes of child nodes/peripherals\n pci_node.append(pci_state.addrCellsProperty())\n pci_node.append(pci_state.sizeCellsProperty())\n pci_node.append(pci_state.interruptCellsProperty())\n # PCI address for CPU\n pci_node.append(\n FdtPropertyWords(\n \"reg\",\n soc_state.addrCells(self.platform.pci_host.conf_base)\n + soc_state.sizeCells(self.platform.pci_host.conf_size),\n )\n )\n\n # Ranges mapping\n # For now some of this is hard coded, because the PCI module does not\n # have a proper full understanding of the memory map, but adapting the\n # PCI module is beyond the scope of what I'm trying to do here.\n # Values are taken from the ARM VExpress_GEM5_V1 platform.\n ranges = []\n # Pio address range\n ranges += self.platform.pci_host.pciFdtAddr(space=1, addr=0)\n ranges += soc_state.addrCells(self.platform.pci_host.pci_pio_base)\n ranges += pci_state.sizeCells(0x10000) # Fixed size\n\n # AXI memory address range\n ranges += self.platform.pci_host.pciFdtAddr(space=2, addr=0)\n ranges += soc_state.addrCells(self.platform.pci_host.pci_mem_base)\n ranges += pci_state.sizeCells(0x40000000) # Fixed size\n pci_node.append(FdtPropertyWords(\"ranges\", ranges))\n\n # Interrupt mapping\n plic_handle = int_state.phandle(plic)\n int_base = self.platform.pci_host.int_base\n\n interrupts = []\n\n for i in range(int(self.platform.pci_host.int_count)):\n interrupts += self.platform.pci_host.pciFdtAddr(\n device=i, addr=0\n ) + [int(i) + 1, plic_handle, int(int_base) + i]\n\n pci_node.append(FdtPropertyWords(\"interrupt-map\", interrupts))\n\n int_count = int(self.platform.pci_host.int_count)\n if int_count & (int_count - 1):\n fatal(\"PCI interrupt count should be power of 2\")\n\n intmask = self.platform.pci_host.pciFdtAddr(\n device=int_count - 1, addr=0\n ) + [0x0]\n pci_node.append(FdtPropertyWords(\"interrupt-map-mask\", intmask))\n\n if self.platform.pci_host._dma_coherent:\n pci_node.append(FdtProperty(\"dma-coherent\"))\n\n soc_node.append(pci_node)\n\n # UART node\n uart = self.platform.uart\n uart_node = uart.generateBasicPioDeviceNode(\n soc_state, \"uart\", uart.pio_addr, uart.pio_size\n )\n uart_node.append(\n FdtPropertyWords(\"interrupts\", [self.platform.uart_int_id])\n )\n uart_node.append(FdtPropertyWords(\"clock-frequency\", [0x384000]))\n uart_node.append(\n FdtPropertyWords(\"interrupt-parent\", soc_state.phandle(plic))\n )\n uart_node.appendCompatible([\"ns8250\"])\n soc_node.append(uart_node)\n\n # VirtIO MMIO disk node\n disk = self.disk\n disk_node = disk.generateBasicPioDeviceNode(\n soc_state, \"virtio_mmio\", disk.pio_addr, disk.pio_size\n )\n disk_node.append(FdtPropertyWords(\"interrupts\", [disk.interrupt_id]))\n disk_node.append(\n FdtPropertyWords(\"interrupt-parent\", soc_state.phandle(plic))\n )\n disk_node.appendCompatible([\"virtio,mmio\"])\n soc_node.append(disk_node)\n\n # VirtIO MMIO rng node\n rng = self.rng\n rng_node = rng.generateBasicPioDeviceNode(\n soc_state, \"virtio_mmio\", rng.pio_addr, rng.pio_size\n )\n rng_node.append(FdtPropertyWords(\"interrupts\", [rng.interrupt_id]))\n rng_node.append(\n FdtPropertyWords(\"interrupt-parent\", soc_state.phandle(plic))\n )\n rng_node.appendCompatible([\"virtio,mmio\"])\n soc_node.append(rng_node)\n\n root.append(soc_node)\n\n fdt = Fdt()\n fdt.add_rootnode(root)\n fdt.writeDtsFile(os.path.join(outdir, \"device.dts\"))\n fdt.writeDtbFile(os.path.join(outdir, \"device.dtb\"))","def make_data(rics: list, fields: list, name: str) -> None:\n df = get_data(rics, fields)\n df.index.name = 'ID'\n to_csv(df, name)","def generate_timeseries(data_list, setname=\"MagneticFields\"):\n full_data = TimeSeriesList()\n for seg in sorted(data_list):\n hfile = h5py.File(data_list[seg], \"r\")\n full_data.append(retrieve_data_timeseries(hfile, \"MagneticFields\"))\n hfile.close()\n return full_data","def download_6min_csv(out_file, begin_date, end_date, station, product='water_level', datum='STND', time_zone='GMT'):\n\n # Note: 6 minutes is the default interval, see https://api.tidesandcurrents.noaa.gov/api/prod/\n\n base_url = 'https://api.tidesandcurrents.noaa.gov'\n if product == 'water_level':\n api_url = '/api/prod/datagetter'\\\n '?product='+product+\\\n '&application=NOS.COOPS.TAC.WL'\\\n '&begin_date='+begin_date+\\\n '&end_date='+end_date+\\\n '&station='+station+\\\n '&datum='+datum+\\\n '&time_zone='+time_zone+\\\n '&units=metric'\\\n '&format=csv'\n else:\n api_url = '/api/prod/datagetter'\\\n '?product='+product+\\\n '&application=NOS.COOPS.TAC.WL'\\\n '&begin_date='+begin_date+\\\n '&end_date='+end_date+\\\n '&station='+station+\\\n '&time_zone='+time_zone+\\\n '&units=metric'\\\n '&format=csv'\n\n url = base_url+api_url\n print(url)\n _retrieve_file(url,out_file)","def __init__(self,\n name: str = 'Process',\n time_horizon: int = 432000,\n lambda_: float = 0.1,\n beta: float = 0.2,\n epsilon: float = 0.2,\n mu: int = 4,\n stream_speed: int = 100,\n n_features: int = 2,\n gen_plot: bool = False,\n gen_metrics: bool = True):\n self.gen_plot = gen_plot\n self.gen_metrics = gen_metrics\n self.event_index = 0\n self.total_cases = set()\n self.check_point = datetime(2010, 1, 1)\n self.cases = []\n self.name = name\n self.time_horizon = time_horizon\n self.initialized = False\n self.cp_count = 0\n self.nyquist = 0\n self.check_point_cases = 0\n self.process_model_graph = nx.DiGraph()\n self.denstream = DenStream(lambda_, beta, epsilon, mu, stream_speed, n_features)\n self.cluster_metrics = []\n self.case_metrics = []\n self.active_core_clusters = set()\n self.drift_indexes = []\n self.metrics = Metrics(self.name)\n self.feature_space_plot_path = f'visualization/{self.name}_feature_space'\n makedirs(self.feature_space_plot_path, exist_ok=True)","def write_output(self) -> None:\n self.home.round(2).to_csv(var.indicators_base_cumsum + \"home_\" + str(self.year) + \".csv\")\n self.away.round(2).to_csv(var.indicators_base_cumsum + \"away_\" + str(self.year) + \".csv\")","def __init__(\n self,\n output_dir=None,\n output_fname='statistics.tsv',\n exp_name=None,\n log_freq=1,\n ):\n # Set up output file\n self.output_dir = output_dir or '/tmp/experiments/%i' % int(time.time())\n if not os.path.exists(self.output_dir):\n os.makedirs(self.output_dir)\n output_filepath = os.path.join(output_dir, output_fname)\n self.output_file = open(output_filepath, 'w')\n self.file_writer = csv.writer(self.output_file, delimiter='\\t')\n atexit.register(self.output_file.close)\n\n self.exp_name = exp_name\n self.log_freq = log_freq\n self.first_row = True\n self.log_headers = None\n self.counter = 0 # keeps track of how often log_stats is called","def generate(dir):\r\n metric_files = get_all_metrics(dir)\r\n dfs = []\r\n for m in metric_files:\r\n metric_name = m.replace('.csv', '').split('-')[-1]\r\n full_path = os.path.join(dir, m)\r\n dfs.append(read_metrics_as_df(full_path,'Value',metric_name).set_index('Step').drop(columns=['Wall time']))\r\n base_df = dfs[0]\r\n for df in dfs[1:]:\r\n base_df = base_df.join(df, on='Step')\r\n return base_df","def _gen_report(self):\n print \"------------------------------------------\"\n print \"fio report\"\n print \"------------------------------------------\"\n print \"name\", \" \".join(f for f in FIELDS)\n # print fields\n for name in sorted(self.reports):\n report = self.reports[name]\n #print report\n print name, \" \".join(str(report.get(f)) for f in FIELDS)\n\n print \"*******************************************\"\n # print clats\n index = 0\n for name in sorted(self.reports):\n report = self.reports[name]\n if index == 0:\n print \"clat_percent\", \" \".join(\n str(c[0]) for c in report[\"clats\"])\n print name, \" \".join(str(c[1]) for c in report[\"clats\"])\n index += 1","def make_nptabel_csv(obs_id, module, qa_dir, output_path=''):\n\n logger.info(\n \"Reading param information for {0} of {1}\".format(module, obs_id))\n summary_data = extract_all_beams(obs_id, module, qa_dir)\n logger.info(\n \"Reading param information for {0} of {1}... Done\".format(module, obs_id))\n\n i = 0\n if module == 'transfer':\n while len(summary_data[i]) <= 1:\n i += 1\n if len(summary_data[i]) > 1:\n break\n else:\n while len(summary_data[i]) <= 2:\n i += 1\n if len(summary_data[i]) > 2:\n break\n\n csv_columns = summary_data[i].keys()\n\n csv_columns.sort()\n dict_data = summary_data\n\n # save the file\n if output_path == '':\n csv_file = str(obs_id)+\"_\"+str(module)+\"_summary.csv\"\n else:\n csv_file = os.path.join(output_path, str(\n obs_id)+\"_\"+str(module)+\"_summary.csv\")\n\n try:\n with open(csv_file, 'w') as csvfile:\n writer = csv.DictWriter(csvfile, fieldnames=csv_columns)\n writer.writeheader()\n for data in dict_data:\n writer.writerow(data)\n except Exception as e:\n logger.warning(\"Creating file {} failed\".format(csv_file))\n logger.exception(e)\n\n # print(\"Created file: \"+str(obs_id)+\"_\"+str(module)+\"_summary.csv\")\n logger.info(\"Creating file: {} ... Done\".format(csv_file))","def fcvs(self):\n for name in self._fcvs:\n yield name, self._data[name]","def make_csv(file_of_data):\n with open(file_of_data, 'w') as f:\n writer = csv.writer(f)\n header = (\"Counter\", \"Date/time\", \"Latitude\", \"Longitude\", \"Temperature\", \"Humidity\")\n writer.writerow(header)","def main(files, target_depth, tol_diff, depth_fld, temperature_fld,\n salinity_fld):\n ymd_fmt = \"{0}-{1}-{2}\"\n # Note change of line terminator to make it compatible with AWK\n writer = csv.writer(sys.stdout, lineterminator='\\n')\n writer.writerow([\"time\", \"bottle_number\", \"depth\",\n \"temperature\", \"salinity\"])\n for bottle_f in files:\n with bottle_f:\n for lineno, line in enumerate(bottle_f, start=1):\n if re.search('^(\\*|#)', line):\n continue\n if re.search('^ *bottle', line.lower()):\n databeg = lineno + 2\n continue\n if (lineno - databeg) % 2 == 0:\n parsedl = line.split()\n mm = _french_month(parsedl[1])\n if mm:\n fmt = '%Y-%m-%d %H:%M:%S'\n yyyymmdd = ymd_fmt.format(parsedl[3], mm, parsedl[2])\n else:\n fmt = '%Y-%b-%d %H:%M:%S'\n yyyymmdd = ymd_fmt.format(parsedl[3], parsedl[1],\n parsedl[2])\n bottle_no = parsedl[0]\n depth = parsedl[depth_fld - 1]\n temperature = parsedl[temperature_fld - 1]\n salinity = parsedl[salinity_fld - 1]\n else:\n if lineno <= databeg:\n continue\n hhmmss = line.split()[0]\n ymd = datetime.strptime(\"{0} {1}\".format(yyyymmdd,\n hhmmss), fmt)\n depth_dev = abs(float(depth) - target_depth)\n if (depth_dev < tol_diff):\n line_out = (ymd.strftime('%Y-%m-%d %H:%M:%S'),\n bottle_no, depth, temperature,\n salinity)\n writer.writerow(line_out)","def save_as_csv(time_series, data, path_and_file_name):\n\n parent_name = \"test\"\n parent_uqid = uuid.uuid4()\n\n file_obj = open(path_and_file_name, 'w')\n file_obj.write('version,'+str(2)+'\\n')\n file_obj.write('numOfCH,'+str(1)+'\\n')\n file_obj.write('type, scan\\n')\n file_obj.write('ch_type,'+str(0)+'\\n')\n\n file_obj.write('carpet pos,'+str(0)+'\\n')\n file_obj.write('parent_name,'+str(parent_name)+'\\n')\n file_obj.write('parent_uqid,'+str(parent_uqid)+'\\n')\n file_obj.write('parent_filename,'+str(path_and_file_name)+'\\n')\n\n file_obj.write('pc, 0\\n')\n file_obj.write('Time (ns), CH0 Auto-Correlation\\n')\n for time_step in range(0, time_series.shape[0]):\n file_obj.write(str(float(time_series[time_step]))+','+str(data[time_step])+ '\\n')\n file_obj.write('end\\n')\n\n file_obj.close()","def to_csv(self):\n if not self._fitted:\n self.fit()\n #self._message(\"Saving results into a csv (comma separated values) file.\")\n v=np.array([list(self.initialConcentration.values()),\n list(self.fitting_error.values()),\n list(self.k.values()),\n list(self.Fb.values()),\n list(self.slope.values())]).T\n k=list(self.initialConcentration.keys())\n d=pd.DataFrame(v,columns=['Initial Concentration','Fitting Error','k','Fb','Slope'],index=k)\n fn=get_valid_fname(self.ID)\n self.csvname=\"%s_initial_concentrations.csv\"%(fn)\n self.fullcsvname=\"%s/%s_initial_concentrations.csv\"%(self.info['resultsdir'],fn)\n self.info['csvname_initialConcentration']=self.csvname\n print(self.csvname)\n d.to_csv('%s/%s'%(self.info['resultsdir'],self.csvname))","def readProcessedFCD():\n procFcdDict = {}\n pqDateDict = {} # each date is a period / quota tupel assigned\n simDate = '2007-07-18 '\n day = 0\n # create keys for the procFcdDict\n for p in period:\n for q in quota:\n day += 86400\n date, time = calcTime.getDateFromDepart(day).split(\" \")\n pqDateDict.setdefault(date, (p, q))\n procFcdDict.setdefault((p, q), {})\n # print date,p,q\n\n inputFile = open(path.FQprocessedFCD, 'r')\n for line in inputFile:\n timestamp, edge, speed, cover, id = line.split('\\t')\n date, time = calcTime.getNiceTimeLabel(timestamp).split(\" \")\n # add values to actual Dict\n timestep = calcTime.getTimeInSecs(simDate + time)\n procFcdDict[pqDateDict[date]].setdefault(\n timestep, []).append((id, edge, float(speed) / 3.6))\n inputFile.close()\n\n return procFcdDict","def write_crossing_times(temperature, crossing_times_collector, file_name):\n with open(\"./Results/\" + file_name + \"-T{:.4f}.csv\".format(temperature), 'w') as f:\n for crossing_times in crossing_times_collector:\n f.write(\"%s\\n\" % \", \".join([str(element) for element in crossing_times]))"],"string":"[\n \"def writeRawFCD():\\n global vehId, vehIdDict\\n vehIdDict = {}\\n vehId = 0\\n day = 0\\n\\n def getVehId(orgId):\\n \\\"\\\"\\\"creates new vehicle id's which consists only numerics\\\"\\\"\\\"\\n global vehId, vehIdDict\\n value = vehIdDict.get(orgId, vehId)\\n if value is vehId:\\n vehIdDict[orgId] = vehId\\n vehId = (vehId + 1) % 65500\\n return value\\n\\n outputFile = open(path.FQrawFCD, 'w')\\n\\n for period, quota, vtypeDictR, taxiSum in generatePeriodQuotaSets():\\n day += 86400\\n # reset dict so that every taxi (even if the vehicle is chosen several\\n # times) gets its own id\\n vehIdDict = {}\\n # dataset=0\\n sortedKeys = vtypeDictR.keys()\\n sortedKeys.sort()\\n for timestep in sortedKeys:\\n taxiList = vtypeDictR[timestep]\\n for tup in taxiList: # all elements in this timestep\\n # calc timestep ->for every period /quota set a new day\\n time = timestep + day\\n time = calcTime.getDateFromDepart(time)\\n # dataset+=1\\n # print ouptut\\n # veh_id date (time to simDate+time) x (remove and\\n # set comma new)\\n outputFile.write(str(getVehId(tup[0])) + '\\\\t' + time + '\\\\t' + tup[3][0:2] + '.' + tup[3][2:7] + tup[3][8:] +\\n # y (remove and set comma new)\\n # status speed form m/s in km/h\\n '\\\\t' + tup[4][0:2] + '.' + tup[4][2:7] + tup[4][8:] + '\\\\t' + \\\"90\\\" + '\\\\t' + str(int(round(tup[2] * 3.6))) + '\\\\n')\\n # print dataset, time\\n print(vehId)\\n outputFile.close()\",\n \"def run(self):\\n\\t\\tself._data_updater_thread.start()\\n\\t\\tf = open('output.csv', 'w') #TODO: handle output file correctly (cfg)\\n\\t\\tf.write('(datetime;valve;thin_temp;thin_pres;out_temp)\\\\n')\\n\\t\\tf.close()\",\n \"def _write_csv(self):\\n\\n # add the label to the header\\n if self.input_data.get_value(InputType.TIME_PERIOD) == 'all':\\n self.header.append('Date')\\n else:\\n self.header.append('sample id')\\n\\n key_list = []\\n\\n for i, cube in enumerate(self.cube_list):\\n if self.input_data.get_value(InputType.TIME_PERIOD) == 'all':\\n self._write_sample_with_date(cube, i, key_list)\\n else:\\n self._write_sample(cube, i, key_list)\\n\\n output_data_file_path = self._get_full_file_name()\\n self._write_data_dict(output_data_file_path, key_list)\\n\\n return [output_data_file_path]\",\n \"def write_current_voltage_csv(dir_name, file_name, all_data_raw, freqs_explicit, samples, periods, curr_range,\\n batt_volt, serial_n, start_time, log):\\n k = samples * periods\\n all_data = []\\n times = []\\n delimiter = ','\\n\\n for end_time, data_set in all_data_raw: #: Step 1\\n voltage = data_set[:k]\\n current = data_set[k:]\\n\\n times.append(end_time)\\n\\n all_data.append([\\\"%.7f\\\" % x for x in voltage])\\n all_data[-1] += [(\\\"%\\\" + \\\".%if\\\" % (6 - curr_range)) % x for x in current]\\n\\n final_name = file_name\\n suffix = 0\\n\\n while exists(join(dir_name, '%s.csv' % final_name)): #: Step 2\\n if suffix == 0:\\n final_name += '0'\\n\\n suffix += 1\\n final_name = re.sub(r'[0-9]*$', str(suffix), final_name)\\n\\n full_path = join(dir_name, '%s.csv' % final_name) #: Step 3\\n f = open(full_path, 'wb')\\n\\n n_freqs = len(freqs_explicit)\\n per_sweep_data_names = ['File Name', 'Device Serial Number', 'Start Date and Time', 'Number of Frequencies',\\n 'Current Resolution (Amps)', 'Battery OCV (Volts)']\\n current_voltage_data_str = []\\n\\n first_column_l = -float('inf')\\n\\n for data_name in per_sweep_data_names: #: Step 4\\n first_column_l = max(first_column_l, len(data_name))\\n\\n column_widths = [first_column_l]\\n\\n for freq_id in range(len(all_data)):\\n column_widths.append(10 if freq_id != 0 else 17)\\n column_widths.append(10)\\n\\n data_type_line = [(first_column_l, 'Data Type')] #: Step 5.a\\n\\n for freq_id in range(len(all_data)):\\n column_l = column_widths[(freq_id + 1) * 2]\\n data_type_line.append((max(column_l, 10 if freq_id != 0 else 17), 'V'))\\n data_type_line.append((max(column_l, 10), 'I'))\\n\\n frequencies = [(first_column_l, 'Frequency (Hz)')] #: Step 5.b\\n\\n for freq_id in range(len(all_data)):\\n column_l = column_widths[(freq_id + 1) * 2]\\n freq_explicit = \\\"%.2E\\\" % (Decimal(freqs_explicit[freq_id]) / 1000)\\n frequencies.append((max(column_l, 10 if freq_id != 0 else 17), freq_explicit))\\n frequencies.append((max(column_l, 10), freq_explicit))\\n\\n times_line = [(first_column_l, 'Time from start (s)')] #: Step 5.c\\n\\n for freq_id in range(len(all_data)):\\n if freq_id == 0:\\n time_diff = 0\\n else:\\n end_time = times[freq_id - 1]\\n column_l = column_widths[(freq_id + 1) * 2]\\n time_diff = (end_time - start_time).seconds\\n\\n times_line.append((max(column_l, 10 if freq_id != 0 else 17), str(time_diff)))\\n times_line.append((max(column_l, 10), str(time_diff)))\\n\\n samples_line = [(first_column_l, 'Samples per period')] #: Step 5.d\\n\\n for freq_id in range(len(all_data)):\\n column_l = column_widths[(freq_id + 1) * 2]\\n freq_bit = int(np.round(np.log2(float(freqs_explicit[freq_id]) / F_MIN))) & 23\\n freq_explicit = 2 ** (27 - freq_bit) if freq_bit >= 21 else 128\\n\\n samples_line.append((max(column_l, 10 if freq_id != 0 else 17), str(freq_explicit)))\\n samples_line.append((max(column_l, 10), str(freq_explicit)))\\n\\n second_column_l = column_widths[1]\\n\\n #: Step 5.e\\n per_sweep_data_vals = map(str, ['%s.csv' % file_name, serial_n, '%02i/%02i/%02i %02i:%02i:%02i' %\\n (start_time.month, start_time.day,\\n start_time.year - 2000, start_time.hour,\\n start_time.minute, start_time.second),\\n n_freqs, CURRENT_RANGE_VALS[curr_range], \\\"%.3f\\\" % batt_volt])\\n\\n per_sweep_data = [build_line([(first_column_l, per_sweep_data_names[i]),\\n (second_column_l, per_sweep_data_vals[i])], delimiter) for i in\\n range(len(per_sweep_data_names))]\\n\\n #: Step 5.f\\n for i in range(k):\\n line = [(first_column_l, str(i + 1))]\\n\\n for freq_id in range(len(all_data)):\\n column_l = column_widths[(freq_id + 1) * 2]\\n voltage = str(all_data[freq_id][i])\\n current = str(all_data[freq_id][i + k])\\n\\n line.append((max(column_l, 10 if freq_id != 0 else 17), voltage))\\n line.append((max(column_l, 10), current))\\n\\n current_voltage_data_str.append(build_line(line, delimiter))\\n\\n f.write(\\\"\\\\n\\\".join(per_sweep_data) + '\\\\n\\\\n') #: Step 6\\n f.write(build_line(data_type_line, delimiter) + '\\\\n')\\n f.write(build_line(frequencies, delimiter) + '\\\\n')\\n f.write(build_line(times_line, delimiter) + '\\\\n')\\n f.write(build_line(samples_line, delimiter) + '\\\\n')\\n f.write(\\\"\\\\n\\\".join(current_voltage_data_str))\\n f.close()\\n\\n log([(\\\"Successfully wrote file '%s.csv' to path %s.\\\" % (final_name, dir_name), 0)]) #: Step 7\",\n \"def _csvWriter(self):\\r\\n # Initialize Header\\r\\n table = []\\r\\n voltageRow = []\\r\\n for i in range(len(self._voltages)):\\r\\n voltageRow.append(self._voltages[i][0])\\r\\n voltageRow.append(\\\" \\\")\\r\\n if self._vna.isTwoComponents():\\r\\n voltageRow.append(\\\" \\\")\\r\\n table.append(voltageRow)\\r\\n \\r\\n # Fill table with data\\r\\n # if self._vna.isTwoComponents():\\r\\n # for i in range(len(self._frequency[0])):\\r\\n # row = []\\r\\n # for j in range(len(self._frequency)):\\r\\n # row.append(self._frequency[j][i])\\r\\n # row.append(self._intensity[j][2*i])\\r\\n # row.append(self._intensity[j][2*i + 1])\\r\\n # table.append(row)\\r\\n # else: \\r\\n for i in range(len(self._frequency[0])):\\r\\n row = []\\r\\n for j in range(len(self._frequency)):\\r\\n row.append(self._frequency[j][i])\\r\\n row.append(self._intensity[j][i])\\r\\n table.append(row)\\r\\n\\r\\n # Write to CSV\\r\\n filename = 'CSVs/' + self._vna.getDateFormatted() + '.csv'\\r\\n with open(filename, 'w', newline='') as csvfile:\\r\\n dataWriter = csv.writer(csvfile, delimiter=',', quoting=csv.QUOTE_MINIMAL)\\r\\n for i in range(len(table)):\\r\\n dataWriter.writerow(table[i])\",\n \"def csvOutput(cycle, fctimes, beachdata, offshoredata, surfdata, fname='isurf_output.csv', outdir='.'):\\n\\n datestr = cycle.strftime('%Y%m%d00')\\n\\n with open(outdir+'/%s' %fname,'w') as outp:\\n outp.write(datestr+'\\\\r\\\\n')\\n for isite in range(len(beachdata['name'])):\\n outp.write('\\\\r\\\\n')\\n outp.write('%s' %beachdata['name'][isite] + '\\\\r\\\\n')\\n outp.write('%d' %beachdata['type'][isite] + '\\\\r\\\\n')\\n #outp.write('TI Hsmo Tpmo Dmo Hseq Tpeq DmEq Hsbr Dpbr\\\\r\\\\n')\\n #outp.write('LT,Wspd,Wdir,Hsmo,Tpmo,Dmo,Tide,Hseq,Tpeq,DmEq,Hsbr,Dpbr,Hlbr,Hhbr,BT\\\\r\\\\n')\\n outp.write('LT,Wspd,Wdir,Hsmo,Tpmo,Dmo,Hseq,Tpeq,DmEq,Hsbr,Dpbr,Hlbr,Hhbr,BT\\\\r\\\\n')\\n\\n\\t # write out to file\\n for itime in range(len(fctimes)):\\n\\n # write out the data values to file\\n\\t #outp.write ('%02d' %fctimes[lp] + ' %4.2f %4.1f %3d' %tuple([hm0[lp,isite], tp[lp,isite], dirn[lp,isite]]) + \\\\\\n # ' %4.2f %4.1f %3d' %tuple([hsshwd[lp,isite], tpshwd[lp,isite], reldir[lp,isite]]) + ' %4.2f %4.2f' %tuple([hsbkinit[lp,isite], dpsat[lp,isite]]) + '\\\\r\\\\n')\\n\\t outp.write('%02d' %fctimes[itime] + \\\\\\n ',%4.1f' %offshoredata['wspd'][itime,isite] + \\\\\\n #',%3d' %offshoredata['wdir'][itime,isite] + \\\\\\n ',%4.2f' %offshoredata['hm0'][itime,isite] + \\\\\\n ',%4.1f' %offshoredata['tp'][itime,isite] + \\\\\\n ',%3d' %offshoredata['dirn'][itime,isite] + \\\\\\n ',%4.2f' %surfdata['shorewardHs'][itime,isite] + \\\\\\n ',%4.1f' %surfdata['shorewardT'][itime,isite] + \\\\\\n ',%3d' %surfdata['relativeDirn'][itime,isite] + \\\\\\n ',%4.2f' %surfdata['breakerHs'][itime,isite] + \\\\\\n ',%4.2f' %surfdata['saturatedDepth'][itime,isite] + \\\\\\n ',%4.2f' %surfdata['Hb1in3'][itime,isite] + \\\\\\n ',%4.2f' %surfdata['Hb1in10'][itime,isite] + \\\\\\n ',%1d' %surfdata['breakerType'][itime,isite] + '\\\\r\\\\n')\\n outp.close()\",\n \"def genScheduleCSV():\\r\\n try: \\r\\n printSchedule()\\r\\n save_class_list()\\r\\n print(\\\"\\\\nSchedule generated, check working directory\\\")\\r\\n except Exception as e:\\r\\n print(\\\"Exception found\\\" + str(e))\",\n \"def generate_csv(results, path):\\n csvpath = path + '/results.csv'\\n\\n if os.path.exists(csvpath):\\n os.remove(csvpath)\\n\\n csvf = open(csvpath, 'w')\\n\\n # Header\\n csvf.write(\\\"Powerpoint, Mean, Mode\\\\n\\\")\\n\\n # Results\\n for power in results:\\n mean = 0\\n count = 0\\n mode = 0\\n maxc = 0\\n for freq in results[power]:\\n freqc = results[power][freq]\\n\\n mean += freq * freqc\\n count += freqc\\n\\n if freqc > maxc:\\n mode = freq\\n\\n mean /= count\\n\\n csvf.write(f\\\"{power}, {mean}, {mode}\\\\n\\\")\\n\\n csvf.close()\",\n \"def createOutput():\\n\\n firstPeriod = True\\n # get edge No\\n edgesNo = 0\\n edgesSet = set()\\n for timestep, taxiList in vtypeDict.iteritems():\\n for tup in taxiList:\\n edgesSet.add(tup[1])\\n edgesNo = len(edgesSet)\\n\\n outputFile = open(path.FQoutput, 'w')\\n outputFile.write('<?xml version=\\\"1.0\\\"?>\\\\n')\\n outputFile.write('<paramEffects aggregationInterval=\\\"%d\\\" vehicles=\\\"%d\\\" edges=\\\"%d\\\">\\\\n' % (\\n aggInterval, vehSum, edgesNo))\\n for period, quota, vtypeDictR, taxiSum in generatePeriodQuotaSets(True):\\n if quota is None:\\n if not firstPeriod:\\n outputFile.write(\\\"\\\\t</periods>\\\\n\\\")\\n else:\\n firstPeriod = False\\n outputFile.write('\\\\t<periods period=\\\"%d\\\">\\\\n' % (period))\\n else:\\n simpleTaxiMeanVList = [0, 1]\\n simpleEdgeMeanVList = [0, 1]\\n drivenEdgesSet = set()\\n\\n if len(vtypeDictR) == 0: # if the processed FCD returns no Values\\n print(\\\"noData p\\\", period, \\\" q\\\", quota)\\n drivenEdgesSet.add(0)\\n else: # create mean from all taxi speed values\\n for timestep, taxiList in vtypeDictR.iteritems():\\n for tup in taxiList: # all elements in this timestep\\n simpleTaxiMeanVList[0] += tup[2]\\n simpleTaxiMeanVList[1] += 1\\n drivenEdgesSet.add(tup[1])\\n # create mean from all edge speed values which are driven by the\\n # chosen taxis\\n drivenEdgesList = list(drivenEdgesSet)\\n drivenEdgesList.sort()\\n # print \\\"dataSets \\\",simpleTaxiMeanVList[1]\\n\\n # --edgeDump-- #\\n \\\"\\\"\\\"\\n for i in edgeDumpDict.keys(): #all intervals\\n for edge,v in edgeDumpDict[i]:\\n if BinarySearch.isElmInList(drivenEdgesList,edge):\\n simpleEdgeMeanVList[0]+=v\\n simpleEdgeMeanVList[1]+=1\\n \\\"\\\"\\\"\\n # --vtype-- #\\n\\n for timestep, taxiList in vtypeDict.iteritems():\\n for tup in taxiList:\\n if BinarySearch.isElmInList(drivenEdgesList, tup[1]):\\n simpleEdgeMeanVList[0] += tup[2]\\n simpleEdgeMeanVList[1] += 1\\n\\n # calc values for output\\n detectedEdges = len(drivenEdgesSet)\\n relDetectedEdges = detectedEdges * 100.0 / edgesNo\\n vSim = simpleEdgeMeanVList[0] / simpleEdgeMeanVList[1]\\n vSimFCD = simpleTaxiMeanVList[0] / simpleTaxiMeanVList[1]\\n vAbsDiff = vSimFCD - vSim\\n if vSim != 0:\\n vRelDiff = vAbsDiff / vSim * 100\\n else:\\n vRelDiff = 100\\n if vRelDiff < -40:\\n vRelDiff = -35\\n\\n outputFile.write('\\\\t\\\\t<values taxiQuota=\\\"%f\\\" taxis=\\\"%d\\\" simMeanSpeed=\\\"%f\\\" simFcdMeanSpeed=\\\"%f\\\" ' % (\\n quota, taxiSum, vSim, vSimFCD,))\\n outputFile.write('detectedEdges=\\\"%d\\\" notDetectedEdges=\\\"%d\\\" ' % (\\n detectedEdges, edgesNo - detectedEdges))\\n outputFile.write('absSpeedDiff=\\\"%f\\\" relSpeedDiff=\\\"%f\\\" relDetectedEdges=\\\"%f\\\" relNotDetectedEdges=\\\"%f\\\"/>\\\\n' %\\n (vAbsDiff, vRelDiff, relDetectedEdges, 100 - relDetectedEdges))\\n outputFile.write(\\\"\\\\t</periods>\\\\n</paramEffects>\\\")\\n outputFile.close()\",\n \"def output():\\n\\n if args.top and not args.tfidf and not args.svd:\\n most_frequent(vector).to_csv(path_or_buf=\\\"top{}_vectorfile.csv\\\".format(args.top))\\n\\n elif args.top and args.tfidf and not args.svd:\\n tfidf_transform(most_frequent(vector)).to_csv(path_or_buf=\\\"tfidf_top{}.csv\\\".format(args.top))\\n\\n elif args.top and args.tfidf and args.svd:\\n svd_transform(tfidf_transform(most_frequent(vector)), indexes).to_csv(path_or_buf=\\\"svd{}_tfidf_topn.csv\\\".format(args.svd))\\n\\n elif args.tfidf and not args.top and not args.svd:\\n tfidf_transform(vector).to_csv(path_or_buf=\\\"tfidf.csv\\\")\\n\\n elif args.svd and not args.top and not args.tfidf:\\n svd_transform(vector, indexes).to_csv(path_or_buf=\\\"svd{}_vector.csv\\\".format(args.svd))\\n\\n elif args.tfidf and args.svd and not args.top:\\n svd_transform(tfidf_transform(vector), indexes).to_csv(path_or_buf=\\\"svd{}_tfidf.csv\\\".format(args.svd))\\n\\n else:\\n vector.to_csv(path_or_buf=\\\"vectorfile.csv\\\")\",\n \"def output_selectivities(run_name):\\n\\tf = open(toggles.OUTPUT_PATH + run_name + '_sample_selectivites.csv', 'a')\\n\\tfor p in toggles.CHOSEN_PREDS:\\n\\t\\tpred = Predicate.objects.all().get(pk=p+1)\\n\\t\\tf.write(str(pred.calculatedSelectivity) + \\\", \\\" + str(pred.totalTasks) + \\\", \\\" + str(pred.num_ip_complete) + \\\"; \\\")\\n\\tf.write('\\\\n')\\n\\tf.close()\",\n \"def write_csv_pairwise(self, agent_num):\\n # self.last_timestep_data = []\\n for task_num, i in enumerate(self.tasks):\\n current_task_data = []\\n task_loc = i.getloc()\\n vectorized_task_loc = self.get_vectorized_location(task_loc)\\n current_task_data.append(self.t)\\n current_task_data.append(self.w_EDR)\\n current_task_data.append(self.w_RESOURCE)\\n current_task_data.append(self.w_DISTANCE)\\n current_task_data.append(agent_num)\\n\\n current_task_data.append(task_num)\\n current_task_data.extend(self.is_agent_idle[agent_num]) # Feature 6\\n current_task_data.append((self.is_task_finished[0][task_num])) # Feature 2\\n current_task_data.append((self.is_task_enabled[0][task_num])) # Feature 3\\n current_task_data.append((self.is_task_alive[0][task_num])) # Feature 4\\n current_task_data.append((self.travel_time_constraint_satisfied[agent_num][task_num])) # Feature 5\\n is_occupied = self.agent_locations[0][vectorized_task_loc] # if 1 agent is there, 0 is unoccupied\\n current_task_data.append((is_occupied)) # Feature 1\\n current_task_data.append((self.agent_distances[agent_num][task_num])) # Feature 7\\n current_task_data.append((self.orientation[agent_num][task_num])) # Feature 9\\n current_task_data.append((self.task_deadlines[0][task_num])) # Feature 10\\n current_task_data.append((self.is_task_in_progress[0][task_num])) # Feature 11\\n current_task_data.append((\\n self.orientation[agent_num][task_num] * self.agent_distances[agent_num][task_num])) # Feature 12\\n current_task_data.append((self.how_many_tasks_in_each_square[0][vectorized_task_loc])) # Feature 8\\n if self.task_to_schedule == -1:\\n null_task = 1\\n else:\\n null_task = 0\\n current_task_data.append(null_task)\\n current_task_data.append(self.task_to_schedule[0]) # Output\\n self.pairwise_total_data.append(current_task_data)\\n # self.last_timestep_data.append(current_task_data)\\n # with open('11_schedule.csv', 'a') as outfile:\\n # writer = csv.writer(outfile)\\n # writer.writerow(current_task_data)\",\n \"def export_csv( self, db_device_adapters, db_start, db_end, min_points = 10, csv_file_name = \\\"data.csv\\\" ):\\n msg = f\\\"Export data to csv file {csv_file_name}...\\\"\\n AppGlobal.gui.display_info_string( msg )\\n sep = \\\"\\\\t\\\"\\n for i_device_adapter in db_device_adapters:\\n #time_data, inst_pw_data, total_power_data, = self._prep_data( i_device_adapter, db_start, db_end, min_points )\\n i_device_adapter.retrived_data_cache = self._prep_data( i_device_adapter, db_start, db_end, min_points )\\n time_data, inst_pw_data, total_power_data, = i_device_adapter.retrived_data_cache\\n\\n device_name = i_device_adapter.name\\n\\n if time_data is None:\\n msg = f\\\"No data for {device_name}.\\\"\\n AppGlobal.gui.display_info_string( msg )\\n else:\\n with open( csv_file_name, \\\"a\\\" ) as a_file: # we are appending\\n a_file.write( f'\\\"device\\\"{sep}\\\"time_data\\\"{sep}\\\"inst_pw_data\\\"{sep}\\\"total_power_data\\\"\\\\n' )\\n for ix_list, i_time in enumerate( time_data ):\\n a_file.write( f\\\"{device_name}{sep}{time_data[ ix_list ]}{sep}{inst_pw_data[ ix_list ]}{sep}{total_power_data[ ix_list ]}\\\\n\\\" )\\n\\n msg = f\\\"...CSV file complete.\\\"\\n AppGlobal.gui.display_info_string( msg )\",\n \"def start_rec(self):\\r\\n if not os.path.exists(MEASUREMENTS_DIR):\\r\\n os.makedirs(MEASUREMENTS_DIR)\\r\\n self._csv_file = open(MEASUREMENTS_DIR.child('data.csv'), 'wb')\\r\\n self._csv_writer = csv.DictWriter(\\r\\n self._csv_file, fieldnames=list(self._data.keys()))\\r\\n self._csv_writer.writeheader()\",\n \"def generate_sdfs(timing_data, sdf_path):\\n\\n def make_speed_model(data):\\n \\\"\\\"\\\"\\n Makes a speed model structure for the SDF writer\\n \\\"\\\"\\\"\\n model = dict()\\n\\n # Create entry for sdf writer\\n iport = dict()\\n iport['port'] = data[\\\"input\\\"]\\n iport['port_edge'] = None\\n oport = dict()\\n oport['port'] = data[\\\"output\\\"]\\n oport['port_edge'] = None\\n\\n paths = dict()\\n paths = add_timing_paths_entry(\\n paths, 'slow', [data['SLOW_MIN'], None, data['SLOW_MAX']])\\n paths = add_timing_paths_entry(\\n paths, 'fast', [data['FAST_MIN'], None, data['FAST_MAX']])\\n\\n # Net delay\\n if data[\\\"is_net\\\"]:\\n model = utils.add_interconnect(iport, oport, paths)\\n model[\\\"is_absolute\\\"] = True\\n\\n # Routing bel delay\\n else:\\n model = utils.add_iopath(iport, oport, paths)\\n model[\\\"is_absolute\\\"] = True\\n\\n return model\\n\\n # Build SDF structures\\n sdf_data = dict()\\n for site_name, site_data in timing_data.items():\\n\\n # New SDF\\n if site_name not in sdf_data:\\n sdf_data[site_name] = dict()\\n sdf_data[site_name][\\\"cells\\\"] = dict()\\n\\n for cell_type, cell_data in site_data.items():\\n\\n # New celltype\\n if cell_type not in sdf_data[site_name][\\\"cells\\\"]:\\n sdf_data[site_name][\\\"cells\\\"][cell_type] = dict()\\n\\n for instance, instance_data in cell_data.items():\\n\\n # New cell instance\\n if instance not in sdf_data[site_name][\\\"cells\\\"][cell_type]:\\n sdf_data[site_name][\\\"cells\\\"][cell_type][instance] = dict()\\n\\n # Add speed models\\n for speed_model, speed_data in instance_data.items():\\n sdf_data[site_name][\\\"cells\\\"][cell_type][instance][\\n speed_model] = make_speed_model(speed_data)\\n\\n # Emit SDFs\\n for name, data in sdf_data.items():\\n fname = os.path.join(sdf_path, name.upper() + \\\".sdf\\\")\\n fdata = sdfparse.emit(data, timescale='1ns')\\n\\n with open(fname, \\\"w\\\") as fp:\\n fp.write(fdata)\",\n \"def print(self):\\n df = self.gen_test()\\n # print(df)\\n df.to_csv('some_dated_file.csv', index=False)\\n return df\",\n \"def create_csv(start: object, end: object):\\n data_frame = web.DataReader(\\\"^DJI\\\", \\\"yahoo\\\", start, end)\\n data_frame.to_csv(\\\"dow.csv\\\")\",\n \"def dump_all_binaries_to_CSV():\\n ## TODO\\n timenow = datetime.now()\",\n \"def analysis_dev_sec(self):\\n #calc the date\\n time_now = int(time.time())\\n time_local = time.localtime(time_now)\\n date = time.strftime(\\\"%Y-%m-%d\\\",time_local)\\n sum_cpu_ratio = 0\\n sum_gpu_mem_size = 0\\n # key: time key\\n key_re_time = \\\"[0-9]+ [0-9]+:[0-9]+:[0-9]+ 20[12][][0-9]\\\"\\n # key: temperature key\\n key_re_temper = \\\"[0-9]+C\\\"\\n # key: gpu percent key\\n key_re_percent = \\\"[0-9]+%\\\"\\n # key: gpu mem key\\n key_re_mem = \\\"%s\\\" % self.pid\\n key_re_mem_null = \\\"No running processes found\\\"\\n # key: line ending key\\n key_ending = \\\"====ending====\\\"\\n\\n new_gpu_data_count = 0\\n sum_gpu_usage_percent_all = 0\\n for line in self.file_gpu.readlines():\\n if re.search(key_re_time, line):\\n # time own unit\\n # 1. colect the gpu time info\\n final_time = date + \\\" \\\" + line.split()[3]\\n self.gpu_pertime.append(final_time)\\n elif re.search(key_re_temper, line) and re.search(key_re_percent, line):\\n #print \\\"2222, data_line: %s\\\" % line\\n # 2. colect the gpu temperature info\\n # 3. colect the gpu usage percentage info\\n temper = float(line.split()[2].rstrip(\\\"C\\\"))\\n gpu_usage = float(line.split()[12].rstrip(\\\"%\\\"))\\n if new_gpu_data_count == 0:\\n self.gpu_temper_1.append(temper)\\n self.gpu_usage_percent_1.append(gpu_usage)\\n elif new_gpu_data_count == 1:\\n self.gpu_temper_2.append(temper)\\n self.gpu_usage_percent_2.append(gpu_usage)\\n elif new_gpu_data_count == 2:\\n self.gpu_temper_3.append(temper)\\n self.gpu_usage_percent_3.append(gpu_usage)\\n elif new_gpu_data_count == 3:\\n self.gpu_temper_4.append(temper)\\n self.gpu_usage_percent_4.append(gpu_usage)\\n new_gpu_data_count += 1\\n elif re.search(key_re_mem, line) or re.search(key_re_mem_null, line):\\n # 4. colect the gpu mem info\\n this_gpu_num = line.split()[1]\\n if \\\"MiB\\\" in line.split()[5]:\\n this_gpu_mem = float(line.split()[5].strip(\\\"MiB\\\"))\\n # TODO_this: if there have other unit\\n\\n if this_gpu_num == \\\"0\\\":\\n self.gpu_mem_1.append(this_gpu_mem)\\n elif this_gpu_num == \\\"1\\\":\\n self.gpu_mem_2.append(this_gpu_mem)\\n elif this_gpu_num == \\\"2\\\":\\n self.gpu_mem_3.append(this_gpu_mem)\\n elif this_gpu_num == \\\"3\\\":\\n self.gpu_mem_4.append(this_gpu_mem)\\n elif this_gpu_num == \\\"No\\\":\\n self.gpu_mem_1.append(0)\\n self.gpu_mem_2.append(0)\\n self.gpu_mem_3.append(0)\\n self.gpu_mem_4.append(0)\\n \\n elif re.search(key_ending, line):\\n # control unit\\n # 1.complete the gpu_mem list\\n max_len_gpu_mem = max(len(self.gpu_mem_4), len(self.gpu_mem_3), len(self.gpu_mem_2), len(self.gpu_mem_1))\\n min_len_gpu_mem = min(len(self.gpu_mem_4), len(self.gpu_mem_3), len(self.gpu_mem_2), len(self.gpu_mem_1))\\n if max_len_gpu_mem != min_len_gpu_mem:\\n if len(self.gpu_mem_1) != max_len_gpu_mem:\\n self.gpu_mem_1.append(0)\\n if len(self.gpu_mem_2) != max_len_gpu_mem:\\n self.gpu_mem_2.append(0)\\n if len(self.gpu_mem_3) != max_len_gpu_mem:\\n self.gpu_mem_3.append(0)\\n if len(self.gpu_mem_4) != max_len_gpu_mem:\\n self.gpu_mem_4.append(0)\\n new_gpu_data_count = 0\\n\\n # ! because all the list is equal\\n for i in range(len(self.gpu_mem_1)):\\n self.gpu_usage_percent_all.append(self.gpu_usage_percent_1[i] + self.gpu_usage_percent_2[i] + self.gpu_usage_percent_3[i] + self.gpu_usage_percent_4[i])\\n\\n #self.gpu_mem_all.append(self.gpu_mem_1[i] + self.gpu_mem_2[i] + self.gpu_mem_3[i] + self.gpu_mem_4[i])\\n self.gpu_mem_all.append(self.gpu_mem_1[i] + self.gpu_mem_2[i] + self.gpu_mem_3[i] + self.gpu_mem_4[i])\\n sum_gpu_mem_size += max(self.gpu_mem_1[i], self.gpu_mem_2[i], self.gpu_mem_3[i], self.gpu_mem_4[i])\\n\\n self.gpu_temper_max.append(max(self.gpu_temper_1[i] ,self.gpu_temper_2[i] ,self.gpu_temper_3[i] ,self.gpu_temper_4[i]))\\n\\n version_gpu_usage_percent_all = max(self.gpu_usage_percent_all)\\n\\n version_gpu_mem_all = max(self.gpu_mem_all)\\n version_gpu_mem_avg = round(sum_gpu_mem_size/len(self.gpu_mem_all), 2)\\n\\n version_gpu_temper_max = max(self.gpu_temper_max)\\n\\n print \\\"version_gpu_usage_percent_all: %s\\\" % version_gpu_usage_percent_all\\n print \\\"version_gpu_mem_all: %s\\\" % version_gpu_mem_all\\n print \\\"version_gpu_mem_avg: %s\\\" % version_gpu_mem_avg\\n print \\\"version_gpu_temper_max: %s\\\" % version_gpu_temper_max\\n\\n # insert into database: nvidia_list_1sec\\n if self.db_onoff == \\\"on\\\":\\n # insert into database: nvidia_list_1sec_avg\\n self.mysql.insert_table_sql_nvidia_version(self.time_sql, version_gpu_usage_percent_all, version_gpu_mem_avg, version_gpu_temper_max)\\n # insert into database: nvidia_list_1sec_max\\n #self.mysql.insert_table_sql_nvidia_version(self.time_sql, version_gpu_usage_percent_all, version_gpu_mem_all, version_gpu_temper_max)\",\n \"def csv(self):\\n result = \\\"\\\"\\n for cpu in self.cpus_current:\\n result += str(cpu) + \\\",\\\"\\n return result\",\n \"def create_csv_file(self):\\r\\n # Create a new csv-file\\r\\n with open(self.fname, 'w') as f:\\r\\n writer = csv.writer(f, dialect='excel')\\r\\n writer.writerow(['set_time',\\r\\n 'read_time_P_ac',\\r\\n 'read_time_P_bat',\\r\\n 'soc',\\r\\n 'set_value',\\r\\n 'P_ac',\\r\\n 'P_bat'])\",\n \"def print_v(self, filename, gather=True):\\n global controller\\n timeStep = (controller.dao.machineTimeStep*1.0)/1000.0\\n v = self.get_v(gather, compatible_output=True)\\n utility_calls.check_directory_exists(filename)\\n fileHandle = open(filename, \\\"w\\\")\\n first_id = 0\\n num_neurons = self.vertex.atoms\\n dimensions = self.vertex.atoms\\n fileHandle.write(\\\"# first_id = %d\\\\n\\\" % first_id)\\n fileHandle.write(\\\"# n = %d\\\\n\\\" % num_neurons)\\n fileHandle.write(\\\"# dt = %f\\\\n\\\" % timeStep)\\n fileHandle.write(\\\"# dimensions = [%d]\\\\n\\\" % dimensions)\\n fileHandle.write(\\\"# last_id = %d\\\\n\\\" % (num_neurons-1))\\n for (neuronId, time, value) in v:\\n fileHandle.write(\\\"%f\\\\t%d\\\\n\\\" % (value, neuronId))\\n fileHandle.close()\",\n \"def dbtocsv():\\n connection = sqlite3.connect(\\\"sensordata.db\\\")\\n cursor = connection.cursor()\\n cursor.execute(\\\"Select * from sensordata\\\")\\n roadstationdata = cursor.fetchall()\\n\\n with open('roadstationdata.csv', 'w') as f:\\n writer = csv.writer(f)\\n writer.writerow(['id','name','value','unit','time'])\\n writer.writerows(roadstationdata)\",\n \"def calibration(date):\\r\\n\\r\\n l = []\\r\\n for _ in range(NUM_OF_CALIBRATION_BLOCKS):\\r\\n block = q.get()\\r\\n block = block.flatten()\\r\\n energy = np.sum(block ** 2)\\r\\n l.append(energy)\\r\\n std_dev = np.std(l)\\r\\n mean = np.mean(l)\\r\\n l = []\\r\\n l.extend((date, mean, std_dev))\\r\\n\\r\\n with open('calibration.csv', mode = 'a') as file:\\r\\n create = csv.writer(file)\\r\\n create.writerow(l)\\r\\n print(mean, std_dev)\\r\\n return mean, std_dev\",\n \"def lv_analysis():\\r\\n\\r\\n global params\\r\\n n = params['n']\\r\\n lvmin = params['lvmin']\\r\\n lvmax = params['lvmax']\\r\\n lvstep = params['lvstep']\\r\\n ns = params['ns']\\r\\n nt = params['nt']\\r\\n no = params['no']\\r\\n ne = params['ne']\\r\\n nf = params['nf']\\r\\n lv_dir = create_dir(TIMES_PATH + 'lv')\\r\\n filename = datetime.datetime.now().strftime(DATE_FORMAT) + '.csv'\\r\\n with open(lv_dir + filename, 'wb') as csvfile:\\r\\n fw = csv.writer(csvfile)\\r\\n fw.writerow(('lv', 'ns', 'nt', 'no', 'ne', 'nf',\\r\\n 'method1', 'method2', 'method3_1', 'method3_2'))\\r\\n lv = lvmin\\r\\n while lv <= lvmax:\\r\\n times = [0] * 4\\r\\n for i in range(n):\\r\\n times = map(sum, zip(times, get_times(lv, ns, nt, no, ne, nf)))\\r\\n show_progress('lv', lv, lvmin, lvmax, lvstep, i, n)\\r\\n times = map(lambda x : float(x) / n, times)\\r\\n fw.writerow((lv, ns, nt, no, ne, nf) + tuple(times))\\r\\n lv += lvstep\\r\\n csvfile.close()\",\n \"def dt():\\n wheels = [-2, -1, 0, 1, 2]\\n stations = [1,2,3,4]\\n sectors = range(1,13)\\n sectors4 = range(1,15) # more sectors for station 4\\n\\n dt_info = {\\n \\\"wheels\\\":wheels,\\n \\\"stations\\\":stations,\\n \\\"sectors\\\": sectors,\\n \\\"sectors4\\\":sectors4}\\n\\n return dt_info\",\n \"def enter_data_to_running_index():\\n print('{:~^20}'.format('VDOT Table'))\\n return get_distance(), get_time()\",\n \"def pf_analysis():\\r\\n\\r\\n global params\\r\\n n = params['n']\\r\\n level = params['level']\\r\\n pfmin = params['pfmin']\\r\\n pfmax = params['pfmax']\\r\\n pfstep = params['pfstep']\\r\\n ns = params['ns']\\r\\n nt = params['nt']\\r\\n po = params['po']\\r\\n pe = params['pe']\\r\\n pf_dir = create_dir(TIMES_PATH + 'pf')\\r\\n filename = datetime.datetime.now().strftime(DATE_FORMAT) + '.csv'\\r\\n with open(pf_dir + filename, 'wb') as csvfile:\\r\\n fw = csv.writer(csvfile)\\r\\n fw.writerow(('lv', 'ns', 'nt', 'no', 'ne', 'pf', 'nf',\\r\\n 'method1', 'method2', 'method3_1', 'method3_2'))\\r\\n pf = pfmin\\r\\n while pf <= pfmax:\\r\\n no = max(int(round(po * nt)), 1)\\r\\n ne = max(int(round(pe * no)), 1)\\r\\n nf = max(int(round(pf * nt)), 1)\\r\\n times = [0] * 4\\r\\n for i in range(n):\\r\\n times = map(sum, zip(times, get_times(level, ns, nt, no, ne, nf)))\\r\\n show_progress('pf', pf, pfmin, pfmax, pfstep, i, n)\\r\\n times = map(lambda x: float(x) / n, times)\\r\\n fw.writerow((level, ns, nt, no, ne, pf, nf) + tuple(times))\\r\\n pf += pfstep\\r\\n csvfile.close()\",\n \"def gen_csv_line(dt, data_type, ss_code, ss_config, bin_num, beam_num, blank, bin_size, value):\\n #dt_str = dt.strftime(Ensemble.CSV_DATETIME_FORMAT)\\n dt_str = dt.isoformat()\\n\\n bin_depth = Ensemble.get_bin_depth(blank, bin_size, bin_num)\\n\\n return \\\"{},{},{},{},{},{},{},{}\\\".format(dt_str, data_type, ss_code, ss_config, bin_num, beam_num, bin_depth, value)\",\n \"def gen_fps():\\n global data_src ,output_dir \\n logger = TaskFileLogger(\\\"GenFP\\\")\\n\\n h_vars = load_hydro_var()\\n if not os.path.exists(output_dir):\\n os.mkdir(output_dir)\\n\\n for h_type,var_d in h_vars.items():\\n print \\\"considering %s\\\" %h_type\\n\\n t_output_dir = os.path.join(output_dir,h_type)\\n if not os.path.exists(t_output_dir):\\n print \\\"creating path %s\\\" %t_output_dir\\n os.mkdir(t_output_dir)\\n logger.log(\\\"%s started\\\" %(h_type))\\n\\n for fname in glob.glob(data_src):\\n complex_id = os.path.basename(fname).split('.')[0] \\n fp_path = os.path.join(t_output_dir,complex_id + \\\".fp\\\" )\\n if os.path.exists(fp_path):\\n #print \\\"%s processed\\\" %complex_id\\n continue\\n print \\\"processing %s,fp saved as %s\\\" %(fname , fp_path )\\n c = Complex(fname,hydro_dict = var_d)\\n c.get_fp()\\n c.write_fp_to_file(fp_path)\\n\\n logger.log(\\\"%s finished\\\" %(h_type))\",\n \"def build_csv(path):\\n # find unique param pairs in folder :\\n num_ptrn = '[-+]?\\\\d*\\\\.\\\\d+|\\\\d+'\\n all_files = glob.glob(path)\\n param_strings = [f.split('_')[4] for f in all_files]\\n params1 = set([tuple(re.findall(num_ptrn,s)) for s in param_strings])\\n iters = [str(i) for i in range(2)]\\n params2 = list(product(list(params1),iters))\\n params2 = [(p[0][0],p[0][1],p[1]) for p in params2 if type(p[0]) == tuple] + list(params1)\\n rows = []\\n deviation_rows = []\\n for i,prms in enumerate(params2):\\n print(prms)\\n t1 = time.time()\\n files = [f for f in all_files if '_' + prms[0] + 'M' in f and 'X' + prms[1] + '_' in f]\\n if len(prms) == 3:\\n files = [f for f in files if 'iter'+prms[2] in f]\\n itr = int(prms[2])\\n else:\\n files = [f for f in files if 'iter' not in f]\\n itr = 2\\n files.sort(reverse = True,key = lambda x: int(re.findall(num_ptrn,x)[-1]))\\n # only take first 100 cells for faster analysis :\\n\\n # extract tracks from files :\\n tracks = [np.loadtxt(f) for f in files]\\n tracks = [handle_boundaries(t) for t in tracks]\\n print('number of cells for paramset : ',len(tracks))\\n\\n vec_tracks = np.array([to_vecs(t) for t in tracks])\\n speeds = [[norm(v) for v in vec_track] for vec_track in vec_tracks]\\n speeds = [item for sublist in speeds for item in sublist]\\n speed = np.mean(speeds)\\n std_speed = np.std(speeds)\\n print('Speed calculated')\\n\\n # pooled persistance : \\n t2 = time.time()\\n averages2 = pool_ac(np.array([autocor2(t) for t in tracks]))\\n t3 = time.time()\\n pooled_pers = Persist_tracks([averages2])\\n t4 = time.time()\\n\\n rows.append([prms[0],prms[1],itr,speed,std_speed,np.mean(pooled_pers),np.std(pooled_pers)])\\n print(rows[-1])\\n print('computing time :',time.time() - t1)\\n print('dots per dts time : ',t3 - t2)\\n print('half time :',t4 - t3)\\n df1 = pd.DataFrame(data = rows,\\n columns = ['Lambda', 'Max_act','iter','speed','speed_std','persistance','std_persit'])\\n df1.to_csv('FITFULL/4ACT_all.csv')\",\n \"def write_log(self):\\n with open(self.trav_stat_file, 'a') as stat_file:\\n travel_writer = csv.writer(stat_file)\\n # Every row starts with the start and destnation\\n row = [self.start, self.dest]\\n # This uses a static list so that the order is fixed\\n for state in [\\\"waiting\\\", \\\"riding\\\", \\\"transferring\\\"]:\\n state_total = sum(self.time_record[state])\\n row.append(state_total)\\n travel_writer.writerow(row)\",\n \"def init_csv_file(self):\\n folder = \\\"/home/pi/data/\\\" + datetime.now().strftime(\\\"%Y_%m_%d\\\") + \\\"/\\\"\\n if not os.path.isdir(folder):\\n # append 'a' to the folder name until we find a name that does not exist\\n while os.path.exists(folder):\\n folder = folder[:-1] + \\\"a\\\" + \\\"/\\\"\\n os.mkdir(folder)\\n filename = folder + 'particledata_' + datetime.now().strftime (\\\"%H-%M-%S\\\") \\n while os.path.exists(filename):\\n filename = filename + '_a'\\n filename += '.csv'\\n log.info('Writing data to: ' + filename)\\n self.file = open(filename, \\\"w\\\")\\n self.file.write('Unix Time;Human Readable Time;pm 2.5;pm 10;Has Fix;Longitude;Latitude;Altitude;GPS Unix Time\\\\n')\\n self.file.flush()\\n self.synced_time = False\",\n \"def df():\\n fs.df()\",\n \"def __create_output_csv(self, df, score_list, elapsed_list):\\n df['Similar']=score_list\\n df['Elapsed']=elapsed_list\\n df.to_csv('Output.csv',index=False)\\n return df\",\n \"def RWC_table(datasource, output, time):\\n with open(output + '_' + time + '.csv', 'wb') as destination:\\n writer = csv.writer(destination)\\n if time == 'day':\\n writer.writerow(['file'] + lod)\\n elif time == 'week':\\n writer.writerow(['file'] + weeks)\\n \\n for file in os.listdir(datasource):\\n rowlist = []\\n if file.endswith(\\\".csv\\\"):\\n rowlist.append(file)\\n print(file)\\n\\n # Check timeinterval and run pipeline with those settings\\n if time == 'day':\\n for day in tqdm(lod):\\n rowlist.append(pipeline(datasource + file, [day], False, False))\\n writer.writerow(rowlist)\\n\\n if time == 'week':\\n for week in tqdm(weeks):\\n rowlist.append(pipeline(datasource + file, week, False, False))\\n writer.writerow(rowlist)\",\n \"def save_component_csv (self, directory):\\n #~ return\\n if not self.was_run:\\n #~ fname = os.path.join(directory,\\n #~ self.component_name + \\\"_output.csv\\\")\\n #~ fname = fname.replace(\\\" \\\",\\\"_\\\")\\n\\n #~ fd = open(fname, 'w')\\n #~ fd.write(\\\"Wind Power minimum requirements not met\\\\n\\\")\\n #~ fd.close()\\n return\\n\\n\\n years = np.array(range(self.project_life)) + self.start_year\\n\\n # ??? +/-\\n # ???\\n df = DataFrame({\\n 'Wind: Capacity (kW)':self.load_offset_proposed,\\n \\\"Wind: Generation (kWh/year)\\\": self.net_generation_wind,\\n 'Wind: Energy Captured by Secondary Load'\\n ' (gallons of heating oil equivalent)':\\n self.diesel_equiv_captured,\\n 'Wind: Assumed capacity factor':\\n float(self.comp_specs['capacity factor']),\\n 'Wind: Utility Diesel Displaced (gallons/year)':\\n self.electric_diesel_reduction,\\n 'Wind: Heat Recovery Lost (gallons/year)':\\n self.loss_heat_recovery,\\n \\\"Wind: Heat Recovery Cost Savings ($/year)\\\":\\n self.get_heating_savings_costs(),\\n \\\"Wind: Electricity Cost Savings ($/year)\\\":\\n self.get_electric_savings_costs(),\\n \\\"Wind: Project Capital Cost ($/year)\\\":\\n self.get_capital_costs(),\\n \\\"Wind: Total Cost Savings ($/year)\\\":\\n self.get_total_savings_costs(),\\n \\\"Wind: Net Benefit ($/year)\\\": self.get_net_benefit(),\\n }, years)\\n\\n df[\\\"Community\\\"] = self.cd['name']\\n\\n ol = [\\\"Community\\\",\\n 'Wind: Capacity (kW)',\\n 'Wind: Energy Captured by Secondary Load'\\n ' (gallons of heating oil equivalent)',\\n 'Wind: Assumed capacity factor',\\n 'Wind: Utility Diesel Displaced (gallons/year)',\\n 'Wind: Heat Recovery Lost (gallons/year)',\\n \\\"Wind: Generation (kWh/year)\\\",\\n \\\"Wind: Heat Recovery Cost Savings ($/year)\\\",\\n \\\"Wind: Electricity Cost Savings ($/year)\\\",\\n \\\"Wind: Project Capital Cost ($/year)\\\",\\n \\\"Wind: Total Cost Savings ($/year)\\\",\\n \\\"Wind: Net Benefit ($/year)\\\"]\\n fname = os.path.join(directory,\\n self.cd['name'] + '_' + \\\\\\n self.component_name.lower() + \\\"_output.csv\\\")\\n fname = fname.replace(\\\" \\\",\\\"_\\\")\\n\\n df[ol].ix[:self.actual_end_year].to_csv(fname, index_label=\\\"Year\\\")\",\n \"def print_dfs_output(G, d, f, pi):\\n V = G[0]\\n print (\\\" d f pi\\\")\\n for v in V:\\n print (\\\" {: <5}{: <5}{: <5}{: <5}\\\".format(v, d[v], f[v], pi[v]))\",\n \"def coregister_formatted():\\r\\n\\r\\n print(\\\"begin coregister_formatted\\\")\\r\\n\\r\\n # check all records for pairs using the recordBegin time\\r\\n pair_records()\\r\\n\\r\\n # establish the beginning and end of the coregistered records\\r\\n define_pairedRecords()\\r\\n\\r\\n # coregister paired data in a single csv\\r\\n format_coregister()\\r\\n\\r\\n\\r\\n print(\\\"completed segment_formatted\\\")\",\n \"def df():\\n path, _ = os.path.split(os.path.abspath(__file__))\\n project_path = os.path.join(path, os.pardir, os.pardir)\\n\\n values_path = os.path.join(project_path, \\\"data\\\", \\\"raw\\\", \\\"pumps_train_values.csv\\\")\\n labels_path = os.path.join(project_path, \\\"data\\\", \\\"raw\\\", \\\"pumps_train_labels.csv\\\")\\n\\n train = pd.read_csv(values_path, index_col='id', parse_dates=[\\\"date_recorded\\\"])\\n labels = pd.read_csv(labels_path, index_col='id')\\n\\n return train.join(labels)\",\n \"def courant_processor(self):\\n with open(join(self.logs_dir, \\\"courant.dat\\\"), 'w') as fh:\\n fh.write(\\\"Time CoMean CoMax\\\\n\\\")\\n while True:\\n rexp = (yield)\\n fh.write(self.time_str + \\\"\\\\t\\\" +\\n \\\"\\\\t\\\".join(x for x in rexp.groups()) + \\\"\\\\n\\\")\",\n \"def write_csv(self, agent_num):\\n data = []\\n data.append(self.t)\\n data.append(self.w_EDR)\\n data.append(self.w_RESOURCE)\\n data.append(self.w_DISTANCE)\\n data.append(agent_num)\\n for task_num, task in enumerate(self.tasks):\\n vectorized_task_loc = self.get_vectorized_location(task.getloc())\\n is_occupied = self.agent_locations[0][vectorized_task_loc] # 1 if occupied\\n data.append(is_occupied)\\n # data.extend(np.ndarray.tolist(self.agent_locations)) # Feature 1\\n data.extend(np.ndarray.tolist(self.is_task_finished)) # Feature 2\\n data.extend(np.ndarray.tolist(self.is_task_enabled)) # Feature 3\\n data.extend(np.ndarray.tolist(self.is_task_alive)) # Feature 4\\n data.extend(np.ndarray.tolist(self.travel_time_constraint_satisfied[agent_num])) # Feature 5\\n data.extend(self.is_agent_idle[agent_num]) # Feature 6\\n data.extend(np.ndarray.tolist(self.agent_distances[agent_num])) # Feature 7\\n for task_num, task in enumerate(self.tasks):\\n vectorized_task_loc = self.get_vectorized_location(task.getloc())\\n tasks_in_each_square = self.how_many_tasks_in_each_square[0][vectorized_task_loc] # 1 if occupied\\n data.append(tasks_in_each_square)\\n # data.extend(np.ndarray.tolist(self.how_many_tasks_in_each_square)) # Feature 8\\n data.extend(np.ndarray.tolist(self.orientation[agent_num])) # Feature 9\\n data.extend(np.ndarray.tolist(self.task_deadlines)) # Feature 10\\n data.extend(np.ndarray.tolist(self.is_task_in_progress)) # Feature 11\\n data.extend(np.ndarray.tolist(self.orientation[agent_num] * self.agent_distances[agent_num])) # Feature 12\\n data.append(self.task_to_schedule) # Output\\n self.naive_total_data.append(data)\\n # with open('1_schedule.csv', 'a') as outfile:\\n # writer = csv.writer(outfile)\\n # writer.writerow(data)\",\n \"def create_display_data_table():\\n\\n for ccd in range(0, 10):\\n for node in range(0, 4):\\n file = 'ccd' + str(ccd) + '_' + str(node)\\n infile = data_dir + file\\n outfile = web_dir + 'Data/' + file\\n\\n f = open(infile, 'r')\\n data = [line.strip() for line in f.readlines()]\\n f.close()\\n\\n fo = open(outfile, 'w')\\n#\\n#--- adding heading\\n#\\n line = \\\"#\\\\n#Date Mn K alpha Al K alpha Ti K alpha Slope Sigma Int Sigma\\\\n#\\\\n\\\"\\n fo.write(line)\\n for ent in data:\\n atemp = re.split('\\\\s+', ent)\\n stime = int(atemp[0])\\n#\\n#--- converting the date into <mon> <year> form (e.g. May 2013)\\n#\\n ltime = tcnv.axTimeMTA(stime)\\n btemp = re.split(':', ltime)\\n year = btemp[0]\\n [mon, mdate] = tcnv.changeYdateToMonDate(int(year), int(btemp[1]))\\n lmon = tcnv.changeMonthFormat(mon)\\n line = lmon + ' ' + year \\n for j in range(1, len(atemp)):\\n line = line + '\\\\t' + atemp[j]\\n\\n line = line + '\\\\n'\\n fo.write(line)\\n fo.close()\",\n \"def get_clk_spr_df(self) -> pd.DataFrame:\\n return pd.read_feather(self.figure_data_paths.clk_spr_path)\",\n \"def create_query_csv(self):\\n\\n self.query_df.to_csv(self.query_output_file)\",\n \"def print_mod_factors_csv(df: pd.DataFrame):\\n delimiter = ';'\\n\\n file_path = os.path.join(os.getcwd(), 'modelfactors.csv')\\n with open(file_path, 'w') as output:\\n for columnname, data in df.iteritems():\\n line = f\\\"{columnname}\\\"\\n for value in data:\\n try:\\n line += delimiter + '{0:.{prec}f}'.format(value, prec=__DECIMAL_PRECISION)\\n except ValueError:\\n line += '{}'.format(value)\\n output.write(line + '\\\\n')\\n if columnname == MOD_FACTORS_DOC['freq']:\\n output.write(\\\"#\\\\n\\\")\\n print(f'==INFO== Modelfactors written into {file_path}')\",\n \"def export_tc_to_csv(self, xs, xe, ys, ye, dt=0.1):\\n df = self.norm_stack[xs:xe, ys:ye, :]\\n df_avg = df.mean((0, 1))\\n df_std = df.std((0, 1))\\n s_path = self.path.parent / (self.path.stem + '_timecourse.csv')\\n save_path = self.get_file(s_path, 'csv')\\n np.savetxt(save_path,\\n np.vstack((np.arange(1, df_avg.shape[0]+1, dtype=np.intp), df_avg, df_std)).T,\\n [\\\"%d\\\", \\\"%.4f\\\", \\\"%.4f\\\"], delimiter=\\\",\\\", header='frame, average, std')\\n return save_path\",\n \"def _output_performance(self):\\n self.portfolio.create_equity_curve_dataframe()\\n\\n print(\\\"Creating summary statistics...\\\")\\n stats = self.portfolio.output_summary_stats()\\n\\n print(\\\"Creating equity curve...\\\")\\n print(self.portfolio.equity_curve.tail(10))\\n pprint.pprint(stats)\\n\\n print(\\\"Signals: %s\\\" % self.signals)\\n print(\\\"Orders: %s\\\" % self.orders)\\n print(\\\"Fills: %s\\\" % self.fills)\",\n \"def _cmd_export_cdt(args):\\n sample_ids = list(map(core.fbase, args.filenames))\\n table = export.merge_samples(args.filenames)\\n formatter = export.EXPORT_FORMATS[\\\"cdt\\\"]\\n outheader, outrows = formatter(sample_ids, table)\\n write_tsv(args.output, outrows, colnames=outheader)\",\n \"def write_to_csv(self, log_dir, run_dir, hmc=False):\\n _, run_str = os.path.split(run_dir)\\n avg_data = {\\n 'log_dir': log_dir,\\n 'run_dir': run_str,\\n 'hmc': hmc,\\n }\\n\\n for key, val in dict(sorted(self.data.items())).items():\\n tensor = tf.convert_to_tensor(val)\\n arr, steps = therm_arr(tensor.numpy(), therm_frac=0.2)\\n if 'steps' not in avg_data:\\n avg_data['steps'] = len(steps)\\n avg_data[key] = np.mean(arr)\\n\\n # avg_data[key] = tf.reduce_mean(arr)\\n\\n avg_df = pd.DataFrame(avg_data, index=[0])\\n outdir = os.path.join(BASE_DIR, 'logs', 'GaugeModel_logs')\\n csv_file = os.path.join(outdir, 'inference.csv')\\n head, tail = os.path.split(csv_file)\\n io.check_else_make_dir(head)\\n io.log(f'Appending inference results to {csv_file}.')\\n if not os.path.isfile(csv_file):\\n avg_df.to_csv(csv_file, header=True, index=False, mode='w')\\n else:\\n avg_df.to_csv(csv_file, header=False, index=False, mode='a')\",\n \"def make_time_series(rics: list, fields: list, start_date: str, end_date: str, name: str) -> None:\\n df = get_time_series(rics, fields, start_date, end_date)\\n df.dropna(inplace=True)\\n to_csv(df, name, time_series=True)\",\n \"def write_plot(self):\\n with open(self._graph_data_path, \\\"w+\\\") as f:\\n run_time = self.start_time\\n f.write(\\\"Time, Temperature\\\\n\\\")\\n temperature = 0\\n for step in self.profile[\\\"steps\\\"]:\\n keys = list(step)\\n if len(keys) > 0:\\n if keys[0] == \\\"start\\\":\\n temperature = step[\\\"start\\\"]\\n if keys[0] == \\\"rest\\\":\\n run_time += timedelta(minutes = step[\\\"rest\\\"])\\n if keys[0] == \\\"ramp\\\":\\n run_time += timedelta(minutes = step[\\\"ramp\\\"])\\n temperature = step[\\\"to\\\"]\\n if keys[0] == \\\"mashout\\\":\\n temperature = step[\\\"mashout\\\"]\\n time = run_time.strftime(\\\"%H:%M:%S, \\\")\\n f.write(time + str(temperature) + \\\"\\\\n\\\")\\n run_time += timedelta(minutes = 10)\\n if keys[0] == \\\"jump\\\":\\n temperature = step[\\\"jump\\\"]\\n\\n time = run_time.strftime(\\\"%H:%M:%S, \\\")\\n f.write(time + str(temperature) + \\\"\\\\n\\\")\\n else:\\n logger.error(\\\"Can't make sense of \\\" + str(step))\",\n \"def compile_data():\\r\\n with open('sp500_tickers.pickle', 'rb') as file:\\r\\n tickers = pickle.load(file)\\r\\n metasp = pd.DataFrame()\\r\\n for count, ticker in enumerate(tickers):\\r\\n df = pd.read_csv('sp500_data\\\\{}.csv'.format(ticker))\\r\\n df.set_index('Date', inplace=True)\\r\\n df.rename(columns={'Adj Close': ticker}, inplace=True)\\r\\n df.drop(['Open', 'High', 'Low', 'Close', 'Volume'], 1, inplace=True)\\r\\n if metasp.empty:\\r\\n metasp = df\\r\\n else:\\r\\n metasp = metasp.join(df, how = 'outer')\\r\\n if count % 10 == 0:\\r\\n print(count)\\r\\n metasp.to_csv('sp500_meta.csv')\",\n \"def generate_day_header():\\n cf = config.Config()\\n outstr = \\\"total_rotation,total_acceleration,total_distance,number_missing,\\\"\\n outstr += \\\"oc1_time,oc2_time,oc3_time,oc4_time,oc5_time,oc6_time,oc7_time,\\\"\\n outstr += \\\"oc8_time,oc9_time,oc10_time,oc11_time,oc12_time,oc13_time,\\\"\\n outstr += \\\"oc14_time,oc15_time,oc16_time,oc17_time,oc18_time,oc19_time,\\\"\\n outstr += \\\"oc20_time,oc21_time,oc22_time,oc23_time,oc24_time,oc25_time,\\\"\\n outstr += \\\"oc26_time,oc27_time,oc28_time,oc29_time,oc30_time,oc31_time,\\\"\\n outstr += \\\"oc32_time,oc33_time,\\\"\\n anames = cf.activity_list\\n for i in range(len(anames)):\\n outstr += anames[i] + \\\"_time,\\\"\\n outstr += \\\"oc1_first,oc2_first,\\\"\\n outstr += \\\"oc3_first,oc4_first,oc5_first,oc6_first,oc7_first,oc8_first,\\\"\\n outstr += \\\"oc9_first,oc10_first,oc11_first,oc12_first,oc13_first,\\\"\\n outstr += \\\"oc14_first,oc15_first,oc16_first,oc17_first,oc18_first,\\\"\\n outstr += \\\"oc19_first,oc20_first,oc21_first,oc22_first,oc23_first,\\\"\\n outstr += \\\"oc24_first,oc25_first,oc26_first,oc27_first,oc28_first,\\\"\\n outstr += \\\"oc29_first,oc30_first,oc31_first,oc32_first,oc33_first,\\\"\\n for i in range(len(anames)):\\n outstr += anames[i] + \\\"_first,\\\"\\n outstr += \\\"attraction_time,house_time,restaurant_time,\\\"\\n outstr += \\\"road_time,service_time,store_time,work_time,other_time,\\\"\\n outstr += \\\"attraction_first,house_first,restaurant_first,road_first,\\\"\\n outstr += \\\"service_first,store_first,work_first,other_first\\\"\\n return outstr\",\n \"def create_csv_runtime(analysis, paths, csv_parameters):\\n\\n run_times = analysis.get_runtimes(paths)\\n runs = max(run_times.keys()) + 1\\n\\n output_csv_runtime = csv_parameters\\n runtimes = ['Runtimes']\\n for run in range(runs):\\n runtimes.append(run_times[run])\\n output_csv_runtime.append(runtimes)\\n\\n return output_csv_runtime\",\n \"def outputFunc(filename, parks,roading,private):\\n #assert len(parks) == 3\\n \\n f = open(filename, 'wt')\\n \\n try:\\n writer = csv.writer(f)\\n writer.writerow(days)\\n writer.writerow(parks)\\n writer.writerow(roading)\\n writer.writerow(private)\\n finally:\\n f.close()\",\n \"def run():\\n\\twrite_fuel_data()\",\n \"def csv(self):\\n return '{:.6f},{},{}'.format(self.sample_time, self.value, self.status)\",\n \"def process_iteration_result(self, result, context):\\n self.infile = os.path.join(context.output_directory, 'trace.txt')\\n if os.path.isfile(self.infile):\\n self.logger.debug('Running result_processor \\\"dvfs\\\"')\\n self.outfile = os.path.join(settings.output_directory, 'dvfs.csv')\\n self.flush_parse_initialize()\\n self.calculate()\\n self.percentage()\\n self.generate_csv(context)\\n self.logger.debug('Completed result_processor \\\"dvfs\\\"')\\n else:\\n self.logger.debug('trace.txt not found.')\",\n \"def read_cospectrum(path,d):\\r\\n spec = []\\r\\n timeseries = []\\r\\n for i in range(len(d)):\\r\\n filename = path + d[i]\\r\\n\\r\\n with open(filename, \\\"r\\\") as f:\\r\\n reader = csv.reader(f,delimiter=',')\\r\\n ct=1\\r\\n for row in reader:\\r\\n if ct==6:\\r\\n Hz = float(row[0].split('_')[-1])\\r\\n elif ct==7:\\r\\n height = float(row[0].split('_')[-1])\\r\\n elif ct==8:\\r\\n ws = float(row[0].split('_')[-1])\\r\\n elif ct==9:\\r\\n avg_period = float(row[0].split('_')[-1])\\r\\n elif ct==13:\\r\\n header = row\\r\\n elif ct>13:\\r\\n break\\r\\n ct+=1\\r\\n \\r\\n meta = [Hz,height,ws,avg_period]\\r\\n \\r\\n thisspec = np.genfromtxt(filename,delimiter=',',skip_header=13)\\r\\n spec.append(thisspec)\\r\\n thistime = re.findall('\\\\d{8}-\\\\d{4}',filename)[0]\\r\\n thisdate = datetime.strptime(thistime,'%Y%m%d-%H%M')\\r\\n timeseries.append(thisdate) \\r\\n \\r\\n return spec, timeseries, header, meta\",\n \"def _output_performance(self):\\n self.portfolio.create_equity_curve_dataframe()\\n \\n print(\\\"Creating summary statistics...\\\")\\n stats = self.portfolio.output_summary_stats()\\n \\n print(\\\"Creating equity curve...\\\")\\n print(self.portfolio.equity_curve.tail(10))\\n pprint.pprint(stats)\\n \\n print(\\\"Signals: %s\\\" % self.signals)\\n print(\\\"Orders: %s\\\" % self.orders)\\n print(\\\"Fills: %s\\\" % self.fills)\",\n \"def create_csv(self):\\n try:\\n # Convert List of Lists to DataFrame and write it to a CSV\\n pd.DataFrame(self.data, columns=self.header) \\\\\\n .to_csv(os.path.join(self.file_path, self.file_name), index=False)\\n self.successful_run = True\\n except:\\n # TODO create Exception Handling\\n raise\",\n \"def output_daily_files(dataframe, path, filename):\\n\\n days = dataframe.groupby('date_time_day')\\n dataframe.groupby('date_time_day').size().reset_index(name='data points per day')\\n\\n for day in days.groups:\\n print(day.date())\\n output_path = path + filename + \\\"_\\\" + str(day.date()) + '.csv'\\n print(\\\"Creating intermediate flagged data file: \\\", output_path)\\n days.get_group(day).to_csv(output_path, index=False)\",\n \"def generate(start_date, episodes, steps, output_file):\\n header = ','.join(FIELDS) + '\\\\n'\\n with open(output_file, 'w') as fd:\\n fd.write(header)\\n data_arrays = []\\n first_dp = generate_data_point(start_date)\\n data_arrays.append(first_dp)\\n\\n interval = int(1440/steps)\\n cur_ts = increment_ts(start_date, interval)\\n\\n while step_diff(start_date, cur_ts, interval) < steps*episodes:\\n dp_tmp = generate_data_point(cur_ts)\\n data_arrays.append(dp_tmp)\\n cur_ts = increment_ts(cur_ts, interval)\\n\\n for dp in data_arrays:\\n row = ','.join(dp) + '\\\\n'\\n fd.write(row)\",\n \"def download_multimonth_csv(out_dir, year_start, month_start, year_end, month_end, station, product='water_level', datum='STND', time_zone='GMT'):\\n\\n # add trailing slash to directory name, if necessary\\n if out_dir[-1] is not ('/' or '\\\\\\\\'):\\n out_dir = out_dir+'/'\\n\\n # create directory if necessary\\n if not os.path.isdir(out_dir):\\n os.mkdir(out_dir)\\n\\n file_prefix = station+'_'+product+'_'\\n\\n years = range(int(year_start),int(year_end)+1)\\n\\n for year in years:\\n if year == years[0]:\\n mon_range = range(month_start,13)\\n elif year == years[-1]:\\n mon_range = range(1,month_end+1)\\n else:\\n mon_range = range(1,13)\\n\\n for mon in mon_range:\\n mon_str = str(mon).zfill(2)\\n\\n # file to write\\n filename = file_prefix+str(year)+mon_str+'.csv'\\n out_file = os.path.join(out_dir,filename)\\n\\n # determine number of days in month\\n ndays = monthrange(year, mon)[1]\\n ndays_str = str(ndays).zfill(2)\\n\\n begin_date = str(year)+mon_str+'01'\\n end_date = str(year)+mon_str+ndays_str\\n\\n download_6min_csv(out_file, begin_date, end_date, station, product, datum, time_zone)\",\n \"def create_csvfile(options_path, recept_info,df):\\n df_csv = df.copy()\\n df_csv.index.names = ['Interacting positions']\\n\\n #Change dynX by full name of receptor, adding the dynid if there is more than a simulation for that receptor\\n df_csv.columns = df_csv.columns.map(lambda x: recept_info[x][13])\\n\\n #Sorting by ballesteros Id's (helixloop column) and clustering order\\n df_csv['Interacting positions'] = df_csv.index\\n df_csv['helixloop'] = df_csv['Interacting positions'].apply(lambda x: re.sub(r'^(\\\\d)x',r'\\\\g<1>0x',x)) \\n df_csv = df_csv.sort_values([\\\"helixloop\\\"])\\n\\n #Change jumplines by 'x' to avoid formatting problems\\n def new_index(cell):\\n cell = cell.replace('\\\\n\\\\n', ' ')\\n cell = cell.replace('\\\\n', 'x')\\n cell = cell.replace('xx', 'x')\\n return cell\\n\\n df_csv['Interacting positions'] = df_csv['Interacting positions'].apply(lambda x: new_index(x))\\n df_csv.index = df_csv['Interacting positions']\\n\\n #Drop columns\\n df_csv.drop(columns = ['helixloop','Interacting positions'], inplace = True)\\n\\n #Store dataframe as csv\\n df_csv.to_csv(path_or_buf = options_path+\\\"dataframe.csv\\\", float_format='%.1f')\",\n \"def serdes_dump_state(fpgaid,verbose=1):\\n lines=[]\\n\\n lines.append(\\\"Group : AEQ\\\")\\n lines.append(\\\" Logic Channel : %d\\\" % reconfig_AEQ_get_logical_channel_address(fpgaid,verbose))\\n lines.append(\\\" adapt_done : %d\\\" % reconfig_AEQ_get_adapt_done(fpgaid,verbose))\\n lines.append(\\\" equalization_results : %d\\\" % reconfig_AEQ_get_equalization_results(fpgaid,verbose))\\n lines.append(\\\" mode : %d\\\" % reconfig_AEQ_get_mode(fpgaid,verbose))\\n lines.append(\\\"Group : DFE\\\")\\n lines.append(\\\" Logic Channel : %d\\\" % reconfig_DFE_get_logical_channel_address(fpgaid,verbose))\\n lines.append(\\\" adaptation_engine_enable : %d\\\" % reconfig_DFE_get_adaptation_engine_enable(fpgaid,verbose))\\n lines.append(\\\" power_on : %d\\\" % reconfig_DFE_get_power_on(fpgaid,verbose))\\n lines.append(\\\" tap_1 : %d\\\" % reconfig_DFE_get_tap_1(fpgaid,verbose))\\n lines.append(\\\" tap_2 : %d\\\" % reconfig_DFE_get_tap_2(fpgaid,verbose))\\n lines.append(\\\" tap_2_polarity : %d\\\" % reconfig_DFE_get_tap_2_polarity(fpgaid,verbose))\\n lines.append(\\\" tap_3 : %d\\\" % reconfig_DFE_get_tap_3(fpgaid,verbose))\\n lines.append(\\\" tap_3_polarity : %d\\\" % reconfig_DFE_get_tap_3_polarity(fpgaid,verbose))\\n lines.append(\\\" tap_4 : %d\\\" % reconfig_DFE_get_tap_4(fpgaid,verbose))\\n lines.append(\\\" tap_4_polarity : %d\\\" % reconfig_DFE_get_tap_4_polarity(fpgaid,verbose))\\n lines.append(\\\" tap_5 : %d\\\" % reconfig_DFE_get_tap_5(fpgaid,verbose))\\n lines.append(\\\" tap_5_polarity : %d\\\" % reconfig_DFE_get_tap_5_polarity(fpgaid,verbose))\\n lines.append(\\\"Group : EyeQ\\\")\\n lines.append(\\\" Logic Channel : %d\\\" % reconfig_EyeQ_get_logical_channel_address(fpgaid,verbose))\\n lines.append(\\\" 1D_Eye : %d\\\" % reconfig_EyeQ_get_1D_Eye(fpgaid,verbose))\\n lines.append(\\\" BERB_Enable : %d\\\" % reconfig_EyeQ_get_BERB_Enable(fpgaid,verbose))\\n lines.append(\\\" BERB_Snap_Shot_and_Reset : %d\\\" % reconfig_EyeQ_get_BERB_Snap_Shot_and_Reset(fpgaid,verbose))\\n lines.append(\\\" Bit_Counter31_0 : %d\\\" % reconfig_EyeQ_get_Bit_Counter31_0(fpgaid,verbose))\\n lines.append(\\\" Bit_Counter63_32 : %d\\\" % reconfig_EyeQ_get_Bit_Counter63_32(fpgaid,verbose))\\n lines.append(\\\" Counter_Enable : %d\\\" % reconfig_EyeQ_get_Counter_Enable(fpgaid,verbose))\\n lines.append(\\\" Enable_Eye_Monitor : %d\\\" % reconfig_EyeQ_get_Enable_Eye_Monitor(fpgaid,verbose))\\n lines.append(\\\" Err_Conter63_32 : %d\\\" % reconfig_EyeQ_get_Err_Conter63_32(fpgaid,verbose))\\n lines.append(\\\" Err_Counter31_0 : %d\\\" % reconfig_EyeQ_get_Err_Counter31_0(fpgaid,verbose))\\n lines.append(\\\" Horizontal_phase : %d\\\" % reconfig_EyeQ_get_Horizontal_phase(fpgaid,verbose))\\n lines.append(\\\" Polarity : %d\\\" % reconfig_EyeQ_get_Polarity(fpgaid,verbose))\\n lines.append(\\\" Vertical_height : %d\\\" % reconfig_EyeQ_get_Vertical_height(fpgaid,verbose))\\n lines.append(\\\"Group : PMA\\\")\\n lines.append(\\\" Logic Channel : %d\\\" % reconfig_PMA_get_logical_channel_address(fpgaid,verbose))\\n lines.append(\\\" Pre_emphasis_first_post_tap : %d\\\" % reconfig_PMA_get_Pre_emphasis_first_post_tap(fpgaid,verbose))\\n lines.append(\\\" Pre_emphasis_pre_tap : %d\\\" % tapformat(reconfig_PMA_get_Pre_emphasis_pre_tap(fpgaid,verbose)))\\n lines.append(\\\" Pre_emphasis_second_post_tap : %d\\\" % tapformat(reconfig_PMA_get_Pre_emphasis_second_post_tap(fpgaid,verbose)))\\n lines.append(\\\" RX_equalization_control : %d\\\" % reconfig_PMA_get_RX_equalization_control(fpgaid,verbose))\\n lines.append(\\\" RX_equalization_DC_gain : %d\\\" % reconfig_PMA_get_RX_equalization_DC_gain(fpgaid,verbose))\\n lines.append(\\\" VOD : %d\\\" % reconfig_PMA_get_VOD(fpgaid,verbose))\\n print \\\"\\\\n\\\".join(lines)\\n return lines\",\n \"def write_fenth_out4fp(fname,dH,vol):\\n with open(fname,'w') as f:\\n cmd = ' '.join(s for s in sys.argv)\\n f.write('# Output at {0:s} from,\\\\n'.format(datetime.now().strftime('%Y-%m-%d %H:%M:%S')))\\n f.write('# {0:s}\\\\n'.format(cmd))\\n #...Num of data, weight for the data\\n f.write(' {0:6d} {1:7.3f}\\\\n'.format(2, 1.0))\\n f.write(' {0:8.3f} {1:8.3f}\\\\n'.format(dH,vol))\\n return None\",\n \"def get_meter_list():\\n f = sorted(os.listdir(OUT_METER))[-1]\\n df = pd.read_csv(os.path.join(OUT_METER, f))\\n return df\",\n \"def write_output_csv(filename, **kwargs):\\n import csv\\n import time\\n\\n intermediate = kwargs.pop(\\\"intermediate\\\", False)\\n\\n keys = sorted(kwargs.keys())\\n num_vars = len(keys)\\n\\n if intermediate:\\n full_filename = filename + \\\"_interm\\\"\\n else:\\n dot_index = filename.rfind('.')\\n if dot_index != -1:\\n full_filename = (filename[:dot_index]\\n + time.strftime(\\\"%Y-%m-%d-%H.%M.%S\\\")\\n + filename[dot_index:])\\n else:\\n full_filename = filename + time.strftime(\\\"%Y-%m-%d-%H.%M.%S\\\")\\n\\n # add current time to filename as an identifier\\n with open(full_filename, 'w', newline='') as csvfile:\\n\\n writer = csv.writer(csvfile)\\n\\n # write header\\n writer.writerow(keys)\\n\\n num_entries = len(kwargs[keys[0]])\\n for i in range(num_entries):\\n writer.writerow(kwargs[keys[j]][i] for j in range(num_vars))\",\n \"def csv(self):\\n return '{:.6f},{:.6f},{},{}'.format(\\n self.sample_time, self.value_time, self.value, self.status)\",\n \"def gen_final_df(res_fname, dat_sel, dname):\\n res_file = open(res_fname, \\\"r\\\")\\n rdict = {}\\n pdict = {}\\n for p in res_file:\\n i, c, g, rate = p.split(\\\",\\\")\\n rdict[i] = rate\\n pdict[i] = [c, g]\\n res_file.close()\\n\\n opti_feat = min([key for key in rdict.keys() if rdict[key] == max(rdict.values())])\\n opti_c, opti_g = pdict[opti_feat][0], pdict[opti_feat][1]\\n opti_df = df_transformer(dat_sel, opti_feat)\\n opti_df = opti_df.replace(to_replace=-1, value=2)\\n opti_df.to_csv(dname+\\\".res\\\", sep=\\\" \\\", header=None, index=None)\\n return dname+\\\".res\\\", opti_c, opti_g\",\n \"def _read_trajectory_files(self):\\n dflist = []\\n self.Ntimes = {}\\n for downD in self.case.downstreamD:\\n outputs = self.case.get_outputs(self.method,downD)\\n print(outputs['trajectory_file'])\\n df = pd.read_csv(outputs['trajectory_file'],\\n header=None,\\n usecols=[0,1,2])\\n df.columns = ['t','y','z']\\n df['x'] = downD * self.case.turbine.D\\n df['z'] -= self.case.turbine.zhub\\n df = df.set_index(['t','x'])[['y','z']]\\n self.Ntimes[downD] = len(df.index.levels[0])\\n dflist.append(df)\\n self.df = pd.concat(dflist).sort_index()\",\n \"def dump_lots(args: argparse.Namespace) -> None:\\n engine = create_engine()\\n dump_csv(\\n engine,\\n dtstart=args.dtstart,\\n dtend=args.dtend,\\n dtstart_gains=datetime.max,\\n consolidate=args.consolidate,\\n lotloadfile=args.loadcsv,\\n lotdumpfile=args.file,\\n )\",\n \"def write_stats(self):\\n with open(self.log_file,'a') as output:\\n writer = csv.writer(output)\\n n_comps,comp_size = self.connected_component() # Calculate number of connected components (sub-colonies)\\n writer.writerow([self.pop_size,\\n self.get_average_age(),\\n self.get_average_survival(),\\n # Nearest neighbor logging disabled for speed\\n # Use c++ tool to calculate nearest neighbors after runs\\n # or uncomment line below to calculate in python (slower)\\n # self.get_average_repro()] + [self.get_average_neighbors(r) for r in range(0,16)] +\\n self.get_average_repro()] +\\n [n_comps,\\\",\\\".join(map(str,comp_size))])\",\n \"def create_main_csv(data_list):\\n path = \\\"camelot/clean/CWC_National-Register-of-Large-Dams_2019.csv\\\"\\n if not os.path.exists(\\\"camelot/clean\\\"):\\n os.makedirs(\\\"camelot/clean\\\")\\n data_concat = pd.concat(data_list)\\n data_concat.reset_index(drop=True).to_csv(path, index=True)\",\n \"def gatherStationData():\\n flist = list_files()\\n station_dics = {}\\n print(\\\"Reading in csv data...\\\")\\n for f_in in flist:\\n start,end = find_timespan(f_in)\\n station = station_name(f=f_in)\\n print(\\\"File: {0} Station: {1} {2}--{3}\\\".format(f_in, \\n station, start, end))\\n station_dics[station] = read_precip(fname=f_in, \\n label=station, start_year=start, end_year=end)\\n data_list = []\\n for s in station_dics:\\n data_list.append(station_dics[s]) \\n return pd.concat(data_list,axis=1)\",\n \"def output_wait_time_cdf(self):\\r\\n results_dirname = get_param(\\\"results_dir\\\")\\r\\n job_filename = os.path.join(results_dirname, \\\"%s_job_wait_cdf\\\" %\\r\\n get_param(\\\"file_prefix\\\"))\\r\\n job_file = open(job_filename, \\\"w\\\")\\r\\n task_filename = os.path.join(results_dirname, \\\"%s_task_wait_cdf\\\" %\\r\\n get_param(\\\"file_prefix\\\"))\\r\\n task_file = open(task_filename, \\\"w\\\")\\r\\n \\r\\n # Dictionary mapping loads (as returned by probes) to a list of wait\\r\\n # times for the corresponding tasks.\\r\\n wait_times_per_load = {}\\r\\n # Wait times for the last task in each job.\\r\\n longest_wait_times_per_load = {}\\r\\n for job in self.completed_jobs:\\r\\n longest_task_wait = -1\\r\\n longest_task_load = -1\\r\\n for task_id in range(job.num_tasks):\\r\\n load = job.probe_results[task_id]\\r\\n wait = job.wait_times[task_id]\\r\\n if wait > longest_task_wait:\\r\\n longest_task_wait = wait\\r\\n longest_task_load = load\\r\\n if load not in wait_times_per_load:\\r\\n wait_times_per_load[load] = []\\r\\n wait_times_per_load[load].append(wait)\\r\\n if longest_task_load not in longest_wait_times_per_load:\\r\\n longest_wait_times_per_load[longest_task_load] = []\\r\\n longest_wait_times_per_load[longest_task_load].append(\\r\\n longest_task_wait)\\r\\n \\r\\n task_file.write(\\\"Percentile\\\\t\\\")\\r\\n job_file.write(\\\"Percentile\\\\t\\\")\\r\\n for load in sorted(wait_times_per_load.keys()):\\r\\n wait_times_per_load[load].sort()\\r\\n task_file.write(\\\"%f(%d)\\\\t\\\" %\\r\\n (load, len(wait_times_per_load[load])))\\r\\n task_file.write(\\\"\\\\n\\\")\\r\\n for load in sorted(longest_wait_times_per_load.keys()):\\r\\n longest_wait_times_per_load[load].sort()\\r\\n job_file.write(\\\"%f(%d)\\\\t\\\" %\\r\\n (load, len(longest_wait_times_per_load[load])))\\r\\n job_file.write(\\\"\\\\n\\\")\\r\\n\\r\\n percentile_granularity = 200\\r\\n for i in range(percentile_granularity):\\r\\n percentile = float(i) / percentile_granularity\\r\\n job_file.write(\\\"%f\\\" % percentile)\\r\\n task_file.write(\\\"%f\\\" % percentile)\\r\\n for load in sorted(longest_wait_times_per_load.keys()):\\r\\n job_file.write(\\\"\\\\t%f\\\" % self.percentile(\\r\\n longest_wait_times_per_load[load], percentile))\\r\\n job_file.write(\\\"\\\\n\\\")\\r\\n for load in sorted(wait_times_per_load.keys()):\\r\\n task_file.write(\\\"\\\\t%f\\\" %\\r\\n self.percentile(wait_times_per_load[load],\\r\\n percentile))\\r\\n task_file.write(\\\"\\\\n\\\")\\r\\n job_file.close()\",\n \"def process(self, inputs):\\n df = cudf.read_csv(self.conf['path'])\\n # extract the year, month, day\\n ymd = df['DTE'].astype('str').str.extract(r'(\\\\d\\\\d\\\\d\\\\d)(\\\\d\\\\d)(\\\\d\\\\d)')\\n # construct the standard datetime str\\n df['DTE'] = ymd[0].str.cat(ymd[1],\\n '-').str.cat(ymd[2],\\n '-').astype('datetime64[ms]')\\n df = df[['DTE', 'OPEN', 'CLOSE', 'HIGH', 'LOW', 'SM_ID', 'VOLUME']]\\n df['VOLUME'] /= 1000\\n # change the names\\n df.columns = ['datetime', 'open', 'close',\\n 'high', 'low', \\\"asset\\\", 'volume']\\n return df\",\n \"def print(self):\\n print(\\\"-----\\\", self.name, \\\"-----\\\")\\n print(\\\"Enable index\\\", self.enable_index)\\n print(\\\"End index:\\\", self.stop_index)\\n print(\\\"Measurement length (from the very beginning to the end index):\\\", self.time_vec[self.stop_index])\\n print()\\n print(\\\"Start temperature (hot):\\\", self.temp_hot_start)\\n print(\\\"Start temperature (cold):\\\", self.temp_cold_start)\\n print(\\\"Start temperature (mean):\\\", self.temp_start)\\n print(\\\"End temperature (hot):\\\", self.temp_hot[self.stop_index])\\n print(\\\"End temperature (cold)\\\", self.temp_cold[self.stop_index])\\n print()\\n print(\\\"Max temperature\\\", self.temp_max)\\n print(\\\"Min temperature\\\", self.temp_min)\\n print()\\n print(\\\"Heat pump\\\")\\n print(\\\"Energy input:\\\", self.work_inp)\\n print(\\\"Q_hot\\\", self.qhot_pump)\\n print(\\\"Q_cold\\\", self.qcold_pump)\\n print(\\\"Q_cold + W\\\", self.qcold_pump + self.work_inp)\\n print(\\\"E_lost\\\", self.qcold_pump + self.work_inp - self.qhot_pump)\\n print(\\\"Coefficient of performance COP_hot\\\", self.qhot_pump / self.work_inp)\\n print(\\\"Coefficient of performance COP_cold\\\", self.qcold_pump / self.work_inp)\\n print(\\\"Ideal COP_hot with the setup\\\", self.qhot_pump/(self.qhot_pump-self.qcold_pump))\\n print(\\\"Ideal COP_cold with the setup\\\", self.qcold_pump / (self.qhot_pump - self.qcold_pump))\\n print(\\\"Ideal Carnot COP_hot\\\", (self.temp_max+273.15)/(self.temp_max-self.temp_min))\\n print(\\\"Ideal Carnot COP_cold\\\", (self.temp_min+273.15)/(self.temp_max-self.temp_min))\\n print(\\\"Efficiency fraction out of ideal Carnot cooler\\\", (self.qcold_pump / self.work_inp)/((self.temp_min+273.15)/(self.temp_max-self.temp_min)))\\n\\n if self.not_air:\\n print(\\\"Heat transfer through insulator, hot side\\\", self.heat_loss_pump_hot)\\n print(\\\"Heat transfer through insulator, cold side\\\", self.heat_loss_pump_cold)\\n print(\\\"Estimated Q_hot with resistor\\\", self.qhot_resistor)\\n else:\\n print(\\\"Estimated Q_hot with resistor (=energy input)\\\", self.qhot_resistor)\\n #\\n # I think it should be defined for Q_hot too. Yep, TODO that\\n # Also calculate heatloss due to conduction TODO remove these comments when ready\\n # Todo implement resistive heater calculations\\n print()\\n print(\\\"Heat engine\\\")\\n print(\\\"Energy generated:\\\", self.work_gen)\\n print(\\\"Q_hot\\\", self.qhot_engine)\\n print(\\\"Q_cold\\\", self.qcold_engine)\\n print(\\\"Q_hot - Q_cold\\\", self.qhot_engine - self.qcold_engine)\\n print(\\\"E_lost\\\", -self.qcold_engine - self.work_gen + self.qhot_engine)\\n print(\\\"\\\\\\\"Heat transfer efficiency\\\\\\\" (%)\\\", self.work_gen / (self.qhot_engine - self.qcold_engine) * 100)\\n print(\\\"Efficiency e\\\", self.work_gen / self.qhot_engine)\\n print(\\\"Ideal efficiency with the setup\\\", 1 - (self.qcold_engine / self.qhot_engine))\\n print(\\\"Ideal Carnot efficiency\\\", (self.temp_max-self.temp_min)/(self.temp_max+273.15))\\n if self.not_air:\\n print(\\\"Heat transfer through insulator, hot side\\\", self.heat_loss_gen_hot)\\n print(\\\"Heat transfer through insulator, cold side\\\", self.heat_loss_gen_cold)\\n print()\\n print(\\\"Total efficiency of cycle\\\", self.work_gen/self.work_inp)\\n # About the efficiency of peltier elements (#telok@IRCnet, 2016-07-27)\\n # 19:10 < AgenttiX> Oletteko kokeilleet TECin ohjaamista Arduinolla? Toimisiko tämä kytkentä? http://garagelab.com/profiles/blogs/how-to-use-a-peltier-with-arduino\\n # --\\n # 20:21 <@hrst> Ei toimi. Peltieriä ei voi ohjata PWM:llä.\\n # 20:22 <@hrst> Hyötysuhde on PWM:llä paska, mikä on ongelma koska se on muutenkin liian paska, ja sen lisäksi se hajoaa mekaaniseen värähtelyyn ennemmin tai myöhemmin.\\n print(\\\"-----\\\\n\\\")\",\n \"def __init__(self):\\n super().__init__()\\n self.dmdParams = {} # dmd settings container\\n self.printTag = 'DMD' # print tag\\n self._dynamicHandling = True # This ROM is able to manage the time-series on its own. No need for special treatment outside\\n self.pivotParameterID = None # pivot parameter\\n # variables filled up in the training stages\\n self._amplitudes = {} # {'target1': vector of amplitudes,'target2':vector of amplitudes, etc.}\\n self._eigs = {} # {'target1': vector of eigenvalues,'target2':vector of eigenvalues, etc.}\\n self._modes = {} # {'target1': matrix of dynamic modes,'target2':matrix of dynamic modes, etc.}\\n self.__Atilde = {} # {'target1': matrix of lowrank operator from the SVD,'target2':matrix of lowrank operator from the SVD, etc.}\\n self.pivotValues = None # pivot values (e.g. time)\\n self.KDTreeFinder = None # kdtree weighting model\\n self.timeScales = {} # time-scales (training and dmd). {'training' and 'dmd':{t0:float,'dt':float,'intervals':int}}\\n self.featureVals = None # feature values\",\n \"def file_output(output_directory, distance, relative_dose, scan_curvetype, scan_depth):\\n # Determines the filepaths for the output\\n filepaths = determine_output_filepaths(output_directory, scan_curvetype, scan_depth)\\n\\n columns = [\\\"distance (mm)\\\", \\\"relative dose\\\"]\\n\\n # Loop over each curvetype and save the data to csv\\n for i, _ in enumerate(scan_curvetype):\\n # Stacks the data into one array and transposes into column orientation\\n data = np.vstack([distance[i], relative_dose[i]]).T\\n\\n # Use pandas to save data to csv\\n df = pd.DataFrame(data, columns=columns)\\n df.to_csv(filepaths[i])\",\n \"def execute(self, args: Namespace):\\n data = {}\\n\\n with open(args.data, 'r') as file:\\n reader = csv.reader(file, delimiter=';')\\n\\n for row in reader:\\n if reader.line_num == 1:\\n if 'Timestamp, Decimal, TriState, State' != ','.join(row):\\n print('Not a valid CSV file!')\\n return\\n\\n else:\\n dt = datetime.strptime(row[0], '%Y-%m-%d %H:%M:%S.%f')\\n value = tri_state_value(row[2])\\n device = data.setdefault(tri_state_device(row[2].strip()), {})\\n device.setdefault(dt.date(),[]).append((dt.strftime('%H:%M'), value))\\n\\n for k in sorted(data.keys()):\\n device = data[k]\\n print('Device {}:'.format(tint_yellow(k)))\\n\\n for d in sorted(device.keys()):\\n device[d].sort(key=lambda x: x[0])\\n print('\\\\t{}:'.format(tint_blue(d)))\\n\\n for (t, v) in device[d]:\\n if v:\\n print('\\\\t\\\\tAt {} the device was turned {}.'.format(tint_blue(t),\\n tint_green('ON')))\\n else:\\n print('\\\\t\\\\tAt {} the device was turned {}.'.format(tint_blue(t),\\n tint_red('OFF')))\",\n \"def generate_device_tree(self, outdir: str) -> None:\\n\\n state = FdtState(addr_cells=2, size_cells=2, cpu_cells=1)\\n root = FdtNode(\\\"/\\\")\\n root.append(state.addrCellsProperty())\\n root.append(state.sizeCellsProperty())\\n root.appendCompatible([\\\"riscv-virtio\\\"])\\n\\n for mem_range in self.mem_ranges:\\n node = FdtNode(f\\\"memory@{int(mem_range.start):x}\\\")\\n node.append(FdtPropertyStrings(\\\"device_type\\\", [\\\"memory\\\"]))\\n node.append(\\n FdtPropertyWords(\\n \\\"reg\\\",\\n state.addrCells(mem_range.start)\\n + state.sizeCells(mem_range.size()),\\n )\\n )\\n root.append(node)\\n\\n # See Documentation/devicetree/bindings/riscv/cpus.txt for details.\\n cpus_node = FdtNode(\\\"cpus\\\")\\n cpus_state = FdtState(addr_cells=1, size_cells=0)\\n cpus_node.append(cpus_state.addrCellsProperty())\\n cpus_node.append(cpus_state.sizeCellsProperty())\\n # Used by the CLINT driver to set the timer frequency. Value taken from\\n # RISC-V kernel docs (Note: freedom-u540 is actually 1MHz)\\n cpus_node.append(FdtPropertyWords(\\\"timebase-frequency\\\", [100000000]))\\n\\n for i, core in enumerate(self.get_processor().get_cores()):\\n node = FdtNode(f\\\"cpu@{i}\\\")\\n node.append(FdtPropertyStrings(\\\"device_type\\\", \\\"cpu\\\"))\\n node.append(FdtPropertyWords(\\\"reg\\\", state.CPUAddrCells(i)))\\n node.append(FdtPropertyStrings(\\\"mmu-type\\\", \\\"riscv,sv48\\\"))\\n node.append(FdtPropertyStrings(\\\"status\\\", \\\"okay\\\"))\\n node.append(FdtPropertyStrings(\\\"riscv,isa\\\", \\\"rv64imafdc\\\"))\\n # TODO: Should probably get this from the core.\\n freq = self.clk_domain.clock[0].frequency\\n node.append(FdtPropertyWords(\\\"clock-frequency\\\", freq))\\n node.appendCompatible([\\\"riscv\\\"])\\n int_phandle = state.phandle(f\\\"cpu@{i}.int_state\\\")\\n node.appendPhandle(f\\\"cpu@{i}\\\")\\n\\n int_node = FdtNode(\\\"interrupt-controller\\\")\\n int_state = FdtState(interrupt_cells=1)\\n int_phandle = int_state.phandle(f\\\"cpu@{i}.int_state\\\")\\n int_node.append(int_state.interruptCellsProperty())\\n int_node.append(FdtProperty(\\\"interrupt-controller\\\"))\\n int_node.appendCompatible(\\\"riscv,cpu-intc\\\")\\n int_node.append(FdtPropertyWords(\\\"phandle\\\", [int_phandle]))\\n\\n node.append(int_node)\\n cpus_node.append(node)\\n\\n root.append(cpus_node)\\n\\n soc_node = FdtNode(\\\"soc\\\")\\n soc_state = FdtState(addr_cells=2, size_cells=2)\\n soc_node.append(soc_state.addrCellsProperty())\\n soc_node.append(soc_state.sizeCellsProperty())\\n soc_node.append(FdtProperty(\\\"ranges\\\"))\\n soc_node.appendCompatible([\\\"simple-bus\\\"])\\n\\n # CLINT node\\n clint = self.platform.clint\\n clint_node = clint.generateBasicPioDeviceNode(\\n soc_state, \\\"clint\\\", clint.pio_addr, clint.pio_size\\n )\\n int_extended = list()\\n for i, core in enumerate(self.get_processor().get_cores()):\\n phandle = soc_state.phandle(f\\\"cpu@{i}.int_state\\\")\\n int_extended.append(phandle)\\n int_extended.append(0x3)\\n int_extended.append(phandle)\\n int_extended.append(0x7)\\n clint_node.append(\\n FdtPropertyWords(\\\"interrupts-extended\\\", int_extended)\\n )\\n clint_node.appendCompatible([\\\"riscv,clint0\\\"])\\n soc_node.append(clint_node)\\n\\n # PLIC node\\n plic = self.platform.plic\\n plic_node = plic.generateBasicPioDeviceNode(\\n soc_state, \\\"plic\\\", plic.pio_addr, plic.pio_size\\n )\\n\\n int_state = FdtState(addr_cells=0, interrupt_cells=1)\\n plic_node.append(int_state.addrCellsProperty())\\n plic_node.append(int_state.interruptCellsProperty())\\n\\n phandle = int_state.phandle(plic)\\n plic_node.append(FdtPropertyWords(\\\"phandle\\\", [phandle]))\\n plic_node.append(FdtPropertyWords(\\\"riscv,ndev\\\", [plic.n_src - 1]))\\n\\n int_extended = list()\\n for i, core in enumerate(self.get_processor().get_cores()):\\n phandle = state.phandle(f\\\"cpu@{i}.int_state\\\")\\n int_extended.append(phandle)\\n int_extended.append(0xB)\\n int_extended.append(phandle)\\n int_extended.append(0x9)\\n\\n plic_node.append(FdtPropertyWords(\\\"interrupts-extended\\\", int_extended))\\n plic_node.append(FdtProperty(\\\"interrupt-controller\\\"))\\n plic_node.appendCompatible([\\\"riscv,plic0\\\"])\\n\\n soc_node.append(plic_node)\\n\\n # PCI\\n pci_state = FdtState(\\n addr_cells=3, size_cells=2, cpu_cells=1, interrupt_cells=1\\n )\\n pci_node = FdtNode(\\\"pci\\\")\\n\\n if int(self.platform.pci_host.conf_device_bits) == 8:\\n pci_node.appendCompatible(\\\"pci-host-cam-generic\\\")\\n elif int(self.platform.pci_host.conf_device_bits) == 12:\\n pci_node.appendCompatible(\\\"pci-host-ecam-generic\\\")\\n else:\\n m5.fatal(\\\"No compatibility string for the set conf_device_width\\\")\\n\\n pci_node.append(FdtPropertyStrings(\\\"device_type\\\", [\\\"pci\\\"]))\\n\\n # Cell sizes of child nodes/peripherals\\n pci_node.append(pci_state.addrCellsProperty())\\n pci_node.append(pci_state.sizeCellsProperty())\\n pci_node.append(pci_state.interruptCellsProperty())\\n # PCI address for CPU\\n pci_node.append(\\n FdtPropertyWords(\\n \\\"reg\\\",\\n soc_state.addrCells(self.platform.pci_host.conf_base)\\n + soc_state.sizeCells(self.platform.pci_host.conf_size),\\n )\\n )\\n\\n # Ranges mapping\\n # For now some of this is hard coded, because the PCI module does not\\n # have a proper full understanding of the memory map, but adapting the\\n # PCI module is beyond the scope of what I'm trying to do here.\\n # Values are taken from the ARM VExpress_GEM5_V1 platform.\\n ranges = []\\n # Pio address range\\n ranges += self.platform.pci_host.pciFdtAddr(space=1, addr=0)\\n ranges += soc_state.addrCells(self.platform.pci_host.pci_pio_base)\\n ranges += pci_state.sizeCells(0x10000) # Fixed size\\n\\n # AXI memory address range\\n ranges += self.platform.pci_host.pciFdtAddr(space=2, addr=0)\\n ranges += soc_state.addrCells(self.platform.pci_host.pci_mem_base)\\n ranges += pci_state.sizeCells(0x40000000) # Fixed size\\n pci_node.append(FdtPropertyWords(\\\"ranges\\\", ranges))\\n\\n # Interrupt mapping\\n plic_handle = int_state.phandle(plic)\\n int_base = self.platform.pci_host.int_base\\n\\n interrupts = []\\n\\n for i in range(int(self.platform.pci_host.int_count)):\\n interrupts += self.platform.pci_host.pciFdtAddr(\\n device=i, addr=0\\n ) + [int(i) + 1, plic_handle, int(int_base) + i]\\n\\n pci_node.append(FdtPropertyWords(\\\"interrupt-map\\\", interrupts))\\n\\n int_count = int(self.platform.pci_host.int_count)\\n if int_count & (int_count - 1):\\n fatal(\\\"PCI interrupt count should be power of 2\\\")\\n\\n intmask = self.platform.pci_host.pciFdtAddr(\\n device=int_count - 1, addr=0\\n ) + [0x0]\\n pci_node.append(FdtPropertyWords(\\\"interrupt-map-mask\\\", intmask))\\n\\n if self.platform.pci_host._dma_coherent:\\n pci_node.append(FdtProperty(\\\"dma-coherent\\\"))\\n\\n soc_node.append(pci_node)\\n\\n # UART node\\n uart = self.platform.uart\\n uart_node = uart.generateBasicPioDeviceNode(\\n soc_state, \\\"uart\\\", uart.pio_addr, uart.pio_size\\n )\\n uart_node.append(\\n FdtPropertyWords(\\\"interrupts\\\", [self.platform.uart_int_id])\\n )\\n uart_node.append(FdtPropertyWords(\\\"clock-frequency\\\", [0x384000]))\\n uart_node.append(\\n FdtPropertyWords(\\\"interrupt-parent\\\", soc_state.phandle(plic))\\n )\\n uart_node.appendCompatible([\\\"ns8250\\\"])\\n soc_node.append(uart_node)\\n\\n # VirtIO MMIO disk node\\n disk = self.disk\\n disk_node = disk.generateBasicPioDeviceNode(\\n soc_state, \\\"virtio_mmio\\\", disk.pio_addr, disk.pio_size\\n )\\n disk_node.append(FdtPropertyWords(\\\"interrupts\\\", [disk.interrupt_id]))\\n disk_node.append(\\n FdtPropertyWords(\\\"interrupt-parent\\\", soc_state.phandle(plic))\\n )\\n disk_node.appendCompatible([\\\"virtio,mmio\\\"])\\n soc_node.append(disk_node)\\n\\n # VirtIO MMIO rng node\\n rng = self.rng\\n rng_node = rng.generateBasicPioDeviceNode(\\n soc_state, \\\"virtio_mmio\\\", rng.pio_addr, rng.pio_size\\n )\\n rng_node.append(FdtPropertyWords(\\\"interrupts\\\", [rng.interrupt_id]))\\n rng_node.append(\\n FdtPropertyWords(\\\"interrupt-parent\\\", soc_state.phandle(plic))\\n )\\n rng_node.appendCompatible([\\\"virtio,mmio\\\"])\\n soc_node.append(rng_node)\\n\\n root.append(soc_node)\\n\\n fdt = Fdt()\\n fdt.add_rootnode(root)\\n fdt.writeDtsFile(os.path.join(outdir, \\\"device.dts\\\"))\\n fdt.writeDtbFile(os.path.join(outdir, \\\"device.dtb\\\"))\",\n \"def make_data(rics: list, fields: list, name: str) -> None:\\n df = get_data(rics, fields)\\n df.index.name = 'ID'\\n to_csv(df, name)\",\n \"def generate_timeseries(data_list, setname=\\\"MagneticFields\\\"):\\n full_data = TimeSeriesList()\\n for seg in sorted(data_list):\\n hfile = h5py.File(data_list[seg], \\\"r\\\")\\n full_data.append(retrieve_data_timeseries(hfile, \\\"MagneticFields\\\"))\\n hfile.close()\\n return full_data\",\n \"def download_6min_csv(out_file, begin_date, end_date, station, product='water_level', datum='STND', time_zone='GMT'):\\n\\n # Note: 6 minutes is the default interval, see https://api.tidesandcurrents.noaa.gov/api/prod/\\n\\n base_url = 'https://api.tidesandcurrents.noaa.gov'\\n if product == 'water_level':\\n api_url = '/api/prod/datagetter'\\\\\\n '?product='+product+\\\\\\n '&application=NOS.COOPS.TAC.WL'\\\\\\n '&begin_date='+begin_date+\\\\\\n '&end_date='+end_date+\\\\\\n '&station='+station+\\\\\\n '&datum='+datum+\\\\\\n '&time_zone='+time_zone+\\\\\\n '&units=metric'\\\\\\n '&format=csv'\\n else:\\n api_url = '/api/prod/datagetter'\\\\\\n '?product='+product+\\\\\\n '&application=NOS.COOPS.TAC.WL'\\\\\\n '&begin_date='+begin_date+\\\\\\n '&end_date='+end_date+\\\\\\n '&station='+station+\\\\\\n '&time_zone='+time_zone+\\\\\\n '&units=metric'\\\\\\n '&format=csv'\\n\\n url = base_url+api_url\\n print(url)\\n _retrieve_file(url,out_file)\",\n \"def __init__(self,\\n name: str = 'Process',\\n time_horizon: int = 432000,\\n lambda_: float = 0.1,\\n beta: float = 0.2,\\n epsilon: float = 0.2,\\n mu: int = 4,\\n stream_speed: int = 100,\\n n_features: int = 2,\\n gen_plot: bool = False,\\n gen_metrics: bool = True):\\n self.gen_plot = gen_plot\\n self.gen_metrics = gen_metrics\\n self.event_index = 0\\n self.total_cases = set()\\n self.check_point = datetime(2010, 1, 1)\\n self.cases = []\\n self.name = name\\n self.time_horizon = time_horizon\\n self.initialized = False\\n self.cp_count = 0\\n self.nyquist = 0\\n self.check_point_cases = 0\\n self.process_model_graph = nx.DiGraph()\\n self.denstream = DenStream(lambda_, beta, epsilon, mu, stream_speed, n_features)\\n self.cluster_metrics = []\\n self.case_metrics = []\\n self.active_core_clusters = set()\\n self.drift_indexes = []\\n self.metrics = Metrics(self.name)\\n self.feature_space_plot_path = f'visualization/{self.name}_feature_space'\\n makedirs(self.feature_space_plot_path, exist_ok=True)\",\n \"def write_output(self) -> None:\\n self.home.round(2).to_csv(var.indicators_base_cumsum + \\\"home_\\\" + str(self.year) + \\\".csv\\\")\\n self.away.round(2).to_csv(var.indicators_base_cumsum + \\\"away_\\\" + str(self.year) + \\\".csv\\\")\",\n \"def __init__(\\n self,\\n output_dir=None,\\n output_fname='statistics.tsv',\\n exp_name=None,\\n log_freq=1,\\n ):\\n # Set up output file\\n self.output_dir = output_dir or '/tmp/experiments/%i' % int(time.time())\\n if not os.path.exists(self.output_dir):\\n os.makedirs(self.output_dir)\\n output_filepath = os.path.join(output_dir, output_fname)\\n self.output_file = open(output_filepath, 'w')\\n self.file_writer = csv.writer(self.output_file, delimiter='\\\\t')\\n atexit.register(self.output_file.close)\\n\\n self.exp_name = exp_name\\n self.log_freq = log_freq\\n self.first_row = True\\n self.log_headers = None\\n self.counter = 0 # keeps track of how often log_stats is called\",\n \"def generate(dir):\\r\\n metric_files = get_all_metrics(dir)\\r\\n dfs = []\\r\\n for m in metric_files:\\r\\n metric_name = m.replace('.csv', '').split('-')[-1]\\r\\n full_path = os.path.join(dir, m)\\r\\n dfs.append(read_metrics_as_df(full_path,'Value',metric_name).set_index('Step').drop(columns=['Wall time']))\\r\\n base_df = dfs[0]\\r\\n for df in dfs[1:]:\\r\\n base_df = base_df.join(df, on='Step')\\r\\n return base_df\",\n \"def _gen_report(self):\\n print \\\"------------------------------------------\\\"\\n print \\\"fio report\\\"\\n print \\\"------------------------------------------\\\"\\n print \\\"name\\\", \\\" \\\".join(f for f in FIELDS)\\n # print fields\\n for name in sorted(self.reports):\\n report = self.reports[name]\\n #print report\\n print name, \\\" \\\".join(str(report.get(f)) for f in FIELDS)\\n\\n print \\\"*******************************************\\\"\\n # print clats\\n index = 0\\n for name in sorted(self.reports):\\n report = self.reports[name]\\n if index == 0:\\n print \\\"clat_percent\\\", \\\" \\\".join(\\n str(c[0]) for c in report[\\\"clats\\\"])\\n print name, \\\" \\\".join(str(c[1]) for c in report[\\\"clats\\\"])\\n index += 1\",\n \"def make_nptabel_csv(obs_id, module, qa_dir, output_path=''):\\n\\n logger.info(\\n \\\"Reading param information for {0} of {1}\\\".format(module, obs_id))\\n summary_data = extract_all_beams(obs_id, module, qa_dir)\\n logger.info(\\n \\\"Reading param information for {0} of {1}... Done\\\".format(module, obs_id))\\n\\n i = 0\\n if module == 'transfer':\\n while len(summary_data[i]) <= 1:\\n i += 1\\n if len(summary_data[i]) > 1:\\n break\\n else:\\n while len(summary_data[i]) <= 2:\\n i += 1\\n if len(summary_data[i]) > 2:\\n break\\n\\n csv_columns = summary_data[i].keys()\\n\\n csv_columns.sort()\\n dict_data = summary_data\\n\\n # save the file\\n if output_path == '':\\n csv_file = str(obs_id)+\\\"_\\\"+str(module)+\\\"_summary.csv\\\"\\n else:\\n csv_file = os.path.join(output_path, str(\\n obs_id)+\\\"_\\\"+str(module)+\\\"_summary.csv\\\")\\n\\n try:\\n with open(csv_file, 'w') as csvfile:\\n writer = csv.DictWriter(csvfile, fieldnames=csv_columns)\\n writer.writeheader()\\n for data in dict_data:\\n writer.writerow(data)\\n except Exception as e:\\n logger.warning(\\\"Creating file {} failed\\\".format(csv_file))\\n logger.exception(e)\\n\\n # print(\\\"Created file: \\\"+str(obs_id)+\\\"_\\\"+str(module)+\\\"_summary.csv\\\")\\n logger.info(\\\"Creating file: {} ... Done\\\".format(csv_file))\",\n \"def fcvs(self):\\n for name in self._fcvs:\\n yield name, self._data[name]\",\n \"def make_csv(file_of_data):\\n with open(file_of_data, 'w') as f:\\n writer = csv.writer(f)\\n header = (\\\"Counter\\\", \\\"Date/time\\\", \\\"Latitude\\\", \\\"Longitude\\\", \\\"Temperature\\\", \\\"Humidity\\\")\\n writer.writerow(header)\",\n \"def main(files, target_depth, tol_diff, depth_fld, temperature_fld,\\n salinity_fld):\\n ymd_fmt = \\\"{0}-{1}-{2}\\\"\\n # Note change of line terminator to make it compatible with AWK\\n writer = csv.writer(sys.stdout, lineterminator='\\\\n')\\n writer.writerow([\\\"time\\\", \\\"bottle_number\\\", \\\"depth\\\",\\n \\\"temperature\\\", \\\"salinity\\\"])\\n for bottle_f in files:\\n with bottle_f:\\n for lineno, line in enumerate(bottle_f, start=1):\\n if re.search('^(\\\\*|#)', line):\\n continue\\n if re.search('^ *bottle', line.lower()):\\n databeg = lineno + 2\\n continue\\n if (lineno - databeg) % 2 == 0:\\n parsedl = line.split()\\n mm = _french_month(parsedl[1])\\n if mm:\\n fmt = '%Y-%m-%d %H:%M:%S'\\n yyyymmdd = ymd_fmt.format(parsedl[3], mm, parsedl[2])\\n else:\\n fmt = '%Y-%b-%d %H:%M:%S'\\n yyyymmdd = ymd_fmt.format(parsedl[3], parsedl[1],\\n parsedl[2])\\n bottle_no = parsedl[0]\\n depth = parsedl[depth_fld - 1]\\n temperature = parsedl[temperature_fld - 1]\\n salinity = parsedl[salinity_fld - 1]\\n else:\\n if lineno <= databeg:\\n continue\\n hhmmss = line.split()[0]\\n ymd = datetime.strptime(\\\"{0} {1}\\\".format(yyyymmdd,\\n hhmmss), fmt)\\n depth_dev = abs(float(depth) - target_depth)\\n if (depth_dev < tol_diff):\\n line_out = (ymd.strftime('%Y-%m-%d %H:%M:%S'),\\n bottle_no, depth, temperature,\\n salinity)\\n writer.writerow(line_out)\",\n \"def save_as_csv(time_series, data, path_and_file_name):\\n\\n parent_name = \\\"test\\\"\\n parent_uqid = uuid.uuid4()\\n\\n file_obj = open(path_and_file_name, 'w')\\n file_obj.write('version,'+str(2)+'\\\\n')\\n file_obj.write('numOfCH,'+str(1)+'\\\\n')\\n file_obj.write('type, scan\\\\n')\\n file_obj.write('ch_type,'+str(0)+'\\\\n')\\n\\n file_obj.write('carpet pos,'+str(0)+'\\\\n')\\n file_obj.write('parent_name,'+str(parent_name)+'\\\\n')\\n file_obj.write('parent_uqid,'+str(parent_uqid)+'\\\\n')\\n file_obj.write('parent_filename,'+str(path_and_file_name)+'\\\\n')\\n\\n file_obj.write('pc, 0\\\\n')\\n file_obj.write('Time (ns), CH0 Auto-Correlation\\\\n')\\n for time_step in range(0, time_series.shape[0]):\\n file_obj.write(str(float(time_series[time_step]))+','+str(data[time_step])+ '\\\\n')\\n file_obj.write('end\\\\n')\\n\\n file_obj.close()\",\n \"def to_csv(self):\\n if not self._fitted:\\n self.fit()\\n #self._message(\\\"Saving results into a csv (comma separated values) file.\\\")\\n v=np.array([list(self.initialConcentration.values()),\\n list(self.fitting_error.values()),\\n list(self.k.values()),\\n list(self.Fb.values()),\\n list(self.slope.values())]).T\\n k=list(self.initialConcentration.keys())\\n d=pd.DataFrame(v,columns=['Initial Concentration','Fitting Error','k','Fb','Slope'],index=k)\\n fn=get_valid_fname(self.ID)\\n self.csvname=\\\"%s_initial_concentrations.csv\\\"%(fn)\\n self.fullcsvname=\\\"%s/%s_initial_concentrations.csv\\\"%(self.info['resultsdir'],fn)\\n self.info['csvname_initialConcentration']=self.csvname\\n print(self.csvname)\\n d.to_csv('%s/%s'%(self.info['resultsdir'],self.csvname))\",\n \"def readProcessedFCD():\\n procFcdDict = {}\\n pqDateDict = {} # each date is a period / quota tupel assigned\\n simDate = '2007-07-18 '\\n day = 0\\n # create keys for the procFcdDict\\n for p in period:\\n for q in quota:\\n day += 86400\\n date, time = calcTime.getDateFromDepart(day).split(\\\" \\\")\\n pqDateDict.setdefault(date, (p, q))\\n procFcdDict.setdefault((p, q), {})\\n # print date,p,q\\n\\n inputFile = open(path.FQprocessedFCD, 'r')\\n for line in inputFile:\\n timestamp, edge, speed, cover, id = line.split('\\\\t')\\n date, time = calcTime.getNiceTimeLabel(timestamp).split(\\\" \\\")\\n # add values to actual Dict\\n timestep = calcTime.getTimeInSecs(simDate + time)\\n procFcdDict[pqDateDict[date]].setdefault(\\n timestep, []).append((id, edge, float(speed) / 3.6))\\n inputFile.close()\\n\\n return procFcdDict\",\n \"def write_crossing_times(temperature, crossing_times_collector, file_name):\\n with open(\\\"./Results/\\\" + file_name + \\\"-T{:.4f}.csv\\\".format(temperature), 'w') as f:\\n for crossing_times in crossing_times_collector:\\n f.write(\\\"%s\\\\n\\\" % \\\", \\\".join([str(element) for element in crossing_times]))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.60827273","0.5674156","0.5534153","0.55247027","0.5505764","0.55022764","0.5441504","0.53989345","0.5363615","0.5295529","0.5295098","0.5272777","0.5267846","0.5244405","0.5212482","0.5211538","0.5181538","0.5169765","0.51641446","0.5136384","0.51107246","0.5106257","0.50991654","0.5092352","0.509022","0.5056863","0.5048959","0.5021584","0.5018585","0.501382","0.50083184","0.500655","0.5006525","0.50052905","0.5005275","0.4998223","0.499627","0.4989683","0.4988091","0.49879584","0.49871874","0.49741328","0.49724936","0.4959132","0.49465233","0.49333894","0.4918992","0.4911072","0.4901557","0.48844725","0.48753703","0.4866214","0.4854107","0.48519787","0.48463148","0.4846193","0.48445493","0.48442847","0.4843979","0.48407745","0.48301542","0.48251057","0.48236597","0.48111337","0.48051468","0.4802407","0.4800946","0.4796657","0.47948876","0.47890058","0.4787668","0.47810066","0.47800204","0.47744486","0.47713694","0.47698882","0.4767039","0.47665918","0.47627348","0.47541285","0.4750891","0.4750016","0.47486076","0.47441602","0.4743991","0.47428042","0.47372583","0.47370315","0.47305447","0.47302747","0.4724557","0.47135222","0.47114652","0.4710866","0.47100687","0.4703646","0.46989983","0.46848214","0.4683052","0.46715912"],"string":"[\n \"0.60827273\",\n \"0.5674156\",\n \"0.5534153\",\n \"0.55247027\",\n \"0.5505764\",\n \"0.55022764\",\n \"0.5441504\",\n \"0.53989345\",\n \"0.5363615\",\n \"0.5295529\",\n \"0.5295098\",\n \"0.5272777\",\n \"0.5267846\",\n \"0.5244405\",\n \"0.5212482\",\n \"0.5211538\",\n \"0.5181538\",\n \"0.5169765\",\n \"0.51641446\",\n \"0.5136384\",\n \"0.51107246\",\n \"0.5106257\",\n \"0.50991654\",\n \"0.5092352\",\n \"0.509022\",\n \"0.5056863\",\n \"0.5048959\",\n \"0.5021584\",\n \"0.5018585\",\n \"0.501382\",\n \"0.50083184\",\n \"0.500655\",\n \"0.5006525\",\n \"0.50052905\",\n \"0.5005275\",\n \"0.4998223\",\n \"0.499627\",\n \"0.4989683\",\n \"0.4988091\",\n \"0.49879584\",\n \"0.49871874\",\n \"0.49741328\",\n \"0.49724936\",\n \"0.4959132\",\n \"0.49465233\",\n \"0.49333894\",\n \"0.4918992\",\n \"0.4911072\",\n \"0.4901557\",\n \"0.48844725\",\n \"0.48753703\",\n \"0.4866214\",\n \"0.4854107\",\n \"0.48519787\",\n \"0.48463148\",\n \"0.4846193\",\n \"0.48445493\",\n \"0.48442847\",\n \"0.4843979\",\n \"0.48407745\",\n \"0.48301542\",\n \"0.48251057\",\n \"0.48236597\",\n \"0.48111337\",\n \"0.48051468\",\n \"0.4802407\",\n \"0.4800946\",\n \"0.4796657\",\n \"0.47948876\",\n \"0.47890058\",\n \"0.4787668\",\n \"0.47810066\",\n \"0.47800204\",\n \"0.47744486\",\n \"0.47713694\",\n \"0.47698882\",\n \"0.4767039\",\n \"0.47665918\",\n \"0.47627348\",\n \"0.47541285\",\n \"0.4750891\",\n \"0.4750016\",\n \"0.47486076\",\n \"0.47441602\",\n \"0.4743991\",\n \"0.47428042\",\n \"0.47372583\",\n \"0.47370315\",\n \"0.47305447\",\n \"0.47302747\",\n \"0.4724557\",\n \"0.47135222\",\n \"0.47114652\",\n \"0.4710866\",\n \"0.47100687\",\n \"0.4703646\",\n \"0.46989983\",\n \"0.46848214\",\n \"0.4683052\",\n \"0.46715912\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.64446026"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":84795,"cells":{"query":{"kind":"string","value":"timer event, that is called at timer timeout"},"document":{"kind":"string","value":"def gameLoop(self):\n #f = open(\"C:/Users/Carsten/Desktop/test.txt\",\"a\")\n #f.write(str(QtCore.QThread.currentThreadId()) + \" - game on server game loop \\n\")\n #f.close()\n self.calculate_scene()\n self.send_scene_informations()"},"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 on_timeout(self):\n pass","def timer_handler():\r\n \r\n global elapsed_time\r\n elapsed_time += 1","def timeout(self):\n self.timeout_scan_flag=True\n self.timer.stop()\n self.status_sig.emit([\"Update_Status\",\"Timeout during acquisition\",'log'])\n self.status_sig.emit([\"Timeout\"])","def ontimer(self, fun, t=0):\n self._ontimer(fun, t)","def on_timer(context, data_type, data):\n pass","async def on_timer_update(self, secs: int):\n pass","def __timeout(self, seconds, func, *args):\n t = threading.Timer(seconds, func, *args)\n self._timer = t\n t.start()","def timer_callback(*args):\n logging.debug(\"timer callback at %s\" % datetime.now())","def functionThatWillTimeOut():\n time.sleep(5)","def onTimer(self, tid, userArg):\n\t\t#DEBUG_MSG(\"%s::onTimer: %i, tid:%i, arg:%i\" % (self.getScriptName(), self.id, tid, userArg))\n\t\tNPCObject.onTimer(self, tid, userArg)","def time_change_listener(self, eventignored):\n if self._timeoutat is not None:\n if now() > self._timeoutat:\n self._timeoutat = None\n self.process_event(Events.Timeout)","def on_timeout_cb(self):\n if self.timeout_counter > 0:\n self.label.set_text(\n self.event[\"template\"].format(time=self.timeout_counter)\n )\n self.timeout_counter -= 1\n return True\n\n # Call calback if defined\n callback = self.event.get(\"callback\")\n if callback:\n callback()\n\n # Schedule next event if needed\n self.schedule_next_event()\n\n return False","def _ontimer(self, fun, t):\n if t == 0:\n self.cv.after_idle(fun)\n else:\n self.cv.after(t, fun)","def timer_callback(self):\n self.get_logger().debug(f\"Timer heartbeat {self.timer_count}\")\n self.timer_count += 1","def pytest_timeout_cancel_timer(item):","def timerEvent(self, event):\n self.ext_fb_trigger()\n if self._check_pulse():\n if self._generator_poll is None:\n if self._generator_feedback is not None:\n print('In timerEvent 2')\n self._stop_loop_feedback()\n return\n try:\n next(self._generator_poll) # Run the next iteration\n if self._generator_feedback is None:\n return\n try:\n next(self._generator_feedback)\n except Exception as e:\n print(e)\n self._stop_loop_feedback()\n except StopIteration:\n # print('In timerEvent 5')\n self._stop_loop_feedback() # Iteration has finished, kill the timer\n self._stop_loop_poll() # Iteration has finished, kill the timer","def pytest_timeout_set_timer(item, settings):","def execution_timer_callback(self, event):\n self.executing_goal = False","def timerAction():\n timer = threading.Timer(30.0, timerAction)\n timer.daemon = True\n timer.start()\n save()","def onTimer(self, tid, userArg):\n\t\tDEBUG_MSG(\"%s::onTimer: %i, tid:%i, arg:%i\" % (self.getScriptName(), self.id, tid, userArg))\n\t\tNPCObject.onTimer(self, tid, userArg)\n\t\tAbility.onTimer(self, tid, userArg)\n\t\tAI.onTimer(self, tid, userArg)\n\t\t#AnimationState.onTimer(self, tid, userArg)\n\t\t#AnimationState.onMotionChanged(self, self.isMoving)","def DestroyTimer(self, obj, event):\n return 1","def safe_timer(timeout, func, *args, **kwargs):\n def timer_event():\n try:\n func(*args, **kwargs)\n finally:\n QtCore.QTimer.singleShot(timeout, timer_event)\n QtCore.QTimer.singleShot(timeout, timer_event)","def on_timeout(self):\n self.logger.debug('id=%d, Session timed out!', self.id)\n self.close(SessionCloseErrorCode.SESSION_DIED)","def stop_timer(self):\n self.end_time = datetime.now()","def timeragent(forwho,timeoutfunction,interval):\r\n\r\n timerx = QtCore.QTimer()\r\n timerx.setInterval(interval)\r\n timerx.stop()\r\n\r\n forwho.connect(timerx,SIGNAL(\"timeout()\"),timeoutfunction)\r\n return timerx","def settimeout(self,timeout=10):\r\n # Update\r\n self.timeout = timeout","def time_automation_listener(now):\n action()","def setTimeout(self, timeout):\n self.timeout = timeout","def _on_timeout(self, info: str = None) -> None:\n self._timeout = None\n error_message = \"Timeout {0}\".format(info) if info else \"Timeout\"\n if self.final_callback is not None:\n print('raise')\n\n # self._handle_exception(\n # HTTPTimeoutError, HTTPTimeoutError(error_message), None\n # )","def _idle(self):\n # self._purge_timedout()\n # ...","def __timer_event(self, event):\n self.__refresh_grid()\n if len(self.__selected_correlation) == 2:\n self.show_graph(symbol1=self.__selected_correlation[0], symbol2=self.__selected_correlation[1])\n\n # Set status message\n self.SetStatusText(f\"Status updated at {self.__cor.get_last_calculation():%d-%b %H:%M:%S}.\", 1)","def on_timer(self):\n self.read_serial_data()\n # self.update_monitor()","def _on_timeout(self, key: object, info: str = None) -> None:\n request, callback, timeout_handle = self.waiting[key]\n self.queue.remove((key, request, callback))\n\n error_message = \"Timeout {0}\".format(info) if info else \"Timeout\"\n timeout_response = UDPResponse(\n request,\n 599,\n #error=HTTPTimeoutError(error_message),\n request_time=self.io_loop.time() - request.start_time,\n )\n self.io_loop.add_callback(callback, timeout_response)\n del self.waiting[key]","def attempt(self, timer, context, phases):","def set_timeout(self, timeout):\n self.timeout = timeout","def timer_setup(self):\n pass","def _banner_timeout(self):\n self.sm.on_state_event(self.events.BANNERTIMEOUT)","def __call__(self):\n return self.timer()","def anti_idle_timer_handler(self):\n if not self.connected(): return\n self.send_nop()\n self.start_anti_idle_timer()","def loop_run(self):\n super(TimerLoop, self).loop_run()\n self.timer = self.cothread.Timer(self.timeout,\n self.callback,\n retrigger=True)","def callback_max_sim_time_reached(self, event):\n self.perform_final_actions()\n self._max_sim_time_reached = True\n CiLog.info(\"Simulation timer finished.\")","def timer_change(self):\n if self.time < 999:\n self.time += 1\n self.time_lcd.display(self.time)\n else:\n self.timer.stop()","def timeout(self):\n pf.debug(\"TIMEOUT\")\n self.acceptData(TIMEOUT)","def setTimeOut(self, timeout=6.0):\n self.timeout = timeout","def __window_setTimeout(self, f, delay):\n self.__dict__['__timeout'].append(f)","def stop_timer(self):\n self.log.info(\"{} timer stopped ({} seconds)\".format(self.name, self.interval))\n self.start_event.clear()\n # self.count = self.interval / self.sleep_chunk","def create_timer(function, time):\n timer = Timer()\n timer.timeout.connect(function)\n timer.start(time)\n timer.speed = time\n return timer","def on_tick(self, time):\n pass","def timed_msg(self, t_sec, msg):\n self._msg_hdr(msg)\n self.main_loop.set_alarm_in(t_sec, self._msg_cb, '')","def reset_timeout (self, new_timeout):\n self.timer.cancel()\n self.timer = Timeout(new_timeout, TestIsTakingTooLong(new_timeout))","def timer_object_timeout(seconds=5):\n def raise_timeout_exception():\n raise TimeoutReachedException(seconds=seconds)\n\n return Timer(seconds, raise_timeout_exception)","def fire_timeouted(self):\n fired = self._get_timeouted()\n for timer in fired.keys():\n if fired[timer][0] is None:\n del fired[timer]\n continue\n try:\n cb, arg, _, _ = fired[timer]\n cb(arg)\n except Exception, e:\n # TODO for debugging purposes\n self.logger.exception('Timer handler raised: %s' % e)\n raise e\n\n # Update the timer\n timer_type = fired[timer][2]\n if timer_type == self.TIMER_REPEATED:\n # delete it from the timers\n self.delete(timer)\n\n # Add it again\n cb, arg, _, secs = fired[timer]\n self.add(secs=secs, cb=cb, arg=arg, timer_type=timer_type)\n else:\n self.delete(timer)","def timer(self):\n self.time_remaining -= 1\n if self.time_remaining > 0:\n Timer(1, self.timer).start()","def bcp_timer(self, name, action, **kwargs):\n\n self.events.post('timer_' + name + '_' + action, **kwargs)","def slot_timer(self, _sender, _data):\r\n if self.connected:\r\n if time.time() - self._time_last_received > 60:\r\n self.debug(\"### did not receive anything for a long time, disconnecting.\")\r\n self.force_reconnect()\r\n self.connected = False\r\n if time.time() - self._time_last_subscribed > 1800:\r\n # sometimes after running for a few hours it\r\n # will lose some of the subscriptons for no\r\n # obvious reason. I've seen it losing the trades\r\n # and the lag channel channel already, and maybe\r\n # even others. Simply subscribing again completely\r\n # fixes this condition. For this reason we renew\r\n # all channel subscriptions once every hour.\r\n self.debug(\"### refreshing channel subscriptions\")\r\n self.channel_subscribe(False)","def timerEvent(self, event):\n\n if int(time.time()) - self.start_time > self.capture_duration:\n self.stop_recording()\n\n recording, data = self.camera.read()\n if recording:\n self.image_data.emit(data)","def watchdog_timer(state, wait=3):\n time.sleep(wait)\n if not state['completed']:\n _thread.interrupt_main()","def set_timeout(self, timeout):\n pass","def runAtIdle(self, aFunc: Callable) -> None:\n QtCore.QTimer.singleShot(0, aFunc)","def handler(signum, frame):\n\tglobal stop_flag\n\tstop_flag=True\n\tprint(\"Query timeout!!!!!!!!!!!\")\n\traise Exception(\"Timeout\")","def _on_timer_complete(self, kwargs: dict) -> None:\n self.log(\"Sleep timer over; turning switch off\")\n\n self.set_value(self.entity_ids[CONF_TIMER_SLIDER], 0)","def timeout(self, timeout):\n\n self._timeout = timeout","def start_handler():\r\n timer.start()","def callback(self, fun: Callable[[Timer], None] | None, /) -> None:","def callback(self, fun: Callable[[Timer], None] | None, /) -> None:","def post(self, event):\n self.queue.append(event)\n if not self.timer.active:\n self.timer.start(0)","def pytest_timeout_cancel_timer(item):\n tle.lib.cancel()\n return True","def OnTimer(self, event):\n if self.timerNotZero: # When timer runs, subtract one second and update text\n self.start_time = self.start_time.Subtract(wx.TimeSpan(0, sec=1))\n self.timertext.SetLabel(self.start_time.Format(\"%M:%S\"))\n if self.start_time.GetMinutes() == 0 and self.start_time.GetSeconds() == 0: # Timer reached zero\n self.timerNotZero = False\n self.button1.SetBackgroundColour('red')\n else: # Once timer stops, makes the text blink red\n if self.blinkPhase == 0:\n self.timertext.SetForegroundColour('red')\n self.timertext.SetLabel(\"00:00\")\n self.blinkPhase = 1\n elif self.blinkPhase == 1:\n self.timertext.SetForegroundColour('black')\n self.timertext.SetLabel(\"00:00\")\n self.blinkPhase = 0","def timer_canceled(self, timer):\n try:\n try:\n timer.impltimer.stop()\n del timer.impltimer\n except (AttributeError, TypeError):\n pass\n finally:\n super(Hub, self).timer_canceled(timer)","def set_invoke_timer(self, timeout, retry_entry=False):\n if self.timer_entry is not None and self.timer_entry.active:\n self.timer_entry.deactivate()\n #print(\"(%d) set_invoke_timer:\" % int(time.time()), timeout)\n self.timer_entry = query_management.QueryEntry(expire_after=timeout,\n callback_expire=self._perform_key_exchange,\n retry_count=0)\n if retry_entry:\n self.timer_entry.data[KeyType.retry_timer] = True","def rwsched_timer_callback(self, timer, user_data):\n logger.info(\"**** Voila1 Python TIMER callback ****\")\n logger.debug(timer)\n logger.debug(user_data)\n logger.debug(\"\\n\\n\")","def update(self, func):\n if self.current_time == 0:\n func()\n return\n self.current_time -= 1\n hours = self.current_time // 3600\n minutes = self.current_time % 3600 // 60\n seconds = self.current_time % 60\n try:\n self.timer_label.setText('%02d:%02d:%02d' % (hours, minutes, seconds))\n if self.current_time <= 10:\n self.timer_label.setStyleSheet('color: red')\n Qt.QTimer().singleShot(1000, lambda: self.update(func))\n except RuntimeError:\n return","def _slot_timer_info_later(self, _sender, _data):\r\n self.request_info()\r\n self._info_timer = None","def check_timer():\n end = time.time()\n time_elapsed = end - target_time[0]\n durationMSG = fg.cyan + f\"Scans Completed for {args.target} in: \" + fg.rs\n print(durationMSG, display_time(time_elapsed))","def _timeout(self):\n self.inbox_.put_nowait(Atom('timeout'))","def _handle_timeout(self, frame=None, **_):\n\n raise TimeOut.TimeOutError(self, frame)","def on_sampling_timer(self, event):\n self.sampling_timer.Stop()","def settimeout(self, to):\r\n self._timeout = to","def stop_timer(self):\r\n self.countdownTimer.stop()","def timeout(self, timeout):\n assert timeout is None or timeout > 0\n self._timeout = timeout","def _timeout(signum, frame):\n # Raise TimeoutException with system default timeout message\n raise TimeoutException()","def timeout(time):\n\n def wrapper(f):\n @wraps(f)\n def wrapped_f(self, event, context):\n return f(self, event, context)\n\n wrapped_f.timeout = time\n return wrapped_f\n\n return wrapper","def pytest_timeout_set_timer(item, settings):\n tle.lib.set(int(settings.timeout), str(item).encode(\"utf-8\"))\n return True","def timeout(self):\n self._status_update(\"Pyloton: Timeout\")\n time.sleep(3)","def reset_timer():\n resetTimer = time.time()\n target_time.clear()\n target_time.append(resetTimer)","def timer_update(self):\n if self.mineboard.gamestate is not None:\n return\n time_so_far = round(time.time()-self.start_time)\n if time_so_far == 1:\n self.now.set(f\"Time so far: {time_so_far} second\")\n else:\n self.now.set(f\"Time so far: {time_so_far} seconds\")\n self.after(1000, self.timer_update) # calls this function every second","def __window_clearTimeout(self, timeoutID):\n pass","def timer_tick(self):\n self.timing.timer_tick() # notifies the timing module\n self.events.post('timer_tick') # sends the timer_tick system event\n Task.timer_tick() # notifies tasks\n DelayManager.timer_tick()","def _banner_timeout(self):\n self.hide_banner()\n self._request_redraw()\n self.sm.on_state_event(self.events.TIMEOUT)","def timeout_change(self, timedelta):\n pass # pylint: disable=unnecessary-pass\n # For backward compatibility only.","def __init__(self, timeout=120):\n self.m_timeout = timeout","def start(self):\n self.end_time = time.time() + self.timeout_time","def timer(self):\n if self.board.reset_timer:\n self.time_count.set(\"000\")\n self.time_widget.config(text=self.time_count.get())\n return 0\n elif self.board.stop_timer:\n return 0\n now_time = time.time()\n self.board.time = now_time - self.board.last_frame_time\n self.time_count.set(self.numToStrLabel(int(self.board.time)))\n self.time_widget.config(text=self.time_count.get())\n self.board.time = self.board.last_frame_time\n self.after(50, self.timer)","def reset_timer(self, *_) -> \"ALL\":\n self.last = time.time()\n delta = time.time() - self.last\n if delta > 180:\n print(\n \"!!! Warning: Watchdog failure detected, spawning a fallback \"\n \"thread.\"\n )\n self.watchdog = FallbackWatchdog(self)\n self.watchdog.start()","def internal_event (self):\n self.clock_time += 1\n self.log()","def doTimeout(self):\n\n log.info('Executed {} calls until timeout'.format(self.calls_to_timeout))\n self.calls_to_timeout = 0\n\n self.resetSession()\n time.sleep(self.timeout)","def on_timer(self, event):\n \n o = Unicorn()\n data = o.get_data(rt)\n k = len(data[0])\n y[:, :-k] = y[:, k:]\n y[:, -k:] = remap((data), -40, 40, -1, 1 ) \n t2 = _thread.start_new_thread(printT, ())\n #y2 = np.array([lfilter(b, a, y[i]) for i in range(17)])\n self.program['a_position'].set_data(y.ravel().astype(np.float32))\n self.update()","def checkTimeout(self):\n if TIMEOUT <= (datetime.now() - self.clockCheckStop).total_seconds():\n print('Didn\\'t received messages for 1 minute - Program ends')\n exit(0)","def _set_delete_timer(self, key_name, timeout):\n if key_name is not None:\n #print(\"(%d) _set_delete_timer:\" % int(time.time()), key_name.hex()[:10], timeout)\n query_management.QueryEntry(expire_after=timeout, callback_expire=remove_old_key,\n data={KeyType.hint: key_name}, retry_count=0)","def terminate(self):\n self.stop_timer()\n self.terminate_event.set()\n self.log.info(self.name + \" timer terminated\")","def eventTimer(Event, Time1):\n Time2 = time.time()\n print((\"%4.2f\" % (Time2 - Time1), Event))\n return Time2"],"string":"[\n \"def on_timeout(self):\\n pass\",\n \"def timer_handler():\\r\\n \\r\\n global elapsed_time\\r\\n elapsed_time += 1\",\n \"def timeout(self):\\n self.timeout_scan_flag=True\\n self.timer.stop()\\n self.status_sig.emit([\\\"Update_Status\\\",\\\"Timeout during acquisition\\\",'log'])\\n self.status_sig.emit([\\\"Timeout\\\"])\",\n \"def ontimer(self, fun, t=0):\\n self._ontimer(fun, t)\",\n \"def on_timer(context, data_type, data):\\n pass\",\n \"async def on_timer_update(self, secs: int):\\n pass\",\n \"def __timeout(self, seconds, func, *args):\\n t = threading.Timer(seconds, func, *args)\\n self._timer = t\\n t.start()\",\n \"def timer_callback(*args):\\n logging.debug(\\\"timer callback at %s\\\" % datetime.now())\",\n \"def functionThatWillTimeOut():\\n time.sleep(5)\",\n \"def onTimer(self, tid, userArg):\\n\\t\\t#DEBUG_MSG(\\\"%s::onTimer: %i, tid:%i, arg:%i\\\" % (self.getScriptName(), self.id, tid, userArg))\\n\\t\\tNPCObject.onTimer(self, tid, userArg)\",\n \"def time_change_listener(self, eventignored):\\n if self._timeoutat is not None:\\n if now() > self._timeoutat:\\n self._timeoutat = None\\n self.process_event(Events.Timeout)\",\n \"def on_timeout_cb(self):\\n if self.timeout_counter > 0:\\n self.label.set_text(\\n self.event[\\\"template\\\"].format(time=self.timeout_counter)\\n )\\n self.timeout_counter -= 1\\n return True\\n\\n # Call calback if defined\\n callback = self.event.get(\\\"callback\\\")\\n if callback:\\n callback()\\n\\n # Schedule next event if needed\\n self.schedule_next_event()\\n\\n return False\",\n \"def _ontimer(self, fun, t):\\n if t == 0:\\n self.cv.after_idle(fun)\\n else:\\n self.cv.after(t, fun)\",\n \"def timer_callback(self):\\n self.get_logger().debug(f\\\"Timer heartbeat {self.timer_count}\\\")\\n self.timer_count += 1\",\n \"def pytest_timeout_cancel_timer(item):\",\n \"def timerEvent(self, event):\\n self.ext_fb_trigger()\\n if self._check_pulse():\\n if self._generator_poll is None:\\n if self._generator_feedback is not None:\\n print('In timerEvent 2')\\n self._stop_loop_feedback()\\n return\\n try:\\n next(self._generator_poll) # Run the next iteration\\n if self._generator_feedback is None:\\n return\\n try:\\n next(self._generator_feedback)\\n except Exception as e:\\n print(e)\\n self._stop_loop_feedback()\\n except StopIteration:\\n # print('In timerEvent 5')\\n self._stop_loop_feedback() # Iteration has finished, kill the timer\\n self._stop_loop_poll() # Iteration has finished, kill the timer\",\n \"def pytest_timeout_set_timer(item, settings):\",\n \"def execution_timer_callback(self, event):\\n self.executing_goal = False\",\n \"def timerAction():\\n timer = threading.Timer(30.0, timerAction)\\n timer.daemon = True\\n timer.start()\\n save()\",\n \"def onTimer(self, tid, userArg):\\n\\t\\tDEBUG_MSG(\\\"%s::onTimer: %i, tid:%i, arg:%i\\\" % (self.getScriptName(), self.id, tid, userArg))\\n\\t\\tNPCObject.onTimer(self, tid, userArg)\\n\\t\\tAbility.onTimer(self, tid, userArg)\\n\\t\\tAI.onTimer(self, tid, userArg)\\n\\t\\t#AnimationState.onTimer(self, tid, userArg)\\n\\t\\t#AnimationState.onMotionChanged(self, self.isMoving)\",\n \"def DestroyTimer(self, obj, event):\\n return 1\",\n \"def safe_timer(timeout, func, *args, **kwargs):\\n def timer_event():\\n try:\\n func(*args, **kwargs)\\n finally:\\n QtCore.QTimer.singleShot(timeout, timer_event)\\n QtCore.QTimer.singleShot(timeout, timer_event)\",\n \"def on_timeout(self):\\n self.logger.debug('id=%d, Session timed out!', self.id)\\n self.close(SessionCloseErrorCode.SESSION_DIED)\",\n \"def stop_timer(self):\\n self.end_time = datetime.now()\",\n \"def timeragent(forwho,timeoutfunction,interval):\\r\\n\\r\\n timerx = QtCore.QTimer()\\r\\n timerx.setInterval(interval)\\r\\n timerx.stop()\\r\\n\\r\\n forwho.connect(timerx,SIGNAL(\\\"timeout()\\\"),timeoutfunction)\\r\\n return timerx\",\n \"def settimeout(self,timeout=10):\\r\\n # Update\\r\\n self.timeout = timeout\",\n \"def time_automation_listener(now):\\n action()\",\n \"def setTimeout(self, timeout):\\n self.timeout = timeout\",\n \"def _on_timeout(self, info: str = None) -> None:\\n self._timeout = None\\n error_message = \\\"Timeout {0}\\\".format(info) if info else \\\"Timeout\\\"\\n if self.final_callback is not None:\\n print('raise')\\n\\n # self._handle_exception(\\n # HTTPTimeoutError, HTTPTimeoutError(error_message), None\\n # )\",\n \"def _idle(self):\\n # self._purge_timedout()\\n # ...\",\n \"def __timer_event(self, event):\\n self.__refresh_grid()\\n if len(self.__selected_correlation) == 2:\\n self.show_graph(symbol1=self.__selected_correlation[0], symbol2=self.__selected_correlation[1])\\n\\n # Set status message\\n self.SetStatusText(f\\\"Status updated at {self.__cor.get_last_calculation():%d-%b %H:%M:%S}.\\\", 1)\",\n \"def on_timer(self):\\n self.read_serial_data()\\n # self.update_monitor()\",\n \"def _on_timeout(self, key: object, info: str = None) -> None:\\n request, callback, timeout_handle = self.waiting[key]\\n self.queue.remove((key, request, callback))\\n\\n error_message = \\\"Timeout {0}\\\".format(info) if info else \\\"Timeout\\\"\\n timeout_response = UDPResponse(\\n request,\\n 599,\\n #error=HTTPTimeoutError(error_message),\\n request_time=self.io_loop.time() - request.start_time,\\n )\\n self.io_loop.add_callback(callback, timeout_response)\\n del self.waiting[key]\",\n \"def attempt(self, timer, context, phases):\",\n \"def set_timeout(self, timeout):\\n self.timeout = timeout\",\n \"def timer_setup(self):\\n pass\",\n \"def _banner_timeout(self):\\n self.sm.on_state_event(self.events.BANNERTIMEOUT)\",\n \"def __call__(self):\\n return self.timer()\",\n \"def anti_idle_timer_handler(self):\\n if not self.connected(): return\\n self.send_nop()\\n self.start_anti_idle_timer()\",\n \"def loop_run(self):\\n super(TimerLoop, self).loop_run()\\n self.timer = self.cothread.Timer(self.timeout,\\n self.callback,\\n retrigger=True)\",\n \"def callback_max_sim_time_reached(self, event):\\n self.perform_final_actions()\\n self._max_sim_time_reached = True\\n CiLog.info(\\\"Simulation timer finished.\\\")\",\n \"def timer_change(self):\\n if self.time < 999:\\n self.time += 1\\n self.time_lcd.display(self.time)\\n else:\\n self.timer.stop()\",\n \"def timeout(self):\\n pf.debug(\\\"TIMEOUT\\\")\\n self.acceptData(TIMEOUT)\",\n \"def setTimeOut(self, timeout=6.0):\\n self.timeout = timeout\",\n \"def __window_setTimeout(self, f, delay):\\n self.__dict__['__timeout'].append(f)\",\n \"def stop_timer(self):\\n self.log.info(\\\"{} timer stopped ({} seconds)\\\".format(self.name, self.interval))\\n self.start_event.clear()\\n # self.count = self.interval / self.sleep_chunk\",\n \"def create_timer(function, time):\\n timer = Timer()\\n timer.timeout.connect(function)\\n timer.start(time)\\n timer.speed = time\\n return timer\",\n \"def on_tick(self, time):\\n pass\",\n \"def timed_msg(self, t_sec, msg):\\n self._msg_hdr(msg)\\n self.main_loop.set_alarm_in(t_sec, self._msg_cb, '')\",\n \"def reset_timeout (self, new_timeout):\\n self.timer.cancel()\\n self.timer = Timeout(new_timeout, TestIsTakingTooLong(new_timeout))\",\n \"def timer_object_timeout(seconds=5):\\n def raise_timeout_exception():\\n raise TimeoutReachedException(seconds=seconds)\\n\\n return Timer(seconds, raise_timeout_exception)\",\n \"def fire_timeouted(self):\\n fired = self._get_timeouted()\\n for timer in fired.keys():\\n if fired[timer][0] is None:\\n del fired[timer]\\n continue\\n try:\\n cb, arg, _, _ = fired[timer]\\n cb(arg)\\n except Exception, e:\\n # TODO for debugging purposes\\n self.logger.exception('Timer handler raised: %s' % e)\\n raise e\\n\\n # Update the timer\\n timer_type = fired[timer][2]\\n if timer_type == self.TIMER_REPEATED:\\n # delete it from the timers\\n self.delete(timer)\\n\\n # Add it again\\n cb, arg, _, secs = fired[timer]\\n self.add(secs=secs, cb=cb, arg=arg, timer_type=timer_type)\\n else:\\n self.delete(timer)\",\n \"def timer(self):\\n self.time_remaining -= 1\\n if self.time_remaining > 0:\\n Timer(1, self.timer).start()\",\n \"def bcp_timer(self, name, action, **kwargs):\\n\\n self.events.post('timer_' + name + '_' + action, **kwargs)\",\n \"def slot_timer(self, _sender, _data):\\r\\n if self.connected:\\r\\n if time.time() - self._time_last_received > 60:\\r\\n self.debug(\\\"### did not receive anything for a long time, disconnecting.\\\")\\r\\n self.force_reconnect()\\r\\n self.connected = False\\r\\n if time.time() - self._time_last_subscribed > 1800:\\r\\n # sometimes after running for a few hours it\\r\\n # will lose some of the subscriptons for no\\r\\n # obvious reason. I've seen it losing the trades\\r\\n # and the lag channel channel already, and maybe\\r\\n # even others. Simply subscribing again completely\\r\\n # fixes this condition. For this reason we renew\\r\\n # all channel subscriptions once every hour.\\r\\n self.debug(\\\"### refreshing channel subscriptions\\\")\\r\\n self.channel_subscribe(False)\",\n \"def timerEvent(self, event):\\n\\n if int(time.time()) - self.start_time > self.capture_duration:\\n self.stop_recording()\\n\\n recording, data = self.camera.read()\\n if recording:\\n self.image_data.emit(data)\",\n \"def watchdog_timer(state, wait=3):\\n time.sleep(wait)\\n if not state['completed']:\\n _thread.interrupt_main()\",\n \"def set_timeout(self, timeout):\\n pass\",\n \"def runAtIdle(self, aFunc: Callable) -> None:\\n QtCore.QTimer.singleShot(0, aFunc)\",\n \"def handler(signum, frame):\\n\\tglobal stop_flag\\n\\tstop_flag=True\\n\\tprint(\\\"Query timeout!!!!!!!!!!!\\\")\\n\\traise Exception(\\\"Timeout\\\")\",\n \"def _on_timer_complete(self, kwargs: dict) -> None:\\n self.log(\\\"Sleep timer over; turning switch off\\\")\\n\\n self.set_value(self.entity_ids[CONF_TIMER_SLIDER], 0)\",\n \"def timeout(self, timeout):\\n\\n self._timeout = timeout\",\n \"def start_handler():\\r\\n timer.start()\",\n \"def callback(self, fun: Callable[[Timer], None] | None, /) -> None:\",\n \"def callback(self, fun: Callable[[Timer], None] | None, /) -> None:\",\n \"def post(self, event):\\n self.queue.append(event)\\n if not self.timer.active:\\n self.timer.start(0)\",\n \"def pytest_timeout_cancel_timer(item):\\n tle.lib.cancel()\\n return True\",\n \"def OnTimer(self, event):\\n if self.timerNotZero: # When timer runs, subtract one second and update text\\n self.start_time = self.start_time.Subtract(wx.TimeSpan(0, sec=1))\\n self.timertext.SetLabel(self.start_time.Format(\\\"%M:%S\\\"))\\n if self.start_time.GetMinutes() == 0 and self.start_time.GetSeconds() == 0: # Timer reached zero\\n self.timerNotZero = False\\n self.button1.SetBackgroundColour('red')\\n else: # Once timer stops, makes the text blink red\\n if self.blinkPhase == 0:\\n self.timertext.SetForegroundColour('red')\\n self.timertext.SetLabel(\\\"00:00\\\")\\n self.blinkPhase = 1\\n elif self.blinkPhase == 1:\\n self.timertext.SetForegroundColour('black')\\n self.timertext.SetLabel(\\\"00:00\\\")\\n self.blinkPhase = 0\",\n \"def timer_canceled(self, timer):\\n try:\\n try:\\n timer.impltimer.stop()\\n del timer.impltimer\\n except (AttributeError, TypeError):\\n pass\\n finally:\\n super(Hub, self).timer_canceled(timer)\",\n \"def set_invoke_timer(self, timeout, retry_entry=False):\\n if self.timer_entry is not None and self.timer_entry.active:\\n self.timer_entry.deactivate()\\n #print(\\\"(%d) set_invoke_timer:\\\" % int(time.time()), timeout)\\n self.timer_entry = query_management.QueryEntry(expire_after=timeout,\\n callback_expire=self._perform_key_exchange,\\n retry_count=0)\\n if retry_entry:\\n self.timer_entry.data[KeyType.retry_timer] = True\",\n \"def rwsched_timer_callback(self, timer, user_data):\\n logger.info(\\\"**** Voila1 Python TIMER callback ****\\\")\\n logger.debug(timer)\\n logger.debug(user_data)\\n logger.debug(\\\"\\\\n\\\\n\\\")\",\n \"def update(self, func):\\n if self.current_time == 0:\\n func()\\n return\\n self.current_time -= 1\\n hours = self.current_time // 3600\\n minutes = self.current_time % 3600 // 60\\n seconds = self.current_time % 60\\n try:\\n self.timer_label.setText('%02d:%02d:%02d' % (hours, minutes, seconds))\\n if self.current_time <= 10:\\n self.timer_label.setStyleSheet('color: red')\\n Qt.QTimer().singleShot(1000, lambda: self.update(func))\\n except RuntimeError:\\n return\",\n \"def _slot_timer_info_later(self, _sender, _data):\\r\\n self.request_info()\\r\\n self._info_timer = None\",\n \"def check_timer():\\n end = time.time()\\n time_elapsed = end - target_time[0]\\n durationMSG = fg.cyan + f\\\"Scans Completed for {args.target} in: \\\" + fg.rs\\n print(durationMSG, display_time(time_elapsed))\",\n \"def _timeout(self):\\n self.inbox_.put_nowait(Atom('timeout'))\",\n \"def _handle_timeout(self, frame=None, **_):\\n\\n raise TimeOut.TimeOutError(self, frame)\",\n \"def on_sampling_timer(self, event):\\n self.sampling_timer.Stop()\",\n \"def settimeout(self, to):\\r\\n self._timeout = to\",\n \"def stop_timer(self):\\r\\n self.countdownTimer.stop()\",\n \"def timeout(self, timeout):\\n assert timeout is None or timeout > 0\\n self._timeout = timeout\",\n \"def _timeout(signum, frame):\\n # Raise TimeoutException with system default timeout message\\n raise TimeoutException()\",\n \"def timeout(time):\\n\\n def wrapper(f):\\n @wraps(f)\\n def wrapped_f(self, event, context):\\n return f(self, event, context)\\n\\n wrapped_f.timeout = time\\n return wrapped_f\\n\\n return wrapper\",\n \"def pytest_timeout_set_timer(item, settings):\\n tle.lib.set(int(settings.timeout), str(item).encode(\\\"utf-8\\\"))\\n return True\",\n \"def timeout(self):\\n self._status_update(\\\"Pyloton: Timeout\\\")\\n time.sleep(3)\",\n \"def reset_timer():\\n resetTimer = time.time()\\n target_time.clear()\\n target_time.append(resetTimer)\",\n \"def timer_update(self):\\n if self.mineboard.gamestate is not None:\\n return\\n time_so_far = round(time.time()-self.start_time)\\n if time_so_far == 1:\\n self.now.set(f\\\"Time so far: {time_so_far} second\\\")\\n else:\\n self.now.set(f\\\"Time so far: {time_so_far} seconds\\\")\\n self.after(1000, self.timer_update) # calls this function every second\",\n \"def __window_clearTimeout(self, timeoutID):\\n pass\",\n \"def timer_tick(self):\\n self.timing.timer_tick() # notifies the timing module\\n self.events.post('timer_tick') # sends the timer_tick system event\\n Task.timer_tick() # notifies tasks\\n DelayManager.timer_tick()\",\n \"def _banner_timeout(self):\\n self.hide_banner()\\n self._request_redraw()\\n self.sm.on_state_event(self.events.TIMEOUT)\",\n \"def timeout_change(self, timedelta):\\n pass # pylint: disable=unnecessary-pass\\n # For backward compatibility only.\",\n \"def __init__(self, timeout=120):\\n self.m_timeout = timeout\",\n \"def start(self):\\n self.end_time = time.time() + self.timeout_time\",\n \"def timer(self):\\n if self.board.reset_timer:\\n self.time_count.set(\\\"000\\\")\\n self.time_widget.config(text=self.time_count.get())\\n return 0\\n elif self.board.stop_timer:\\n return 0\\n now_time = time.time()\\n self.board.time = now_time - self.board.last_frame_time\\n self.time_count.set(self.numToStrLabel(int(self.board.time)))\\n self.time_widget.config(text=self.time_count.get())\\n self.board.time = self.board.last_frame_time\\n self.after(50, self.timer)\",\n \"def reset_timer(self, *_) -> \\\"ALL\\\":\\n self.last = time.time()\\n delta = time.time() - self.last\\n if delta > 180:\\n print(\\n \\\"!!! Warning: Watchdog failure detected, spawning a fallback \\\"\\n \\\"thread.\\\"\\n )\\n self.watchdog = FallbackWatchdog(self)\\n self.watchdog.start()\",\n \"def internal_event (self):\\n self.clock_time += 1\\n self.log()\",\n \"def doTimeout(self):\\n\\n log.info('Executed {} calls until timeout'.format(self.calls_to_timeout))\\n self.calls_to_timeout = 0\\n\\n self.resetSession()\\n time.sleep(self.timeout)\",\n \"def on_timer(self, event):\\n \\n o = Unicorn()\\n data = o.get_data(rt)\\n k = len(data[0])\\n y[:, :-k] = y[:, k:]\\n y[:, -k:] = remap((data), -40, 40, -1, 1 ) \\n t2 = _thread.start_new_thread(printT, ())\\n #y2 = np.array([lfilter(b, a, y[i]) for i in range(17)])\\n self.program['a_position'].set_data(y.ravel().astype(np.float32))\\n self.update()\",\n \"def checkTimeout(self):\\n if TIMEOUT <= (datetime.now() - self.clockCheckStop).total_seconds():\\n print('Didn\\\\'t received messages for 1 minute - Program ends')\\n exit(0)\",\n \"def _set_delete_timer(self, key_name, timeout):\\n if key_name is not None:\\n #print(\\\"(%d) _set_delete_timer:\\\" % int(time.time()), key_name.hex()[:10], timeout)\\n query_management.QueryEntry(expire_after=timeout, callback_expire=remove_old_key,\\n data={KeyType.hint: key_name}, retry_count=0)\",\n \"def terminate(self):\\n self.stop_timer()\\n self.terminate_event.set()\\n self.log.info(self.name + \\\" timer terminated\\\")\",\n \"def eventTimer(Event, Time1):\\n Time2 = time.time()\\n print((\\\"%4.2f\\\" % (Time2 - Time1), Event))\\n return Time2\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76686984","0.7486532","0.7313377","0.7291277","0.7181817","0.69615936","0.6915906","0.6821288","0.68168485","0.67896986","0.6762602","0.6755751","0.67511904","0.6695119","0.66732055","0.6667869","0.65977186","0.6574802","0.6542744","0.6540145","0.6537727","0.6528407","0.64854634","0.6474897","0.6463902","0.6448617","0.64445853","0.64392585","0.64307314","0.6421502","0.6401313","0.63815606","0.6361156","0.6335728","0.63353395","0.631984","0.63129073","0.6276879","0.6268285","0.625596","0.62178797","0.6204921","0.6203974","0.6188162","0.6186043","0.6184326","0.61821824","0.61785984","0.61736894","0.6172386","0.6169622","0.6162236","0.61614597","0.6158491","0.6152771","0.6145915","0.6143829","0.61381674","0.6127667","0.61108524","0.610793","0.6105176","0.61034644","0.6103106","0.6103106","0.6095242","0.6071209","0.6057473","0.60504454","0.6044036","0.60374916","0.60315084","0.6026312","0.6005391","0.6003441","0.5998282","0.5980894","0.5977512","0.5976887","0.5974916","0.59714115","0.59381795","0.5930862","0.5926775","0.5916677","0.59157324","0.5906558","0.5903288","0.58996135","0.58961415","0.5895831","0.5890186","0.5883329","0.58680475","0.5851027","0.58453655","0.58295524","0.5829423","0.5828614","0.58198166","0.58181745"],"string":"[\n \"0.76686984\",\n \"0.7486532\",\n \"0.7313377\",\n \"0.7291277\",\n \"0.7181817\",\n \"0.69615936\",\n \"0.6915906\",\n \"0.6821288\",\n \"0.68168485\",\n \"0.67896986\",\n \"0.6762602\",\n \"0.6755751\",\n \"0.67511904\",\n \"0.6695119\",\n \"0.66732055\",\n \"0.6667869\",\n \"0.65977186\",\n \"0.6574802\",\n \"0.6542744\",\n \"0.6540145\",\n \"0.6537727\",\n \"0.6528407\",\n \"0.64854634\",\n \"0.6474897\",\n \"0.6463902\",\n \"0.6448617\",\n \"0.64445853\",\n \"0.64392585\",\n \"0.64307314\",\n \"0.6421502\",\n \"0.6401313\",\n \"0.63815606\",\n \"0.6361156\",\n \"0.6335728\",\n \"0.63353395\",\n \"0.631984\",\n \"0.63129073\",\n \"0.6276879\",\n \"0.6268285\",\n \"0.625596\",\n \"0.62178797\",\n \"0.6204921\",\n \"0.6203974\",\n \"0.6188162\",\n \"0.6186043\",\n \"0.6184326\",\n \"0.61821824\",\n \"0.61785984\",\n \"0.61736894\",\n \"0.6172386\",\n \"0.6169622\",\n \"0.6162236\",\n \"0.61614597\",\n \"0.6158491\",\n \"0.6152771\",\n \"0.6145915\",\n \"0.6143829\",\n \"0.61381674\",\n \"0.6127667\",\n \"0.61108524\",\n \"0.610793\",\n \"0.6105176\",\n \"0.61034644\",\n \"0.6103106\",\n \"0.6103106\",\n \"0.6095242\",\n \"0.6071209\",\n \"0.6057473\",\n \"0.60504454\",\n \"0.6044036\",\n \"0.60374916\",\n \"0.60315084\",\n \"0.6026312\",\n \"0.6005391\",\n \"0.6003441\",\n \"0.5998282\",\n \"0.5980894\",\n \"0.5977512\",\n \"0.5976887\",\n \"0.5974916\",\n \"0.59714115\",\n \"0.59381795\",\n \"0.5930862\",\n \"0.5926775\",\n \"0.5916677\",\n \"0.59157324\",\n \"0.5906558\",\n \"0.5903288\",\n \"0.58996135\",\n \"0.58961415\",\n \"0.5895831\",\n \"0.5890186\",\n \"0.5883329\",\n \"0.58680475\",\n \"0.5851027\",\n \"0.58453655\",\n \"0.58295524\",\n \"0.5829423\",\n \"0.5828614\",\n \"0.58198166\",\n \"0.58181745\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":84796,"cells":{"query":{"kind":"string","value":"updating the direction information, revived from the client"},"document":{"kind":"string","value":"def update_player_direction(self,direction):\n pass"},"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_direction(self, update_data: dict):\n if self.on_update_direction:\n self.on_update_direction(self, update_data)","def _directionUpdated(self, *args, **kwargs):\n # Invert direction to manipulate the 'source' pointing to\n # the center of the viewport\n x, y, z = - self._light.direction\n\n # Horizontal plane is plane xz\n azimuth = int(round(numpy.degrees(numpy.arctan2(x, z))))\n altitude = int(round(numpy.degrees(numpy.pi/2. - numpy.arccos(y))))\n\n if azimuth != self.getAzimuthAngle():\n self.setAzimuthAngle(azimuth)\n\n if altitude != self.getAltitudeAngle():\n self.setAltitudeAngle(altitude)","def set_direction(self, new_dir):\n self.__direction = new_dir","def send_player_direction(self):\n pl_dir_dict = {}\n for pl in self.player_list:\n pl_dir_dict[pl.id] = pl.direction\n self.on_data_to_all_clients({\"game\":{\"player_dir\":pl_dir_dict}})","def move(self, direction):\r\n self.stored_direction = direction","def update(self):\n if self.dir == \"r\":\n self.vx = 10\n self.vy = 0\n elif self.dir == \"l\":\n self.vx = -10\n self.vy = 0\n elif self.dir == \"u\":\n self.vx = 0\n self.vy = -10\n elif self.dir == \"d\":\n self.vx = 0\n self.vy = 10\n elif self.dir == \"None\":\n self.vx = 0\n self.vy = 0\n self.x += self.vx\n self.y += self.vy","async def async_set_direction(self, direction: str) -> None:\n if direction == DIRECTION_FORWARD:\n self._device.fan_dir = SENSEME_DIRECTION_FORWARD\n else:\n self._device.fan_dir = SENSEME_DIRECTION_REVERSE","def set_direction(self, direction: str) -> None:\n if direction == \"forward\":\n self._bond.setDirection(self._deviceId, Directions.FORWARD)\n elif direction == \"reverse\":\n self._bond.setDirection(self._deviceId, Directions.REVERSE)\n self._attributes['current_direction'] = direction","def set_direction(self, dir):\n if dir == 0:\n self.direction = [0, -1]\n elif dir == 1:\n self.direction = [1, 0]\n elif dir == 2:\n self.direction = [0, 1]\n elif dir == 3:\n self.direction = [-1, 0]","def change_direction(self, direction):\r\n for event in pygame.event.get():\r\n if event.type == pygame.KEYDOWN:\r\n if event.key == pygame.K_ESCAPE:\r\n pygame.quit()\r\n sys.exit()\r\n elif event.key == pygame.K_UP:\r\n if self.direction == [0, 1]:\r\n self.direction == [0, 1]\r\n return self.direction\r\n else:\r\n self.direction = [dx, dy] = [0, -1]\r\n return self.direction\r\n elif event.key == pygame.K_DOWN:\r\n if self.direction == [0, -1]:\r\n self.direction == [0, -1]\r\n return self.direction\r\n else:\r\n self.direction = [dx, dy] = [0, 1]\r\n return self.direction\r\n elif event.key == pygame.K_LEFT:\r\n if self.direction == [1, 0]:\r\n self.direction == [1, 0]\r\n return self.direction\r\n else:\r\n self.direction = [dx, dy] = [-1, 0]\r\n return self.direction\r\n elif event.key == pygame.K_RIGHT:\r\n if self.direction == [-1, 0]:\r\n self.direction == [-1, 0]\r\n return self.direction\r\n else:\r\n self.direction = [dx, dy] = [1, 0]\r\n return self.direction","def direction(self, direction):\n\n self._direction = direction","def update(self):\n bondState = self._bond.getDeviceState(self._deviceId)\n if 'power' in bondState:\n self._state = True if bondState['power'] == 1 else False\n if self._state and bondState['speed'] in self._speed_name_by_value:\n self._attributes['current_speed'] = self._speed_name_by_value[bondState['speed']]\n else:\n self._attributes['current_speed'] = SPEED_OFF\n\n if 'direction' in bondState:\n if bondState['direction'] == Directions.REVERSE:\n self._attributes['current_direction'] = \"reverse\"\n else:\n self._attributes['current_direction'] = \"forward\"","async def test_direction_read(hass: HomeAssistant, utcnow) -> None:\n helper = await setup_test_component(hass, create_fan_service)\n\n state = await helper.async_update(\n ServicesTypes.FAN, {CharacteristicsTypes.ROTATION_DIRECTION: 0}\n )\n assert state.attributes[\"direction\"] == \"forward\"\n\n state = await helper.async_update(\n ServicesTypes.FAN, {CharacteristicsTypes.ROTATION_DIRECTION: 1}\n )\n assert state.attributes[\"direction\"] == \"reverse\"","def _update(self):\n self._execute_lane_changes()\n self._execute_forward_movement()","async def test_v2_direction_read(hass: HomeAssistant, utcnow) -> None:\n helper = await setup_test_component(hass, create_fanv2_service)\n\n state = await helper.async_update(\n ServicesTypes.FAN_V2, {CharacteristicsTypes.ROTATION_DIRECTION: 0}\n )\n assert state.attributes[\"direction\"] == \"forward\"\n\n state = await helper.async_update(\n ServicesTypes.FAN_V2, {CharacteristicsTypes.ROTATION_DIRECTION: 1}\n )\n assert state.attributes[\"direction\"] == \"reverse\"","def update(self):\n self.arest.update()","async def test_v2_set_direction(hass: HomeAssistant, utcnow) -> None:\n helper = await setup_test_component(hass, create_fanv2_service)\n\n await hass.services.async_call(\n \"fan\",\n \"set_direction\",\n {\"entity_id\": \"fan.testdevice\", \"direction\": \"reverse\"},\n blocking=True,\n )\n helper.async_assert_service_values(\n ServicesTypes.FAN_V2,\n {\n CharacteristicsTypes.ROTATION_DIRECTION: 1,\n },\n )\n\n await hass.services.async_call(\n \"fan\",\n \"set_direction\",\n {\"entity_id\": \"fan.testdevice\", \"direction\": \"forward\"},\n blocking=True,\n )\n helper.async_assert_service_values(\n ServicesTypes.FAN_V2,\n {\n CharacteristicsTypes.ROTATION_DIRECTION: 0,\n },\n )","def update():","def update():","def update(direction): \n if direction == 3:\n head[0] -=1\n elif direction == 2:\n head[0] += 1\n elif direction == 1:\n head[1] -= 1\n elif direction == 0:\n head[1] += 1\n \n screen.refresh()\n time.sleep(0.1)","def update(self,update_flags):\n pass","async def test_set_direction(hass: HomeAssistant, utcnow) -> None:\n helper = await setup_test_component(hass, create_fan_service)\n\n await hass.services.async_call(\n \"fan\",\n \"set_direction\",\n {\"entity_id\": \"fan.testdevice\", \"direction\": \"reverse\"},\n blocking=True,\n )\n helper.async_assert_service_values(\n ServicesTypes.FAN,\n {\n CharacteristicsTypes.ROTATION_DIRECTION: 1,\n },\n )\n\n await hass.services.async_call(\n \"fan\",\n \"set_direction\",\n {\"entity_id\": \"fan.testdevice\", \"direction\": \"forward\"},\n blocking=True,\n )\n helper.async_assert_service_values(\n ServicesTypes.FAN,\n {\n CharacteristicsTypes.ROTATION_DIRECTION: 0,\n },\n )","def move(self, direction):\n # replace with your code\n pass","def move(self, direction):\n # replace with your code\n pass","def _update_distance_(self):\n pass","def setDirection(self,stepDir = 2):\n pass","def setdirection(self, *args, **kwargs):\n return _coordsys.coordsys_setdirection(self, *args, **kwargs)","def updateDest(self):\n\n\t\t# if end is reached stop calling\n\t\tif self.i == self.numSteps:\n\t\t\treturn False\n\n\t\t# controller\n\t\tpoint = self.control.nextUpPD(self.i)\n\t\tcommand_string = 'id1 mav.waypoint_actuator setdest [%s, %s, %s, %s, 0.2] \\n' % (\n\t\t\tpoint[0], point[1], point[2], point[3])\n\t\tcomm.write(bytes(command_string, 'utf8'))\n\n\t\tself.i = self.i + 1\n\t\treturn GLib.SOURCE_CONTINUE","def change_direction(self, event):\n if event.keysym in self.mapping:\n self.vector = self.mapping[event.keysym]","def update_position(self):\n self.back = self.pos % self.road_len\n self.front = (self.pos + self.length) % self.road_len","def update_direction(self, move : np.ndarray, direction: np.ndarray):\r\n pos = move.copy()\r\n \r\n\r\n pos += direction\r\n while(self.in_board(pos)):\r\n if self.board[pos[0],pos[1]] == self.turn:\r\n pos -= direction\r\n while((pos != move).any()):\r\n self.board[pos[0], pos[1]] = self.turn\r\n self.count += 1\r\n pos -= direction\r\n break\r\n\r\n elif self.board[pos[0],pos[1]] == 0:\r\n\r\n break\r\n else:\r\n pos += direction","def sendDirection(self,direction):\n x,y = direction\n data = _RobotCommunicator.DIRECTION_HEADER + \\\n pack(_RobotCommunicator.DIRECTION_FORMAT,x,y)\n self.udpSock.sendto(data,self.addr)","def move(self, direction):\n pass","def update(self):\n\n pass","def update( ):\r\n pass","def update_turn(self):\n pass","def update_dir(self, key):\r\n\r\n \r\n if key == K_UP:\r\n self.last_dir = 'u' \r\n elif key == K_DOWN:\r\n self.last_dir = 'd'\r\n elif key == K_RIGHT:\r\n self.last_dir = 'r' \r\n elif key == K_LEFT:\r\n self.last_dir = 'l' \r\n pass","def set_direction(self, right_or_left):\r\n if right_or_left == \"r\":\r\n self.__direction = self.__direction - 7\r\n elif right_or_left == \"l\":\r\n self.__direction = self.__direction + 7","def update(self):\n self.updateCount = self.updateCount + 1\n if self.updateCount > self.updateCountMax:\n\n # update previous positions\n for i in range(self.length - 1, 0, -1):\n self.x[i] = self.x[i - 1]\n self.y[i] = self.y[i - 1]\n\n # update position of player : party lead\n if self.direction == 0:\n self.x[0] = self.x[0] + self.step\n if self.direction == 1:\n self.x[0] = self.x[0] - self.step\n if self.direction == 2:\n self.y[0] = self.y[0] - self.step\n if self.direction == 3:\n self.y[0] = self.y[0] + self.step\n\n self.updateCount = 0","def setDirection (self, ra, dec):\n self._response.setDirection(ra, dec)","def update_info(self, ego_pos, ego_spd):\n self.current_transform = ego_pos\n self.current_speed = ego_spd\n if self.dynamic:\n self.dynamic_pid()","def change_pos(self, direction):\n if direction == Direction.UP:\n self._y_pos -= 1\n elif direction == Direction.DOWN:\n self._y_pos += 1\n elif direction == Direction.LEFT:\n self._x_pos -= 1\n elif direction == Direction.RIGHT:\n self._x_pos += 1\n self._coordinates = self.coordinates()","def update_direction(self):\n direction = self.get_direction()\n\n if direction[1] == NORTH[1]:\n self.current_animation = N_ANIM \n elif direction[1] == SOUTH[1]:\n self.current_animation = S_ANIM \n elif direction[0] == EAST[0]:\n self.current_animation = E_ANIM \n else:\n self.current_animation = W_ANIM","def set_direction(self, direction: str) -> None:\n self.wink.set_fan_direction(direction)","def update_and_send_elevator_info(self):\n\t\tself.networkHandler.networkSender.elevatorInfo = {'currentFloor': self.currentFloor, 'direction': self.find_direction(), 'orderQueue': self.orderQueue.get_copy()}\n\t\tself.orderQueue.save_to_file()","def getDirection(self):\n if 'N' in str(self.trip_update.trip.trip_id):\n direction = 'northbound'\n if 'S' in str(self.trip_update.trip.trip_id):\n direction = 'southbound'\n return direction","def setPath(self, request, context):\n \n cmds = self.vehicle.commands\n coordFrame, alt = None, None\n waypoints = []\n \n # The idea behind stripping off the first position is to determine what reference frame to\n # to use. Future proto changes will removed the coordinate frame boolean flag from the \n # request making the code unnecessary. For now, this is the way it is.\n firstPosition = nth(request, 0)\n lat = firstPosition.lat\n lon = firstPosition.lon\n \n useRelativeAltitude = firstPosition.useRelativeAltitude\n \n if useRelativeAltitude:\n alt = firstPosition.relativeAltitude\n coordFrame = mavutil.mavlink.MAV_FRAME_GLOBAL_RELATIVE_ALT\n else:\n alt = firstPosition.gpsAltitude\n coordFrame = mavutil.mavlink.MAV_FRAME_GLOBAL\n\n print ('First position at ({0},{1}) -> {2}'.format(lat, lon, alt))\n waypoints.append([lat, lon, alt])\n nextIndex = self.vehicle.commands.next\n # Make sure the drone is not in AUTO mode. \n #self.vehicle.mode = VehicleMode(\"LOITER\")\n self.clear_mission(cmds, coordFrame)\n \n # Add first position\n cmds.add(Command( 0, 0, 0, coordFrame, mavutil.mavlink.MAV_CMD_NAV_WAYPOINT, 0, 0, 0, 0, 0, 0, lat, lon, alt))\n \n # Add the remaining positions\n for position in request:\n lat = position.lat\n lon = position.lon\n if useRelativeAltitude:\n alt = position.relativeAltitude\n else:\n alt = position.gpsAltitude\n print ('Point at ({0},{1}) -> {2}'.format(lat, lon, alt))\n cmds.add(Command( 0, 0, 0, coordFrame, mavutil.mavlink.MAV_CMD_NAV_WAYPOINT, 0, 0, 0, 0, 0, 0, lat, lon, alt))\n waypoints.append([lat, lon, alt])\n \n print (\"Uploading new commands to drone\")\n cmds.upload()\n \n # Reset mission set to first (0) waypoint\n #if self.vehicle.commands.next !=0:\n # print \"Continuing mission...\"\n #else:\n # print \"Starting mission\"\n # self.vehicle.commands.next = 0\n if len(self.vehicle.waypoints)==0:\n print \"Starting mission\"\n self.vehicle.commands.next = 0\n else:\n print \"Continuing mission...\"\n self.vehicle.commands.next = nextIndex\n \n self.vehicle.waypoints = waypoints \n self.vehicle.mode = VehicleMode(\"AUTO\")\n \n self.print_mission() \n \n return droneconnect_pb2.Null()","def sendDirection(self,direction):\n self.broadcaster.sendDirection(direction)","def direction(self):\n _direction = self._custom.get(\"direction\")\n if _direction is not None:\n return _direction\n\n _direction = self._infer_direction()\n self._custom[\"direction\"] = _direction\n\n return _direction","def motorsDirection(self, direction):\n\n print (direction)\n if direction == 'r' or direction == 'R':\n self.motorDirection(self.motor1DirectionPin, self.motorReverse)\n self.motorDirection(self.motor2DirectionPin, self.motorReverse)\n print (\"Direction reverse\")\n else:\n self.motorDirection(self.motor1DirectionPin, self.motorForward)\n self.motorDirection(self.motor2DirectionPin, self.motorForward)\n print (\"Direction forward\")","def update(self):\n self._state = None\n self._attributes = {}\n\n vehicles = self._api.get_vehicles(self._latitude, self._longitude)\n scooter = {}\n\n if vehicles:\n for vehicle in vehicles:\n location_vehicle = (vehicle[\"location\"][0], vehicle[\"location\"][1])\n location_hass = (self._latitude, self._longitude)\n vehicle[\"distance\"] = distance(location_vehicle, location_hass).m\n\n scooter = sorted(vehicles, key=lambda item: item[\"distance\"])[0]\n\n if scooter:\n self._state = round(scooter[\"distance\"])\n self._attributes[ATTR_LATITUDE] = round(scooter[\"location\"][0], 5)\n self._attributes[ATTR_LONGITUDE] = round(scooter[\"location\"][1], 5)\n self._attributes[ATTR_BATTERY_LEVEL] = round(scooter[\"battery\"])\n self._attributes[ATTR_ATTRIBUTION] = ATTRIBUTION","def move(self, direction):\n # Store the values in the connection dictionary in a list\n self.room_num = self.current_room.connection[direction]\n\n # Check if there is a conditional movement and change the current room\n if len(self.room_num) == 1:\n self.current_room = self.rooms[int(self.room_num[0]) - 1]\n else:\n adventure.check(len(self.room_num))","def update(self):\n return_code, pos_new = sim.simxGetObjectPosition(self.clientID, self.from_handle, self.to_handle, sim.simx_opmode_streaming)\n self.distance = np.linalg.norm(np.asarray(pos_new))","def _update(self):\n pass","def send_update(self, neighbor):\n message = 'ROUTE UPDATE'\n source = ':'.join([self.name[0], str(self.name[1])])\n dv = []\n for others in self.distance_vector:\n others_sep = others.split(':')\n dv.append(','.join([others_sep[0], others_sep[1], str(self.distance_vector[others].cost)]))\n dv = '\\n'.join(dv)\n to_send = '\\n'.join([message, source, dv])\n neighbor.sok.sendto(to_send, (neighbor.addr, neighbor.port))\n neighbor.send_timer = time.time()\n neighbor.update_ready = False","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def update(self):\n pass","def move(self, direction):\n\n if direction == \"north\":\n self.go_and_update(-1, 0)\n\n elif direction == \"south\":\n self.go_and_update(1, 0)\n\n elif direction == \"east\":\n self.go_and_update(0, 1)\n\n elif direction == \"west\":\n self.go_and_update(0, -1)","def _change_fleet_direction(self):\n for alien in self.aliens.sprites():\n alien.rect.x -= self.settings.fleet_approach_speed\n self.settings.fleet_direction *= -1","def _change_fleet_direction(self):\n\t\tfor auto in self.autos.sprites():\n\t\t\tauto.rect.y -= self.settings.fleet_rise_speed\n\t\tself.settings.fleet_direction *= -1","def _update_(self):\n self._update_distance_()\n self._check_literature_name_()","def _update_transition(self, dt, time, direction): #pylint:disable-msg=C0103,C0301\r\n pass","def get_direction(self):\r\n return self.__direction","def update(self):\r\n pass","def adjust_starting_position(self, direction):\n\n direction = 1 if direction in [\"left\", 1] else -1\n\n self.angle = direction * 25\n self.distance = 12\n self.drive_thread.reset()\n\n while self.drive_thread.driven_distance < self.distance:\n time.sleep(0.1)\n\n self.angle = 0\n self.distance = 12\n self.drive_thread.reset()\n\n while self.drive_thread.driven_distance < self.distance:\n time.sleep(0.1)\n\n self.angle = direction * -25\n self.distance = 12\n self.drive_thread.reset()\n\n while self.drive_thread.driven_distance < self.distance:\n time.sleep(0.1)","def _update(self):\r\n\r\n\r\n\r\n\r\n trafficdata = {'name': self.road_name,\r\n 'city': self.city,\r\n 'key' : self.api_key,\r\n }\r\n\r\n trafficdata = urllib.parse.urlencode(trafficdata)\r\n ret = urllib.request.urlopen(\"%s?%s\" % (\"http://restapi.amap.com/v3/traffic/status/road\", trafficdata))\r\n if ret.status != 200:\r\n _Log.error('http get data Error StatusCode:%s' % ret.status)\r\n return\r\n res = ret.read().decode('utf-8')\r\n\r\n json_obj = json.loads(res)\r\n if not 'trafficinfo' in json_obj:\r\n _Log.error('Json Status Error1!')\r\n return\r\n if not 'description' in json_obj['trafficinfo']:\r\n _Log.error('No traffic data in json!')\r\n return\r\n self.data = json_obj","def updateOmLocation(self):\n if self.om != None:\n self.om.current_loc = self.destinations[self.current_loc]","def update_route(self, vrpdata):\n self.distance = 0\n self.quantity = 0\n self.tourValid = False\n lastc = 0 # first entry is depot\n for c in self.route:\n self.distance += vrpdata.DistMatrix[lastc][c]\n self.quantity += vrpdata.CustDem[c]\n lastc = c\n self.distance += vrpdata.DistMatrix[lastc][0] # last entry is depot\n self.tourValid = (self.quantity <= vrpdata.MaxVehCap)","def update(self):","def update(self):","def update(self):","def update(self) -> None:\n ...","def update(self):\n try:\n response = requests.get('{}/digital/{}'.format(\n self._resource, self._pin), timeout=10)\n self.data = {'state': response.json()['return_value']}\n except requests.exceptions.ConnectionError:\n _LOGGER.error(\"No route to device '%s'. Is device offline?\",\n self._resource)","def updatePos(self):\n self.timeDriving +=1\n self.pos[0] += self.vx\n self.pos[1] += self.vy","def update(self, pos):\n\t\tpass","def update_tlm(self):","def update_goal(self):\n pass","def move(self, direction):\n path = self.location.get_path(direction)\n if path is not None:\n if not path.blocked:\n # exit current location\n self.location.exit()\n\n # enter new location\n self.location = path.destination\n self.location.enter()\n\n self.on_move.trigger()\n else:\n self.echo(self.text(\"PATH_BLOCKED\", direction=direction))\n else:\n self.echo(self.text(\"NO_PATH\", direction=direction))","def get_direction(self):\n return self.direction","def update(self, match='inv', *args, **kwargs):\n if match == 'inv':\n self._link()\n self._get_atoms()\n self._get_distances()\n self._find_molecules()\n\n if match == 'inv':\n # self._get_code_atom_links()\n self._get_prochirality()\n # ===================================================================\n # self._get_orientations()\n #===================================================================\n self._transfer_adp()\n elif match == 'geom':\n self._match_molecules()\n elif match == 'trust':\n self._trust_molecules()\n else:\n apd_exit(1, 'Unknown ADP transfer method. Use inv/geom/trust.')\n self._update_H_ADP()","def move_in_direction(self, direction):\n if direction == NORTH:\n self.__position[y] += 1\n elif direction == NORTHEAST:\n self.__position[x] += 1\n self.__position[y] += 1\n elif direction == EAST:\n self.__position[x] += 1\n elif direction == SOUTHEAST:\n self.__position[x] += 1\n self.__position[y] -= 1\n elif direction == SOUTH:\n self.__position[y] -= 1\n elif direction == SOUTHWEST:\n self.__position[x] -= 1\n self.__position[y] -= 1\n elif direction == WEST:\n self.__position[x] -= 1\n elif direction == NORTHWEST:\n self.__position[x] -= 1\n self.__position[y] += 1","def direction(self):\n return self._direction.copy()","def update(self) -> None:\n destination = self._get_local_dest(self.path)\n\n try:\n path_type = self._get_path_type(self.absolute)\n handler = self.factory.get_handler(path_type)\n handler.update(self.absolute, destination)\n except Exception as e:\n print(f\"[!] Skipping {self.path}: {e}\")","def update_normal(self):\n options = self.get_direction_options()\n if self.is_at_intersection() or self.last_position == (self.rect.centerx, self.rect.centery):\n self.direction = self.get_chase_direction(options)\n if self.direction == 'u' and 'u' in options:\n self.rect.centery -= self.speed\n elif self.direction == 'l' and 'l' in options:\n self.rect.centerx -= self.speed\n elif self.direction == 'd' and 'd' in options:\n self.rect.centery += self.speed\n elif self.direction == 'r' and 'r' in options:\n self.rect.centerx += self.speed\n self.change_eyes(self.direction or 'r') # default look direction to right\n self.image = self.norm_images.next_image()","def update(self, **options):\n pass","def _move(self):\n self.pos += self.direction # add direction vector\n self.direction += self.gravity # add gravity to direction\n self.direction = self.direction.elementwise() * self.drag # apply drag to direction","def updateServePosition(self):\n pass"],"string":"[\n \"def update_direction(self, update_data: dict):\\n if self.on_update_direction:\\n self.on_update_direction(self, update_data)\",\n \"def _directionUpdated(self, *args, **kwargs):\\n # Invert direction to manipulate the 'source' pointing to\\n # the center of the viewport\\n x, y, z = - self._light.direction\\n\\n # Horizontal plane is plane xz\\n azimuth = int(round(numpy.degrees(numpy.arctan2(x, z))))\\n altitude = int(round(numpy.degrees(numpy.pi/2. - numpy.arccos(y))))\\n\\n if azimuth != self.getAzimuthAngle():\\n self.setAzimuthAngle(azimuth)\\n\\n if altitude != self.getAltitudeAngle():\\n self.setAltitudeAngle(altitude)\",\n \"def set_direction(self, new_dir):\\n self.__direction = new_dir\",\n \"def send_player_direction(self):\\n pl_dir_dict = {}\\n for pl in self.player_list:\\n pl_dir_dict[pl.id] = pl.direction\\n self.on_data_to_all_clients({\\\"game\\\":{\\\"player_dir\\\":pl_dir_dict}})\",\n \"def move(self, direction):\\r\\n self.stored_direction = direction\",\n \"def update(self):\\n if self.dir == \\\"r\\\":\\n self.vx = 10\\n self.vy = 0\\n elif self.dir == \\\"l\\\":\\n self.vx = -10\\n self.vy = 0\\n elif self.dir == \\\"u\\\":\\n self.vx = 0\\n self.vy = -10\\n elif self.dir == \\\"d\\\":\\n self.vx = 0\\n self.vy = 10\\n elif self.dir == \\\"None\\\":\\n self.vx = 0\\n self.vy = 0\\n self.x += self.vx\\n self.y += self.vy\",\n \"async def async_set_direction(self, direction: str) -> None:\\n if direction == DIRECTION_FORWARD:\\n self._device.fan_dir = SENSEME_DIRECTION_FORWARD\\n else:\\n self._device.fan_dir = SENSEME_DIRECTION_REVERSE\",\n \"def set_direction(self, direction: str) -> None:\\n if direction == \\\"forward\\\":\\n self._bond.setDirection(self._deviceId, Directions.FORWARD)\\n elif direction == \\\"reverse\\\":\\n self._bond.setDirection(self._deviceId, Directions.REVERSE)\\n self._attributes['current_direction'] = direction\",\n \"def set_direction(self, dir):\\n if dir == 0:\\n self.direction = [0, -1]\\n elif dir == 1:\\n self.direction = [1, 0]\\n elif dir == 2:\\n self.direction = [0, 1]\\n elif dir == 3:\\n self.direction = [-1, 0]\",\n \"def change_direction(self, direction):\\r\\n for event in pygame.event.get():\\r\\n if event.type == pygame.KEYDOWN:\\r\\n if event.key == pygame.K_ESCAPE:\\r\\n pygame.quit()\\r\\n sys.exit()\\r\\n elif event.key == pygame.K_UP:\\r\\n if self.direction == [0, 1]:\\r\\n self.direction == [0, 1]\\r\\n return self.direction\\r\\n else:\\r\\n self.direction = [dx, dy] = [0, -1]\\r\\n return self.direction\\r\\n elif event.key == pygame.K_DOWN:\\r\\n if self.direction == [0, -1]:\\r\\n self.direction == [0, -1]\\r\\n return self.direction\\r\\n else:\\r\\n self.direction = [dx, dy] = [0, 1]\\r\\n return self.direction\\r\\n elif event.key == pygame.K_LEFT:\\r\\n if self.direction == [1, 0]:\\r\\n self.direction == [1, 0]\\r\\n return self.direction\\r\\n else:\\r\\n self.direction = [dx, dy] = [-1, 0]\\r\\n return self.direction\\r\\n elif event.key == pygame.K_RIGHT:\\r\\n if self.direction == [-1, 0]:\\r\\n self.direction == [-1, 0]\\r\\n return self.direction\\r\\n else:\\r\\n self.direction = [dx, dy] = [1, 0]\\r\\n return self.direction\",\n \"def direction(self, direction):\\n\\n self._direction = direction\",\n \"def update(self):\\n bondState = self._bond.getDeviceState(self._deviceId)\\n if 'power' in bondState:\\n self._state = True if bondState['power'] == 1 else False\\n if self._state and bondState['speed'] in self._speed_name_by_value:\\n self._attributes['current_speed'] = self._speed_name_by_value[bondState['speed']]\\n else:\\n self._attributes['current_speed'] = SPEED_OFF\\n\\n if 'direction' in bondState:\\n if bondState['direction'] == Directions.REVERSE:\\n self._attributes['current_direction'] = \\\"reverse\\\"\\n else:\\n self._attributes['current_direction'] = \\\"forward\\\"\",\n \"async def test_direction_read(hass: HomeAssistant, utcnow) -> None:\\n helper = await setup_test_component(hass, create_fan_service)\\n\\n state = await helper.async_update(\\n ServicesTypes.FAN, {CharacteristicsTypes.ROTATION_DIRECTION: 0}\\n )\\n assert state.attributes[\\\"direction\\\"] == \\\"forward\\\"\\n\\n state = await helper.async_update(\\n ServicesTypes.FAN, {CharacteristicsTypes.ROTATION_DIRECTION: 1}\\n )\\n assert state.attributes[\\\"direction\\\"] == \\\"reverse\\\"\",\n \"def _update(self):\\n self._execute_lane_changes()\\n self._execute_forward_movement()\",\n \"async def test_v2_direction_read(hass: HomeAssistant, utcnow) -> None:\\n helper = await setup_test_component(hass, create_fanv2_service)\\n\\n state = await helper.async_update(\\n ServicesTypes.FAN_V2, {CharacteristicsTypes.ROTATION_DIRECTION: 0}\\n )\\n assert state.attributes[\\\"direction\\\"] == \\\"forward\\\"\\n\\n state = await helper.async_update(\\n ServicesTypes.FAN_V2, {CharacteristicsTypes.ROTATION_DIRECTION: 1}\\n )\\n assert state.attributes[\\\"direction\\\"] == \\\"reverse\\\"\",\n \"def update(self):\\n self.arest.update()\",\n \"async def test_v2_set_direction(hass: HomeAssistant, utcnow) -> None:\\n helper = await setup_test_component(hass, create_fanv2_service)\\n\\n await hass.services.async_call(\\n \\\"fan\\\",\\n \\\"set_direction\\\",\\n {\\\"entity_id\\\": \\\"fan.testdevice\\\", \\\"direction\\\": \\\"reverse\\\"},\\n blocking=True,\\n )\\n helper.async_assert_service_values(\\n ServicesTypes.FAN_V2,\\n {\\n CharacteristicsTypes.ROTATION_DIRECTION: 1,\\n },\\n )\\n\\n await hass.services.async_call(\\n \\\"fan\\\",\\n \\\"set_direction\\\",\\n {\\\"entity_id\\\": \\\"fan.testdevice\\\", \\\"direction\\\": \\\"forward\\\"},\\n blocking=True,\\n )\\n helper.async_assert_service_values(\\n ServicesTypes.FAN_V2,\\n {\\n CharacteristicsTypes.ROTATION_DIRECTION: 0,\\n },\\n )\",\n \"def update():\",\n \"def update():\",\n \"def update(direction): \\n if direction == 3:\\n head[0] -=1\\n elif direction == 2:\\n head[0] += 1\\n elif direction == 1:\\n head[1] -= 1\\n elif direction == 0:\\n head[1] += 1\\n \\n screen.refresh()\\n time.sleep(0.1)\",\n \"def update(self,update_flags):\\n pass\",\n \"async def test_set_direction(hass: HomeAssistant, utcnow) -> None:\\n helper = await setup_test_component(hass, create_fan_service)\\n\\n await hass.services.async_call(\\n \\\"fan\\\",\\n \\\"set_direction\\\",\\n {\\\"entity_id\\\": \\\"fan.testdevice\\\", \\\"direction\\\": \\\"reverse\\\"},\\n blocking=True,\\n )\\n helper.async_assert_service_values(\\n ServicesTypes.FAN,\\n {\\n CharacteristicsTypes.ROTATION_DIRECTION: 1,\\n },\\n )\\n\\n await hass.services.async_call(\\n \\\"fan\\\",\\n \\\"set_direction\\\",\\n {\\\"entity_id\\\": \\\"fan.testdevice\\\", \\\"direction\\\": \\\"forward\\\"},\\n blocking=True,\\n )\\n helper.async_assert_service_values(\\n ServicesTypes.FAN,\\n {\\n CharacteristicsTypes.ROTATION_DIRECTION: 0,\\n },\\n )\",\n \"def move(self, direction):\\n # replace with your code\\n pass\",\n \"def move(self, direction):\\n # replace with your code\\n pass\",\n \"def _update_distance_(self):\\n pass\",\n \"def setDirection(self,stepDir = 2):\\n pass\",\n \"def setdirection(self, *args, **kwargs):\\n return _coordsys.coordsys_setdirection(self, *args, **kwargs)\",\n \"def updateDest(self):\\n\\n\\t\\t# if end is reached stop calling\\n\\t\\tif self.i == self.numSteps:\\n\\t\\t\\treturn False\\n\\n\\t\\t# controller\\n\\t\\tpoint = self.control.nextUpPD(self.i)\\n\\t\\tcommand_string = 'id1 mav.waypoint_actuator setdest [%s, %s, %s, %s, 0.2] \\\\n' % (\\n\\t\\t\\tpoint[0], point[1], point[2], point[3])\\n\\t\\tcomm.write(bytes(command_string, 'utf8'))\\n\\n\\t\\tself.i = self.i + 1\\n\\t\\treturn GLib.SOURCE_CONTINUE\",\n \"def change_direction(self, event):\\n if event.keysym in self.mapping:\\n self.vector = self.mapping[event.keysym]\",\n \"def update_position(self):\\n self.back = self.pos % self.road_len\\n self.front = (self.pos + self.length) % self.road_len\",\n \"def update_direction(self, move : np.ndarray, direction: np.ndarray):\\r\\n pos = move.copy()\\r\\n \\r\\n\\r\\n pos += direction\\r\\n while(self.in_board(pos)):\\r\\n if self.board[pos[0],pos[1]] == self.turn:\\r\\n pos -= direction\\r\\n while((pos != move).any()):\\r\\n self.board[pos[0], pos[1]] = self.turn\\r\\n self.count += 1\\r\\n pos -= direction\\r\\n break\\r\\n\\r\\n elif self.board[pos[0],pos[1]] == 0:\\r\\n\\r\\n break\\r\\n else:\\r\\n pos += direction\",\n \"def sendDirection(self,direction):\\n x,y = direction\\n data = _RobotCommunicator.DIRECTION_HEADER + \\\\\\n pack(_RobotCommunicator.DIRECTION_FORMAT,x,y)\\n self.udpSock.sendto(data,self.addr)\",\n \"def move(self, direction):\\n pass\",\n \"def update(self):\\n\\n pass\",\n \"def update( ):\\r\\n pass\",\n \"def update_turn(self):\\n pass\",\n \"def update_dir(self, key):\\r\\n\\r\\n \\r\\n if key == K_UP:\\r\\n self.last_dir = 'u' \\r\\n elif key == K_DOWN:\\r\\n self.last_dir = 'd'\\r\\n elif key == K_RIGHT:\\r\\n self.last_dir = 'r' \\r\\n elif key == K_LEFT:\\r\\n self.last_dir = 'l' \\r\\n pass\",\n \"def set_direction(self, right_or_left):\\r\\n if right_or_left == \\\"r\\\":\\r\\n self.__direction = self.__direction - 7\\r\\n elif right_or_left == \\\"l\\\":\\r\\n self.__direction = self.__direction + 7\",\n \"def update(self):\\n self.updateCount = self.updateCount + 1\\n if self.updateCount > self.updateCountMax:\\n\\n # update previous positions\\n for i in range(self.length - 1, 0, -1):\\n self.x[i] = self.x[i - 1]\\n self.y[i] = self.y[i - 1]\\n\\n # update position of player : party lead\\n if self.direction == 0:\\n self.x[0] = self.x[0] + self.step\\n if self.direction == 1:\\n self.x[0] = self.x[0] - self.step\\n if self.direction == 2:\\n self.y[0] = self.y[0] - self.step\\n if self.direction == 3:\\n self.y[0] = self.y[0] + self.step\\n\\n self.updateCount = 0\",\n \"def setDirection (self, ra, dec):\\n self._response.setDirection(ra, dec)\",\n \"def update_info(self, ego_pos, ego_spd):\\n self.current_transform = ego_pos\\n self.current_speed = ego_spd\\n if self.dynamic:\\n self.dynamic_pid()\",\n \"def change_pos(self, direction):\\n if direction == Direction.UP:\\n self._y_pos -= 1\\n elif direction == Direction.DOWN:\\n self._y_pos += 1\\n elif direction == Direction.LEFT:\\n self._x_pos -= 1\\n elif direction == Direction.RIGHT:\\n self._x_pos += 1\\n self._coordinates = self.coordinates()\",\n \"def update_direction(self):\\n direction = self.get_direction()\\n\\n if direction[1] == NORTH[1]:\\n self.current_animation = N_ANIM \\n elif direction[1] == SOUTH[1]:\\n self.current_animation = S_ANIM \\n elif direction[0] == EAST[0]:\\n self.current_animation = E_ANIM \\n else:\\n self.current_animation = W_ANIM\",\n \"def set_direction(self, direction: str) -> None:\\n self.wink.set_fan_direction(direction)\",\n \"def update_and_send_elevator_info(self):\\n\\t\\tself.networkHandler.networkSender.elevatorInfo = {'currentFloor': self.currentFloor, 'direction': self.find_direction(), 'orderQueue': self.orderQueue.get_copy()}\\n\\t\\tself.orderQueue.save_to_file()\",\n \"def getDirection(self):\\n if 'N' in str(self.trip_update.trip.trip_id):\\n direction = 'northbound'\\n if 'S' in str(self.trip_update.trip.trip_id):\\n direction = 'southbound'\\n return direction\",\n \"def setPath(self, request, context):\\n \\n cmds = self.vehicle.commands\\n coordFrame, alt = None, None\\n waypoints = []\\n \\n # The idea behind stripping off the first position is to determine what reference frame to\\n # to use. Future proto changes will removed the coordinate frame boolean flag from the \\n # request making the code unnecessary. For now, this is the way it is.\\n firstPosition = nth(request, 0)\\n lat = firstPosition.lat\\n lon = firstPosition.lon\\n \\n useRelativeAltitude = firstPosition.useRelativeAltitude\\n \\n if useRelativeAltitude:\\n alt = firstPosition.relativeAltitude\\n coordFrame = mavutil.mavlink.MAV_FRAME_GLOBAL_RELATIVE_ALT\\n else:\\n alt = firstPosition.gpsAltitude\\n coordFrame = mavutil.mavlink.MAV_FRAME_GLOBAL\\n\\n print ('First position at ({0},{1}) -> {2}'.format(lat, lon, alt))\\n waypoints.append([lat, lon, alt])\\n nextIndex = self.vehicle.commands.next\\n # Make sure the drone is not in AUTO mode. \\n #self.vehicle.mode = VehicleMode(\\\"LOITER\\\")\\n self.clear_mission(cmds, coordFrame)\\n \\n # Add first position\\n cmds.add(Command( 0, 0, 0, coordFrame, mavutil.mavlink.MAV_CMD_NAV_WAYPOINT, 0, 0, 0, 0, 0, 0, lat, lon, alt))\\n \\n # Add the remaining positions\\n for position in request:\\n lat = position.lat\\n lon = position.lon\\n if useRelativeAltitude:\\n alt = position.relativeAltitude\\n else:\\n alt = position.gpsAltitude\\n print ('Point at ({0},{1}) -> {2}'.format(lat, lon, alt))\\n cmds.add(Command( 0, 0, 0, coordFrame, mavutil.mavlink.MAV_CMD_NAV_WAYPOINT, 0, 0, 0, 0, 0, 0, lat, lon, alt))\\n waypoints.append([lat, lon, alt])\\n \\n print (\\\"Uploading new commands to drone\\\")\\n cmds.upload()\\n \\n # Reset mission set to first (0) waypoint\\n #if self.vehicle.commands.next !=0:\\n # print \\\"Continuing mission...\\\"\\n #else:\\n # print \\\"Starting mission\\\"\\n # self.vehicle.commands.next = 0\\n if len(self.vehicle.waypoints)==0:\\n print \\\"Starting mission\\\"\\n self.vehicle.commands.next = 0\\n else:\\n print \\\"Continuing mission...\\\"\\n self.vehicle.commands.next = nextIndex\\n \\n self.vehicle.waypoints = waypoints \\n self.vehicle.mode = VehicleMode(\\\"AUTO\\\")\\n \\n self.print_mission() \\n \\n return droneconnect_pb2.Null()\",\n \"def sendDirection(self,direction):\\n self.broadcaster.sendDirection(direction)\",\n \"def direction(self):\\n _direction = self._custom.get(\\\"direction\\\")\\n if _direction is not None:\\n return _direction\\n\\n _direction = self._infer_direction()\\n self._custom[\\\"direction\\\"] = _direction\\n\\n return _direction\",\n \"def motorsDirection(self, direction):\\n\\n print (direction)\\n if direction == 'r' or direction == 'R':\\n self.motorDirection(self.motor1DirectionPin, self.motorReverse)\\n self.motorDirection(self.motor2DirectionPin, self.motorReverse)\\n print (\\\"Direction reverse\\\")\\n else:\\n self.motorDirection(self.motor1DirectionPin, self.motorForward)\\n self.motorDirection(self.motor2DirectionPin, self.motorForward)\\n print (\\\"Direction forward\\\")\",\n \"def update(self):\\n self._state = None\\n self._attributes = {}\\n\\n vehicles = self._api.get_vehicles(self._latitude, self._longitude)\\n scooter = {}\\n\\n if vehicles:\\n for vehicle in vehicles:\\n location_vehicle = (vehicle[\\\"location\\\"][0], vehicle[\\\"location\\\"][1])\\n location_hass = (self._latitude, self._longitude)\\n vehicle[\\\"distance\\\"] = distance(location_vehicle, location_hass).m\\n\\n scooter = sorted(vehicles, key=lambda item: item[\\\"distance\\\"])[0]\\n\\n if scooter:\\n self._state = round(scooter[\\\"distance\\\"])\\n self._attributes[ATTR_LATITUDE] = round(scooter[\\\"location\\\"][0], 5)\\n self._attributes[ATTR_LONGITUDE] = round(scooter[\\\"location\\\"][1], 5)\\n self._attributes[ATTR_BATTERY_LEVEL] = round(scooter[\\\"battery\\\"])\\n self._attributes[ATTR_ATTRIBUTION] = ATTRIBUTION\",\n \"def move(self, direction):\\n # Store the values in the connection dictionary in a list\\n self.room_num = self.current_room.connection[direction]\\n\\n # Check if there is a conditional movement and change the current room\\n if len(self.room_num) == 1:\\n self.current_room = self.rooms[int(self.room_num[0]) - 1]\\n else:\\n adventure.check(len(self.room_num))\",\n \"def update(self):\\n return_code, pos_new = sim.simxGetObjectPosition(self.clientID, self.from_handle, self.to_handle, sim.simx_opmode_streaming)\\n self.distance = np.linalg.norm(np.asarray(pos_new))\",\n \"def _update(self):\\n pass\",\n \"def send_update(self, neighbor):\\n message = 'ROUTE UPDATE'\\n source = ':'.join([self.name[0], str(self.name[1])])\\n dv = []\\n for others in self.distance_vector:\\n others_sep = others.split(':')\\n dv.append(','.join([others_sep[0], others_sep[1], str(self.distance_vector[others].cost)]))\\n dv = '\\\\n'.join(dv)\\n to_send = '\\\\n'.join([message, source, dv])\\n neighbor.sok.sendto(to_send, (neighbor.addr, neighbor.port))\\n neighbor.send_timer = time.time()\\n neighbor.update_ready = False\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def update(self):\\n pass\",\n \"def move(self, direction):\\n\\n if direction == \\\"north\\\":\\n self.go_and_update(-1, 0)\\n\\n elif direction == \\\"south\\\":\\n self.go_and_update(1, 0)\\n\\n elif direction == \\\"east\\\":\\n self.go_and_update(0, 1)\\n\\n elif direction == \\\"west\\\":\\n self.go_and_update(0, -1)\",\n \"def _change_fleet_direction(self):\\n for alien in self.aliens.sprites():\\n alien.rect.x -= self.settings.fleet_approach_speed\\n self.settings.fleet_direction *= -1\",\n \"def _change_fleet_direction(self):\\n\\t\\tfor auto in self.autos.sprites():\\n\\t\\t\\tauto.rect.y -= self.settings.fleet_rise_speed\\n\\t\\tself.settings.fleet_direction *= -1\",\n \"def _update_(self):\\n self._update_distance_()\\n self._check_literature_name_()\",\n \"def _update_transition(self, dt, time, direction): #pylint:disable-msg=C0103,C0301\\r\\n pass\",\n \"def get_direction(self):\\r\\n return self.__direction\",\n \"def update(self):\\r\\n pass\",\n \"def adjust_starting_position(self, direction):\\n\\n direction = 1 if direction in [\\\"left\\\", 1] else -1\\n\\n self.angle = direction * 25\\n self.distance = 12\\n self.drive_thread.reset()\\n\\n while self.drive_thread.driven_distance < self.distance:\\n time.sleep(0.1)\\n\\n self.angle = 0\\n self.distance = 12\\n self.drive_thread.reset()\\n\\n while self.drive_thread.driven_distance < self.distance:\\n time.sleep(0.1)\\n\\n self.angle = direction * -25\\n self.distance = 12\\n self.drive_thread.reset()\\n\\n while self.drive_thread.driven_distance < self.distance:\\n time.sleep(0.1)\",\n \"def _update(self):\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n trafficdata = {'name': self.road_name,\\r\\n 'city': self.city,\\r\\n 'key' : self.api_key,\\r\\n }\\r\\n\\r\\n trafficdata = urllib.parse.urlencode(trafficdata)\\r\\n ret = urllib.request.urlopen(\\\"%s?%s\\\" % (\\\"http://restapi.amap.com/v3/traffic/status/road\\\", trafficdata))\\r\\n if ret.status != 200:\\r\\n _Log.error('http get data Error StatusCode:%s' % ret.status)\\r\\n return\\r\\n res = ret.read().decode('utf-8')\\r\\n\\r\\n json_obj = json.loads(res)\\r\\n if not 'trafficinfo' in json_obj:\\r\\n _Log.error('Json Status Error1!')\\r\\n return\\r\\n if not 'description' in json_obj['trafficinfo']:\\r\\n _Log.error('No traffic data in json!')\\r\\n return\\r\\n self.data = json_obj\",\n \"def updateOmLocation(self):\\n if self.om != None:\\n self.om.current_loc = self.destinations[self.current_loc]\",\n \"def update_route(self, vrpdata):\\n self.distance = 0\\n self.quantity = 0\\n self.tourValid = False\\n lastc = 0 # first entry is depot\\n for c in self.route:\\n self.distance += vrpdata.DistMatrix[lastc][c]\\n self.quantity += vrpdata.CustDem[c]\\n lastc = c\\n self.distance += vrpdata.DistMatrix[lastc][0] # last entry is depot\\n self.tourValid = (self.quantity <= vrpdata.MaxVehCap)\",\n \"def update(self):\",\n \"def update(self):\",\n \"def update(self):\",\n \"def update(self) -> None:\\n ...\",\n \"def update(self):\\n try:\\n response = requests.get('{}/digital/{}'.format(\\n self._resource, self._pin), timeout=10)\\n self.data = {'state': response.json()['return_value']}\\n except requests.exceptions.ConnectionError:\\n _LOGGER.error(\\\"No route to device '%s'. Is device offline?\\\",\\n self._resource)\",\n \"def updatePos(self):\\n self.timeDriving +=1\\n self.pos[0] += self.vx\\n self.pos[1] += self.vy\",\n \"def update(self, pos):\\n\\t\\tpass\",\n \"def update_tlm(self):\",\n \"def update_goal(self):\\n pass\",\n \"def move(self, direction):\\n path = self.location.get_path(direction)\\n if path is not None:\\n if not path.blocked:\\n # exit current location\\n self.location.exit()\\n\\n # enter new location\\n self.location = path.destination\\n self.location.enter()\\n\\n self.on_move.trigger()\\n else:\\n self.echo(self.text(\\\"PATH_BLOCKED\\\", direction=direction))\\n else:\\n self.echo(self.text(\\\"NO_PATH\\\", direction=direction))\",\n \"def get_direction(self):\\n return self.direction\",\n \"def update(self, match='inv', *args, **kwargs):\\n if match == 'inv':\\n self._link()\\n self._get_atoms()\\n self._get_distances()\\n self._find_molecules()\\n\\n if match == 'inv':\\n # self._get_code_atom_links()\\n self._get_prochirality()\\n # ===================================================================\\n # self._get_orientations()\\n #===================================================================\\n self._transfer_adp()\\n elif match == 'geom':\\n self._match_molecules()\\n elif match == 'trust':\\n self._trust_molecules()\\n else:\\n apd_exit(1, 'Unknown ADP transfer method. Use inv/geom/trust.')\\n self._update_H_ADP()\",\n \"def move_in_direction(self, direction):\\n if direction == NORTH:\\n self.__position[y] += 1\\n elif direction == NORTHEAST:\\n self.__position[x] += 1\\n self.__position[y] += 1\\n elif direction == EAST:\\n self.__position[x] += 1\\n elif direction == SOUTHEAST:\\n self.__position[x] += 1\\n self.__position[y] -= 1\\n elif direction == SOUTH:\\n self.__position[y] -= 1\\n elif direction == SOUTHWEST:\\n self.__position[x] -= 1\\n self.__position[y] -= 1\\n elif direction == WEST:\\n self.__position[x] -= 1\\n elif direction == NORTHWEST:\\n self.__position[x] -= 1\\n self.__position[y] += 1\",\n \"def direction(self):\\n return self._direction.copy()\",\n \"def update(self) -> None:\\n destination = self._get_local_dest(self.path)\\n\\n try:\\n path_type = self._get_path_type(self.absolute)\\n handler = self.factory.get_handler(path_type)\\n handler.update(self.absolute, destination)\\n except Exception as e:\\n print(f\\\"[!] Skipping {self.path}: {e}\\\")\",\n \"def update_normal(self):\\n options = self.get_direction_options()\\n if self.is_at_intersection() or self.last_position == (self.rect.centerx, self.rect.centery):\\n self.direction = self.get_chase_direction(options)\\n if self.direction == 'u' and 'u' in options:\\n self.rect.centery -= self.speed\\n elif self.direction == 'l' and 'l' in options:\\n self.rect.centerx -= self.speed\\n elif self.direction == 'd' and 'd' in options:\\n self.rect.centery += self.speed\\n elif self.direction == 'r' and 'r' in options:\\n self.rect.centerx += self.speed\\n self.change_eyes(self.direction or 'r') # default look direction to right\\n self.image = self.norm_images.next_image()\",\n \"def update(self, **options):\\n pass\",\n \"def _move(self):\\n self.pos += self.direction # add direction vector\\n self.direction += self.gravity # add gravity to direction\\n self.direction = self.direction.elementwise() * self.drag # apply drag to direction\",\n \"def updateServePosition(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75249773","0.6738136","0.641039","0.62898123","0.625545","0.62209475","0.6207071","0.6116505","0.610406","0.6084203","0.6081595","0.6042297","0.6000609","0.59838057","0.59476405","0.5923903","0.59084034","0.5897013","0.5897013","0.5890528","0.5885742","0.5875727","0.58637005","0.58637005","0.58584064","0.5838726","0.5834024","0.58298385","0.582942","0.58189726","0.58101374","0.57893133","0.5757323","0.5750794","0.5748923","0.5741094","0.57121617","0.5708554","0.56961715","0.56957954","0.569145","0.56813806","0.56785864","0.5673724","0.56704664","0.56661487","0.56468475","0.56462306","0.56460994","0.5639074","0.5622213","0.56213456","0.56193185","0.5617001","0.55930114","0.55923384","0.55923384","0.55923384","0.55923384","0.55923384","0.55923384","0.55923384","0.55923384","0.55923384","0.55923384","0.55923384","0.55923384","0.55923384","0.55923384","0.55923384","0.5587192","0.55627346","0.5545902","0.5540427","0.55350846","0.55340654","0.55307645","0.5526074","0.55072755","0.5506468","0.55022216","0.5497891","0.5497891","0.5497891","0.54893935","0.548286","0.5476036","0.5468209","0.5466554","0.5464939","0.5455552","0.54521006","0.5449018","0.5447944","0.5446267","0.54449147","0.54419506","0.54407287","0.54215515","0.5415789"],"string":"[\n \"0.75249773\",\n \"0.6738136\",\n \"0.641039\",\n \"0.62898123\",\n \"0.625545\",\n \"0.62209475\",\n \"0.6207071\",\n \"0.6116505\",\n \"0.610406\",\n \"0.6084203\",\n \"0.6081595\",\n \"0.6042297\",\n \"0.6000609\",\n \"0.59838057\",\n \"0.59476405\",\n \"0.5923903\",\n \"0.59084034\",\n \"0.5897013\",\n \"0.5897013\",\n \"0.5890528\",\n \"0.5885742\",\n \"0.5875727\",\n \"0.58637005\",\n \"0.58637005\",\n \"0.58584064\",\n \"0.5838726\",\n \"0.5834024\",\n \"0.58298385\",\n \"0.582942\",\n \"0.58189726\",\n \"0.58101374\",\n \"0.57893133\",\n \"0.5757323\",\n \"0.5750794\",\n \"0.5748923\",\n \"0.5741094\",\n \"0.57121617\",\n \"0.5708554\",\n \"0.56961715\",\n \"0.56957954\",\n \"0.569145\",\n \"0.56813806\",\n \"0.56785864\",\n \"0.5673724\",\n \"0.56704664\",\n \"0.56661487\",\n \"0.56468475\",\n \"0.56462306\",\n \"0.56460994\",\n \"0.5639074\",\n \"0.5622213\",\n \"0.56213456\",\n \"0.56193185\",\n \"0.5617001\",\n \"0.55930114\",\n \"0.55923384\",\n \"0.55923384\",\n \"0.55923384\",\n \"0.55923384\",\n \"0.55923384\",\n \"0.55923384\",\n \"0.55923384\",\n \"0.55923384\",\n \"0.55923384\",\n \"0.55923384\",\n \"0.55923384\",\n \"0.55923384\",\n \"0.55923384\",\n \"0.55923384\",\n \"0.55923384\",\n \"0.5587192\",\n \"0.55627346\",\n \"0.5545902\",\n \"0.5540427\",\n \"0.55350846\",\n \"0.55340654\",\n \"0.55307645\",\n \"0.5526074\",\n \"0.55072755\",\n \"0.5506468\",\n \"0.55022216\",\n \"0.5497891\",\n \"0.5497891\",\n \"0.5497891\",\n \"0.54893935\",\n \"0.548286\",\n \"0.5476036\",\n \"0.5468209\",\n \"0.5466554\",\n \"0.5464939\",\n \"0.5455552\",\n \"0.54521006\",\n \"0.5449018\",\n \"0.5447944\",\n \"0.5446267\",\n \"0.54449147\",\n \"0.54419506\",\n \"0.54407287\",\n \"0.54215515\",\n \"0.5415789\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7453741"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":84797,"cells":{"query":{"kind":"string","value":"set the inital position of the player, if a player joins the game"},"document":{"kind":"string","value":"def set_player_start_position(self):\n if self.field_size.x() == 0: return\n \n parts = len(self.player_list)\n y_list = []\n for p in range(1,parts+1):\n y_list.append(self.field_size.y()*p/(parts+1))\n\n for i,p in enumerate(self.player_list):\n p1 = Qt.QPoint(self.start_y,y_list[i])\n p2 = Qt.QPoint(self.start_y+self.start_length,y_list[i])\n p.set_start_position([p1,p2])\n p.status_remove = False\n p.override_direction(0)"},"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 set_first_player(self):\n if self.player2.won_previous:\n self.current_player = self.player2\n else: self.current_player = self.player1","def _drive_player_position(self) -> None:\n player = self._player\n if player:\n assert self.node\n assert player.node\n self.node.connectattr('torso_position', player.node, 'position')","def setup_player_position(world, empty, player):\n\n position = [0, 0]\n is_valid = False\n\n while not is_valid:\n position[0] = randint(0, len(world) - 1)\n position[1] = randint(0, len(world) - 1)\n\n if world[position[0]][position[1]] == empty:\n is_valid = True\n world[position[0]][position[1]] = player\n\n return position","def bcp_player_turn_start(self, player, **kwargs):\n\n if ((self.player and self.player.number != player) or\n not self.player):\n\n self.player = self.player_list[int(player)-1]","def set_player_position(self, position):\n raise NotImplementedError","def center_on_spawn(self):\n self.center_on(*self.world.metadata['playerStart'])","def setCurrentPlayer(self):\n self.current_player = next(self.get_player_order_fn())","def reset_position(self): \n self.rect.x = 400\n self.rect.y = 400\n \n # Specifies the Player's spawnpoint as maze_arrangement[8][8], representing\n # the tile in the center of the maze \n self.__minotaur_x = 8\n self.__minotaur_y = 8","def place_player(self, player, position):\n self.board[position] = player","def try_move_player(self):\n player = self.player\n if player.direction == 'U':\n next_position = (player.position[0], player.position[1] - 1)\n elif player.direction == 'D':\n next_position = (player.position[0], player.position[1] + 1)\n elif player.direction == 'L':\n next_position = (player.position[0] - 1, player.position[1])\n elif player.direction == 'R':\n next_position = (player.position[0] + 1, player.position[1])\n\n if self.__is_valid_position(next_position):\n self.player.position = next_position\n else:\n self.game_over = True","def init_position():\n __maze.init_position()","def initial_move(self):\n\n # Make the first move based on the game we\n # are currently playing, otherwise return\n if isinstance(self.get_game_space(), Gomoku):\n\n # play one stone in the bottom left-hand corner\n self.get_game_space().set_tile(0,6,self.get_affinity())\n\n # the agents are now in play \n self.set_play_status(True)\n self.get_opponent().set_play_status(True)\n\n else:\n print('Unknown game. Returning')\n return None","def update_players_locations(self):\n self.loc = self.find_value(1)\n self.opponent_loc = self.find_value(2)","async def on_world_start(self, data, connection):\n player = self.plugins['player_manager'].get_player_by_name(\n connection.player.name)\n if hasattr(player, 'seen_before'):\n return True\n else:\n self.background(self._new_player_greeter(connection))\n self.background(self._new_player_gifter(connection))\n player.seen_before = True\n return True","def respawn_player(self):\n self.rect.x = 50\n self.rect.y = 50\n \n # Specifies the Player's spawnpoint as maze_arrangement[1][1], representing\n # the tile in the top-left corner of the maze\n self.__user_x = 1\n self.__user_y = 1","def move_player(self, delta):\n if self.player_pos + delta in MAP:\n self.player_pos = self.player_pos + delta","def player_left(self) -> None:\n self._routes[self._current_route_key][\"LEFT\"] += 1\n new_pos = self._player.x - self.MOVE_INC\n if new_pos + self.PLAYER_DIM <= self._width and new_pos - self.PLAYER_DIM >= 0:\n self._player.x = new_pos","def set_player(self, new_player):\n self.player = new_player","def switch_player(self):\n self.player = Nim.other_player(self.player)","def setPosition(self):\n # determine posX, posY for battle\n (x1,y1) = globals.battlemapQuadrants[self.systemGrid]\n self.posX = x1+self.setX\n self.posY = y1+self.setY","def setPlayerPositions(self, updates):\r\n for upd in updates:\r\n playerNode = self.playersNode.find(upd[0])\r\n playerNode.setPos(upd[1])\r\n playerNode.setHpr(upd[2])","def move_player():\r\n global current_position #say that we want to refer to the one above!\r\n if map1[current_position[0]][current_position[1]] == 'x':\r\n print('we hit a wall!')\r\n current_position = previous_position #hit a wall so we return to the previous position\r\n else:\r\n if map1[current_position[0]][current_position[1]] == 'f': #check have we reach the flag yet\r\n map1[current_position[0]][current_position[1]] = 'p' #set new position to be the player\r\n map1[previous_position[0]][previous_position[1]] = ' ' #set previous position to be empty space\r\n print('we maade it!')\r\n return True\r\n map1[current_position[0]][current_position[1]] = 'p' #move the player to the next position\r\n map1[previous_position[0]][previous_position[1]] = ' '","def set_player_tile(self, tile_coords):\n #self.tiles[ self.player_position[0] ][ self.player_position[1] ].has_player = False\n self.player_position = list(tile_coords)\n #self.tiles[ self.player_position[0] ][ self.player_position[1] ].has_player = True","def do_start_joined(self):\n\t\td = {\"state\": be.S_GAME,\n\t\t\t\t\"hosting\": False,\n\t\t\t\t\"uuid\": None,\n\t\t\t\t\"name\": self.game_name,\n\t\t\t\t\"nickname\": self.nickname,\n\t\t\t\t\"num_players\": self.num_players,\n\t\t\t\t\"boardsize\": self.boardsize}\n\t\tevent = pygame.event.Event(be.E_STATE, d)\n\t\tpygame.event.post(event)\n\n\t\tself.hide_all()\n\t\tself.renderer.color = (0, 0, 0, 0)","def newPlayer():\r\n global player\r\n if player == 1:\r\n player = 2\r\n else:\r\n player = 1","def player(self):\n legal = self.board.legal_move(self.black)\n if(len(legal) == 0):\n self.p_no_move = 1\n print(\"No legal move for player!\")\n self.computer_turn = True\n self.player_turn = False","def __init__(self, player):\n self.platform_list = pygame.sprite.Group()\n #self.enemy_list = pygame.sprite.Group()\n self.player = player\n self.bullet_list = pygame.sprite.Group()\n self.enemy_list = pygame.sprite.Group()\n self.active_sprite_list = pygame.sprite.Group()\n \n # How far this world has been scrolled left/right\n self.world_shift = 0","def set_next_first_player(self):\n if self.current_player == self.player1:\n self.player1.won_previous = True\n self.player2.won_previous = False\n else:\n self.player2.won_previous = True\n self.player1.won_previous = False","def place_player(self, player, position):\n quadrant = position // self.quadrant_positions_count\n quadrant_position = position % self.quadrant_positions_count\n self.play_area[quadrant].place_player(player, quadrant_position)","def __init__(self):\n self.played_pos = []\n self.grid = [['-', '-', '-'],\n ['-', '-', '-'],\n ['-', '-', '-']]\n self.player_played_pos = {'p1': set(), 'p2': set()}","async def set_player(self, player: Optional[andesite.Player]) -> None:\n ...","def change_player(self):\n if self.__root.children is None:\n if self.__root.win[0] == 1:\n self.win = Board.PLAYER_0\n elif self.__root.win[1] == 1:\n self.win = Board.PLAYER_1\n elif self.__root.win[0] == 0 and self.__root.win[1] == 0:\n self.win = 'tie'\n\n self.player = Board.PLAYERS[(Board.PLAYERS.index(self.player) + 1) %\n len(Board.PLAYERS)]","def set_init_pose(self):\n self.move_joints(self.init_cart_vel)\n\n return True","def set_starting_pos(self):\n if self.start and self.is_unoccupied(*self.start):\n self.current_pos = self.start[:]\n else:\n self.set_random_pos('starting')","def switchPlayer(self):\n self.player = Nim.otherPlayer(self.player)","def on_key_press(self, key):\n if key == LEFT:\n self.player.change_x = -5\n elif key == RIGHT:\n self.player.change_x = 5\n elif key == UP:\n self.player.change_y = -5 \n elif key == DOWN:\n self.player.change_y = 5","def set_start_position(self) -> None:\n self.cozmo.set_head_angle(degrees(0)).wait_for_completed()\n self.cozmo.set_lift_height(0.0).wait_for_completed()","def set_player(self, char_data):\n self.player = self.server.object_manager.add_player(char_data)","def place_player(self, start_position=None, uid=None):\n if start_position is None:\n temp_player_index = np.random.choice(np.arange(self.maze.size),\n replace=False,\n size=1)\n # Create flattened array to map\n temp_arr = self.maze.flatten()\n\n # Provide stop placeholder for loop\n loop_brake = 0\n\n while int(temp_player_index) in self.forbid_indices[0]:\n # Propose index for player to occupy\n temp_player_index = np.random.choice(np.arange(self.maze.size),\n replace=False,\n size=1)\n\n # To keep the placeholder loop from running to infinity\n loop_brake += 1\n if loop_brake > len(temp_arr):\n sys.exit(\"Player Placement Failed! No unreserved space detected\")\n else:\n continue\n\n if uid is None:\n # Remake original structure\n temp_arr[temp_player_index] = self.next_play_id\n\n # Carry progress to values list\n self.black_list.append(self.next_play_id)\n\n elif uid not in self.black_list:\n temp_arr[temp_player_index] = uid\n\n # Carry progress to values list\n self.black_list.append(uid)\n\n else:\n sys.exit(\"Player Placement Failed! Proposed UID already in black_list\")\n\n self.forbid_indices[0].append(int(temp_player_index))\n\n # Remake original structure\n self.maze = temp_arr.reshape(self.dims)\n\n if uid is None:\n self.find_player(self.next_play_id)\n self.next_play_id += 1\n else:\n self.find_player(uid)","def set_player(self, player_params):\n\n self.saved_player = player_params","def set_init_pose(self, init_pose):\n \tself.check_publishers_connection()\n \tself.move_joints(init_pose)","def place_marker(self, player, position):\n\n assert player in [1,2]\n assert position[0] in range(10)\n assert position[1] in range(10)\n\n if position in self.board.keys():\n return False\n \n self.board[position] = player\n return True","def initGame(self):\n self.map = {}\n self.blocks = Group()\n self.Coins =Group()\n self.players = Group()\n self.player1 = Player(1525,75,2)\n self.players.add(self.player1)\n if self.playernum == 2:\n self.player2 = Player(75,825,1)\n self.players.add(self.player2)\n else:\n self.player2 = False","def set_player(self, player):\n\n self._player = player","def start_of_game(self):\n pass","def init_game(self):\n self.view.carregar_jogadores_possiveis(self._possible_players_list())\n self.view.put_view_in_main_loop()","def on_player_join(self, pid):\n logging.info(\"%s joined.\", pid)\n\n # first, look if this server has a default class established\n # if not, pick a random class stored in the World personae\n if self.default_class is not None:\n PlayerCls = self.default_class\n else:\n PlayerCls = self.world.random_cls()\n\n # initialize the Character and add it to the server\n character = PlayerCls()\n self.players[pid] = character\n\n # now prepare a location for the player\n # as with default_class, a server-wide default_location takes\n # precedence\n if self.default_location is not None:\n start_loc = self.default_location\n elif PlayerCls.starting_location is not None:\n start_loc = PlayerCls.starting_location\n # if no default location has been defined for CharacterClass or\n # server, resort to picking the first location in locations\n else:\n try:\n start_loc = next(iter(self.world.locations.values()))\n except StopIteration:\n logging.critical(\"Could not spawn %d, \"\n \"world has no locations\", pid)\n return\n logging.warning(\"%s has no default location, \"\n \"so %d will be spawned in %s\",\n PlayerCls, pid, start_loc)\n\n # put the character in \"greet\" mode\n character.spawn(start_loc)","def player_update(self,p,player):\n node = self._validate(p)\n node._player = player","def init_player():\n global active_track_idx\n global track_last_slided_pos\n global track_last_paused_pos\n global track_total_play_time \n\n # INITIALIZE Player\n active_track_idx = -1\n cancel_update_play_time_loop()\n cancel_track_end_event_loop()\n track_status.set(\"---\")\n track_title.set(\"--- : \")\n play_pause_btn.configure(image=play_img)\n track_last_slided_pos = 0\n track_last_paused_pos = 0\n track_total_play_time = 0\n track_pos_label.configure(text=\"00:00\")\n track_length_label.configure(text=\"00:00\")\n track_pos_slider.configure(state=\"disabled\")\n track_pos.set(0)","def _set_init_pose(self):\n #raw_input(\"INIT SPEED PRESS\")\n self.move_base(self.init_linear_speed_vector,\n self.init_angular_turn_speed,\n epsilon=0.05,\n update_rate=10)\n # We Issue the landing command to be sure it starts landing\n #raw_input(\"LAND PRESS\")\n # self.land()\n\n return True","def player_collision(self, player):\n return True","def player_movement(self):","def player_up(self) -> None:\n self._routes[self._current_route_key][\"UP\"] += 1\n new_pos = self._player.y - self.MOVE_INC\n if new_pos + self.PLAYER_DIM <= self._height and new_pos - self.PLAYER_DIM >= 0:\n self._player.y = new_pos","def setNewPosition(self,board_object,x,y):\n\t\tif checkClash(board_object,self,x,y)==0:\n\t\t\toverlayMatrix(board_object,self,x,y)\n\t\t\tself.setPos(x,y)\n\t\t\treturn 0\n\t\telse:\n\t\t\treturn 1","def bot_init():\n client.Console.Say('Hello World')\n global player\n player = client.GetPlayer()","def spawnPlayer( player ):\r\n \r\n room = random.sample(world.maps.World.roomsList, 1)[0]\r\n \r\n # Uncomment below to force spawn in a certain room\r\n room = \"544\"\r\n \r\n player.room = room\r\n world.maps.World.mapGrid[room].players[player.name] = player\r\n player.status = PLAYING\r\n sendToRoomNotPlayer( player, \"{0}{1} appears in a flash!{2}\".format(BLUE, player, WHITE) )\r\n tellWorld( player, None, \"{0} has entered the arena!\".format(player.name) )\r\n \r\n displayRoom(player, player.room)","def set_ready(self):\n if self.game.has_started() or self.status == self.PLAYER_READY:\n return\n self.status = self.PLAYER_READY\n self.game.player_is_ready()","def before_turn(self, playerInfo):\n self.PlayerInfo = playerInfo","def set_points(self):\n self.white_player.play_against(self.black_player)\n self.black_player.play_against(self.white_player)\n\n if self.ended:\n if self.winner is not None:\n self.winner.points += 1\n else:\n self.white_player.points += 0.5\n self.black_player.points += 0.5","def setup_players(self, players):\n\t\tself.players.clear()\n\t\tids = set([p.get_player_id() for p in players])\n\t\tfor p in self.state.get_players():\n\t\t\tif p not in ids:\n\t\t\t\traise PlayerException(p)\n\t\tfor p in players:\n\t\t\tself.players[p.get_player_id()] = p","def move_me_on_spawn(self):\r\n\t\tif self.points_to_go:\r\n\t\t\tself.start_pos = self.points_to_go[0]\r\n\t\t\tfor point in self.points_to_go[1:]:\r\n\t\t\t\tfor i in range(len(self.points_to_go[1:])):\r\n\t\t\t\t\tself.goal_pos = self.points_to_go[i]\r\n\t\t\t\t\t\r\n\t\t\t\t\tself.move_me()\r\n\t\t\t\t\t#self.start_pos = \r\n\t\t\t\t\t#print(self.goal_pos)\r\n\t\t\t\t\t#if self.move_me():\r\n\t\t\t\t\t#\ti += 1\r\n\t\t\t\t\t#\tprint('switch')\r","def start(self):\n self.player = Player()\n self.dealer = Dealer()\n self.pot = 0\n self.side_bet = 0\n start_game()","async def async_set_playhead_position(self, position):\n self._playhead_position = position","def reset(self, starting_player):\n self.__turn = starting_player.value\n self.__turns_played = 0\n self.__winner = MarkerType.NONE\n self.__loser = MarkerType.NONE\n\n for y in range(Settings.SIZE_Y):\n for x in range(Settings.SIZE_X):\n self.__grid[y][x] = MarkerType.NONE\n\n self.__state = GameState.PLAYING","def _set_init_pose(self):\n cmd = np.zeros(16 * self.n)\n self.move_joints(cmd)","def initGameState(self):\n print(\"Setting game state: \")\n self.playGUI = GUI()\n self.playGUI.drawBoard(self.player)","def __init__(self):\n pos = _get_mc().player.getTilePos() + Vec3(2, 0, 0)\n pos = _Vec3(pos.x, pos.y, pos.z)\n _GenericBot.__init__(self, pos)\n self._pos = pos\n self._move(self._pos)","def reset_position(self):\n self.snd_explosion.play()\n pygame.time.delay(1000)\n self.score.iff = \"\"\n self.ship.alive = True\n self.ship.position.x = self.world.left + self.config['Ship']['ship_pos_x'] * self.aspect_ratio\n self.ship.position.y = self.world.top + self.config['Ship']['ship_pos_y'] * self.aspect_ratio\n self.ship.velocity.x = self.config['Ship']['ship_vel_x']\n self.ship.velocity.y = self.config['Ship']['ship_vel_y']\n self.ship.orientation = self.config['Ship']['ship_orientation']","def to_init_position(self):\n if self._pinit == None:\n raise Exception('initial position for motor {} not known'.format(self._port))\n self.change_position(self._pinit)","def init_position(self):\n\t\t\n\t\t# Starting position, 1 is for WHITE, -1 is for BLACK\n\t\tself['D4'] = self['E5'] = 1\n\t\tself['D5'] = self['E4'] = -1","def at_start(self):\n if not self.db.started:\n self.player.start()\n self.db.started = True","def set_movement(self, x, y):\r\n if x < 0 or x > 2:\r\n return False\r\n if y < 0 or y > 2:\r\n return False\r\n rotation_one = self.rotate_matrix(self.matrix)\r\n rotation_two = self.rotate_matrix(rotation_one)\r\n matrix = self.rotate_matrix(rotation_two)\r\n if matrix[x][y] == \" \":\r\n matrix[x][y] = self.player\r\n self.rotate_matrix = self.rotate_matrix(matrix)\r\n self.round_game = self.round_game + 1\r\n if self.player == self.players[0]:\r\n self.player = self.players[1]\r\n else:\r\n self.player = self.players[0]\r\n return True\r\n return False","def player_moves_player(self, x, y):\n activePlayer = self.get_active_player()\n if activePlayer.humanControlled:\n super(RobotGame, self).player_moves_player(x, y)","def move(self, position):\n if self.win:\n raise ValueError('Game finished!')\n\n if self.board[position] != Board.CELL_EMPTY:\n raise ValueError('Cell not empty')\n\n self.board[position] = self.player\n self.__root = BinaryNode(self.board, position, self.player)\n\n self.change_player()","def move_player(direction):\n global ZERO_BASE_PLYR_POS\n if direction == \"north\":\n ZERO_BASE_PLYR_POS -= 10\n elif direction == \"south\":\n ZERO_BASE_PLYR_POS += 10\n elif direction == \"west\":\n ZERO_BASE_PLYR_POS -= 1\n elif direction == \"east\":\n ZERO_BASE_PLYR_POS += 1\n \n sleep(0.5) # all moves have a 0.5 second delay\n \n show_ground_feature()","def _acting_player_position(self):\n return self._env.acting_player_position","def init_position(self):\n if self.invert_init_angle is False:\n self.theta_i_top = -self.theta_s_top\n self.theta_i_bot = -self.theta_s_bot\n else:\n self.theta_i_top = self.theta_s_top\n self.theta_i_bot = self.theta_s_bot\n\n self.move_mid_block(theta=self.theta_i_bot)\n self.move_top_block(theta=self.theta_i_top)\n\n # Variables used to motion\n self.x_offset = self.block_top.center.x\n self.d_top = np.sin(self.theta_s_top) * self.bars_top.length * 2\n self.d_bot = np.sin(self.theta_s_bot) * self.bars_bot.length * 2","def _initialize_player_stats(self):\r\n self.reset()\r\n for x in range(self.num_players):\r\n self.player_draws[f'{x}']=[]\r\n self.player_points[f'{x}']= 0","def on_key_release(self, key):\n if key == LEFT:\n self.player.change_x = 0\n elif key == RIGHT:\n self.player.change_x = 0\n elif key == UP:\n self.player.change_y = 0\n elif key == DOWN:\n self.player.change_y = 0","def update_player_location(player):\n global winners_index\n print \"started handling requests for player: %r\" % str(player)\n msg = str(player.player_socket.recv(32768))\n while msg != \"finished!\":\n if msg != \"\":\n player.state = msg.strip(\"\\n\") + \" ~ \"\n msg = str(player.player_socket.recv(32768))\n\n msg = str(player.player_socket.recv(32768))\n if msg != \"\" and int(msg.split()[1]) == player.index:\n winners_index = player.index","def __init__(self, player):\n self.root = Node(GameState(is_upper=(player == \"upper\")))\n self.root.pruning_is_aggressive = True\n self.start_time = self.end_time = self.time_consumed = 0\n self.norm = norm(350, 200)","def setup(player, state):\n global ME\n global THEM\n global STATE\n\n player = player.upper()\n assert player == 'X' or player == 'O'\n ME = player\n THEM = 'O' if player is 'X' else 'X'\n assert state\n STATE = state","async def on_ready():\n print(\"I'm in\")\n print(client.user)\n await client.change_presence(activity=discord.Game(name=IN_GAME))","def update(self, pos, direction):\n #self.rect.topleft = (xCent*30,yCent*30,)\n self.rect.topleft = (pos)\n if direction == 'left':\n self.image = pygame.image.load('mainplayerleft.png').convert_alpha()\n facing = 'left'\n elif direction == 'right':\n self.image = pygame.image.load('mainplayerright.png').convert_alpha()\n facing = 'right'","def track_players(self, boom_pos):\n self.update_players()\n for player in self.players:\n if self.if_near_boom(player.get_char().get_pos(), boom_pos):\n player.update_lives(-1)\n self.gui.set_doneBlinkingAnimation(False)","def setPlayerOne(self, boardSize):\n mid = int(boardSize / 2)\n for i in range(mid):\n for j in range(mid):\n if (i + j < mid):\n self.addPion(Pion.Pion(self.noPlayer, Posisi.Posisi(i, j)))","def check_trying_using(self):\r\n if self.opportunity or 'key' in inventory:\r\n if self.rect.colliderect(player):\r\n music_acceptor.usingPortalSound()\r\n player.rect.x = random.randrange(75, WIDTH - 125)\r\n player.rect.y = random.randrange(25, HEIGHT - 100)","def follow_player(self, player_x, player_y):\n \n # Determines the horizontal and vertical distance between the Player and the\n # Minotaur, converting them into that are measured by the tiles (Dividing the\n # difference by 50 turns each of these values into integers that represent tile\n # distances)\n x_distance = (self.rect.x - player_x) / 50 \n y_distance = (self.rect.y - player_y) / 50 \n \n # If the Minotaur is NOT on the same tile as the Player i.e. touching them\n if x_distance != 0 and y_distance != 0:\n \n # Check if the Player is situated ABOVE the Minotaur and if the Minotaur is\n # not currently animating\n if y_distance > 0 and not self.__animating:\n \n # If the tile above the Minotaur is free, then set direction as up, set\n # animating to True, and change the minotaur_y (Tile space)\n if (self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y - 1] != 1):\n self.__direction = \"UP\"\n self.__animating = True\n self.__minotaur_y -= 1\n \n # If the tile above the Minotaur is NOT free, and the tile to the left\n # of the Minotaur IS free, then set direction to left, set animating\n # to True, and change the minotaur_x (Tile space) accordingly\n elif self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y - 1] and \\\n (self.__maze_arrangement[self.__minotaur_x - 1][self.__minotaur_y] != 1) and \\\n player_x < self.rect.x:\n self.__direction = \"LEFT\"\n self.__animating = True\n self.__minotaur_x -= 1\n \n # If the tile above the Minotaur is NOT free, and the tile to the RIGHT\n # of the Minotaur IS free, then set direction to right, set animating\n # to True, and change the minotaur_x (Tile space) accordingly \n elif self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y - 1] and \\\n (self.__maze_arrangement[self.__minotaur_x + 1][self.__minotaur_y] != 1) and \\\n player_x > self.rect.x:\n self.__direction = \"RIGHT\"\n self.__animating = True\n self.__minotaur_x += 1 \n \n # Check if the Player is situated BELOW the Minotaur and if the Minotaur is\n # not currently animating \n if y_distance < 0 and not self.__animating:\n \n # If the tile below the Minotaur is free, then set direction as down, set\n # animating to True, and change the minotaur_y (Tile space) \n if (self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y + 1] != 1):\n self.__direction = \"DOWN\"\n self.__animating = True\n self.__minotaur_y += 1\n \n # If the tile below the Minotaur is NOT free, and the tile to the RIGHT\n # of the Minotaur IS free, then set direction to right, set animating\n # to True, and change the minotaur_x (Tile space) accordingly \n elif self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y + 1] and \\\n (self.__maze_arrangement[self.__minotaur_x + 1][self.__minotaur_y] != 1) and \\\n player_x > self.rect.x:\n self.__direction = \"RIGHT\"\n self.__animating = True\n self.__minotaur_x += 1\n \n # If the tile below the Minotaur is NOT free, and the tile to the LEFT\n # of the Minotaur IS free, then set direction to left, set animating\n # to True, and change the minotaur_x (Tile space) accordingly \n elif self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y + 1] and \\\n (self.__maze_arrangement[self.__minotaur_x - 1][self.__minotaur_y] != 1) and \\\n player_x < self.rect.x:\n self.__direction = \"LEFT\"\n self.__animating = True\n self.__minotaur_x -= 1 \n \n # Check if the Player is situated RIGHT of the Minotaur and if the Minotaur is\n # not currently animating \n if x_distance < 0 and not self.__animating:\n \n # If the tile to the right of the Minotaur is free, then set direction as \n # right, set animating to True, and change the minotaur_x (Tile space) \n if (self.__maze_arrangement[self.__minotaur_x + 1][self.__minotaur_y] != 1):\n self.__direction = \"RIGHT\"\n self.__animating = True\n self.__minotaur_x += 1 \n \n # If the tile to the right of the Minotaur is NOT free, and the tile ABOVE\n # the Minotaur IS free, then set direction to up, set animating\n # to True, and change the minotaur_y (Tile space) accordingly \n elif self.__maze_arrangement[self.__minotaur_x + 1][self.__minotaur_y] and \\\n (self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y - 1] != 1) and \\\n player_y < self.rect.y:\n self.__direction = \"UP\"\n self.__animating = True\n self.__minotaur_y -= 1\n \n # If the tile to the right of the Minotaur is NOT free, and the tile BELOW\n # the Minotaur IS free, then set direction to down, set animating\n # to True, and change the minotaur_y (Tile space) accordingly \n elif self.__maze_arrangement[self.__minotaur_x + 1][self.__minotaur_y] and \\\n (self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y + 1] != 1) and \\\n player_y > self.rect.y:\n self.__direction = \"DOWN\"\n self.__animating = True\n self.__minotaur_y += 1 \n \n # Check if the Player is situated LEFT of the Minotaur and if the Minotaur is\n # not currently animating \n if x_distance > 0 and not self.__animating:\n \n # If the tile to the LEFT of the Minotaur is free, then set direction as \n # left, set animating to True, and change the minotaur_x (Tile space) \n if (self.__maze_arrangement[self.__minotaur_x - 1][self.__minotaur_y] != 1):\n self.__direction = \"LEFT\"\n self.__animating = True\n self.__minotaur_x -= 1\n \n # If the tile to the LEFT of the Minotaur is NOT free, and the tile BELOW\n # the Minotaur IS free, then set direction to down, set animating\n # to True, and change the minotaur_y (Tile space) accordingly \n elif self.__maze_arrangement[self.__minotaur_x - 1][self.__minotaur_y] and \\\n (self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y + 1] != 1) and \\\n player_y > self.rect.y:\n self.__direction = \"DOWN\"\n self.__animating = True\n self.__minotaur_y += 1\n \n # If the tile to the LEFT of the Minotaur is NOT free, and the tile ABOVE\n # the Minotaur IS free, then set direction to up, set animating\n # to True, and change the minotaur_y (Tile space) accordingly \n elif self.__maze_arrangement[self.__minotaur_x - 1][self.__minotaur_y] and \\\n (self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y - 1] != 1) and \\\n player_y > self.rect.y:\n self.__direction = \"UP\"\n self.__animating = True\n self.__minotaur_y -= 1","def player_position(self, player_ip, *args):\r\n\t\ttry:\r\n\t\t\tteam_type = self._teammates[player_ip]\r\n\t\texcept KeyError:\r\n\t\t\tself._comm_server.send_message(player_ip, \"position -1 -1\")\r\n\t\t\treturn\r\n\t\telse:\r\n\t\t\tmaze_pos_finder = self._teams[team_type].maze_pos_finder\r\n\t\t\tplayer_info = self._teams[team_type].get_player_info_by_IP(player_ip)\r\n\r\n\t\t\tpos = maze_pos_finder.get_maze_pos(player_info.color_bgr)\r\n\r\n\t\t\tif pos is not None:\r\n\t\t\t\tself._comm_server.send_message(player_ip, \"position {0} {1}\" \\\r\n\t\t\t\t\t.format(*pos.position))\r\n\t\t\telse:\r\n\t\t\t\tself._comm_server.send_message(player_ip, \"position -1 -1\")","def assign_leftLimit():\r\n player.rect.x = 25","def setPosition(position):","def maybe_start(self):\r\n\t\tif not [p for p in self.players if not p.ready]\\\r\n\t\t and len(self.players) == self.max_players \\\r\n\t\t and not self.started:\r\n\t\t\tself.start()","def send_player_position(self):\n pl_coor_dict = {}\n for pl in self.player_list:\n #coor_list = [[p.x(),p.y()] for p in pl._line_list]\n pl_coor_dict[pl.id] = pl.get_line_list_float()\n self.on_data_to_all_clients({\"game\":{\"player_coor\":pl_coor_dict}})","def set_plays(self) -> None:\n player1 = self._get_input('What is the name of player 1?')\n player2 = self._get_input('What is the name of player 2?')\n self.state = State(player1, player2)","def setUp(self):\n self.player = ship.Player(\n constants.PLAYER_START_PLACE,\n constants.PLAYER_WIDTH,\n constants.PLAYER_HEIGHT,\n constants.PLAYER_IMG,\n constants.PLAYER_HEALTH\n )\n\n self.alien = ship.Alien(\n [320, 300],\n 30,\n 30,\n constants.GREEN_ALIEN_IMG,\n 1\n )\n\n self.alien.shooting([320, 300], 5, False)\n\n self.player.shooting([self.player.position[0] + 3, self.player.position[1]], 1, True)","def update(self):\r\n if not self.tr.game_over and self.tr.turn_tracker:\r\n self.computer_play()","def __init__(self, player1, player2, state_machine, restore = False):\r\n super().__init__()\r\n self.__players[0] = player1\r\n self.__players[1] = player2\r\n self.__player_names[player1] = 'Human'\r\n self.__player_names[player2] = 'Bot'\r\n self.__state_machine = state_machine","def place_entrance(self):\r\n x = random.randint(0, (self.__nx - 1))\r\n y = random.randint(0, (self.__ny - 1))\r\n self.__current_room = x, y # places adventurer in dungeon at start of game\r\n self.__entrance_room = x, y\r\n self.__maze[x][y].set_entrance(True)","def join_player(self, data, user):\n self.remove(user)\n\n user.room = \"100\"\n user.x = \"0\"\n user.y = \"0\"\n user.frame = \"0\"\n\n self.add(user)","def setup_game(self, player, opponent):\n\n self.display.clear_screen()\n\n ship_index = 0\n\n while not player.ready(len(self.SHIP_INFO)):\n # prints the currrent board\n board = self.display.construct_player_board(player, opponent, True)\n self.display.print_board(board)\n\n ship_name, ship_length = self.SHIP_INFO[ship_index]\n ship_to_add = Ship(ship_name, ship_length)\n\n try:\n player.add_ship(ship_to_add)\n except Exception as e:\n ship_to_add = player.ships[ship_index]\n\n origin, orientation = self.display.prompt_for_ship_placement(\n ship_to_add)\n\n try:\n player.place_ship(ship_to_add, origin, orientation,\n self.BOARD_SIZE)\n except ValueError as ve:\n self.display.clear_screen()\n print(ve)\n print()\n continue\n\n self.display.clear_screen()\n ship_index += 1\n self.display.prompt_switch(opponent.name)"],"string":"[\n \"def set_first_player(self):\\n if self.player2.won_previous:\\n self.current_player = self.player2\\n else: self.current_player = self.player1\",\n \"def _drive_player_position(self) -> None:\\n player = self._player\\n if player:\\n assert self.node\\n assert player.node\\n self.node.connectattr('torso_position', player.node, 'position')\",\n \"def setup_player_position(world, empty, player):\\n\\n position = [0, 0]\\n is_valid = False\\n\\n while not is_valid:\\n position[0] = randint(0, len(world) - 1)\\n position[1] = randint(0, len(world) - 1)\\n\\n if world[position[0]][position[1]] == empty:\\n is_valid = True\\n world[position[0]][position[1]] = player\\n\\n return position\",\n \"def bcp_player_turn_start(self, player, **kwargs):\\n\\n if ((self.player and self.player.number != player) or\\n not self.player):\\n\\n self.player = self.player_list[int(player)-1]\",\n \"def set_player_position(self, position):\\n raise NotImplementedError\",\n \"def center_on_spawn(self):\\n self.center_on(*self.world.metadata['playerStart'])\",\n \"def setCurrentPlayer(self):\\n self.current_player = next(self.get_player_order_fn())\",\n \"def reset_position(self): \\n self.rect.x = 400\\n self.rect.y = 400\\n \\n # Specifies the Player's spawnpoint as maze_arrangement[8][8], representing\\n # the tile in the center of the maze \\n self.__minotaur_x = 8\\n self.__minotaur_y = 8\",\n \"def place_player(self, player, position):\\n self.board[position] = player\",\n \"def try_move_player(self):\\n player = self.player\\n if player.direction == 'U':\\n next_position = (player.position[0], player.position[1] - 1)\\n elif player.direction == 'D':\\n next_position = (player.position[0], player.position[1] + 1)\\n elif player.direction == 'L':\\n next_position = (player.position[0] - 1, player.position[1])\\n elif player.direction == 'R':\\n next_position = (player.position[0] + 1, player.position[1])\\n\\n if self.__is_valid_position(next_position):\\n self.player.position = next_position\\n else:\\n self.game_over = True\",\n \"def init_position():\\n __maze.init_position()\",\n \"def initial_move(self):\\n\\n # Make the first move based on the game we\\n # are currently playing, otherwise return\\n if isinstance(self.get_game_space(), Gomoku):\\n\\n # play one stone in the bottom left-hand corner\\n self.get_game_space().set_tile(0,6,self.get_affinity())\\n\\n # the agents are now in play \\n self.set_play_status(True)\\n self.get_opponent().set_play_status(True)\\n\\n else:\\n print('Unknown game. Returning')\\n return None\",\n \"def update_players_locations(self):\\n self.loc = self.find_value(1)\\n self.opponent_loc = self.find_value(2)\",\n \"async def on_world_start(self, data, connection):\\n player = self.plugins['player_manager'].get_player_by_name(\\n connection.player.name)\\n if hasattr(player, 'seen_before'):\\n return True\\n else:\\n self.background(self._new_player_greeter(connection))\\n self.background(self._new_player_gifter(connection))\\n player.seen_before = True\\n return True\",\n \"def respawn_player(self):\\n self.rect.x = 50\\n self.rect.y = 50\\n \\n # Specifies the Player's spawnpoint as maze_arrangement[1][1], representing\\n # the tile in the top-left corner of the maze\\n self.__user_x = 1\\n self.__user_y = 1\",\n \"def move_player(self, delta):\\n if self.player_pos + delta in MAP:\\n self.player_pos = self.player_pos + delta\",\n \"def player_left(self) -> None:\\n self._routes[self._current_route_key][\\\"LEFT\\\"] += 1\\n new_pos = self._player.x - self.MOVE_INC\\n if new_pos + self.PLAYER_DIM <= self._width and new_pos - self.PLAYER_DIM >= 0:\\n self._player.x = new_pos\",\n \"def set_player(self, new_player):\\n self.player = new_player\",\n \"def switch_player(self):\\n self.player = Nim.other_player(self.player)\",\n \"def setPosition(self):\\n # determine posX, posY for battle\\n (x1,y1) = globals.battlemapQuadrants[self.systemGrid]\\n self.posX = x1+self.setX\\n self.posY = y1+self.setY\",\n \"def setPlayerPositions(self, updates):\\r\\n for upd in updates:\\r\\n playerNode = self.playersNode.find(upd[0])\\r\\n playerNode.setPos(upd[1])\\r\\n playerNode.setHpr(upd[2])\",\n \"def move_player():\\r\\n global current_position #say that we want to refer to the one above!\\r\\n if map1[current_position[0]][current_position[1]] == 'x':\\r\\n print('we hit a wall!')\\r\\n current_position = previous_position #hit a wall so we return to the previous position\\r\\n else:\\r\\n if map1[current_position[0]][current_position[1]] == 'f': #check have we reach the flag yet\\r\\n map1[current_position[0]][current_position[1]] = 'p' #set new position to be the player\\r\\n map1[previous_position[0]][previous_position[1]] = ' ' #set previous position to be empty space\\r\\n print('we maade it!')\\r\\n return True\\r\\n map1[current_position[0]][current_position[1]] = 'p' #move the player to the next position\\r\\n map1[previous_position[0]][previous_position[1]] = ' '\",\n \"def set_player_tile(self, tile_coords):\\n #self.tiles[ self.player_position[0] ][ self.player_position[1] ].has_player = False\\n self.player_position = list(tile_coords)\\n #self.tiles[ self.player_position[0] ][ self.player_position[1] ].has_player = True\",\n \"def do_start_joined(self):\\n\\t\\td = {\\\"state\\\": be.S_GAME,\\n\\t\\t\\t\\t\\\"hosting\\\": False,\\n\\t\\t\\t\\t\\\"uuid\\\": None,\\n\\t\\t\\t\\t\\\"name\\\": self.game_name,\\n\\t\\t\\t\\t\\\"nickname\\\": self.nickname,\\n\\t\\t\\t\\t\\\"num_players\\\": self.num_players,\\n\\t\\t\\t\\t\\\"boardsize\\\": self.boardsize}\\n\\t\\tevent = pygame.event.Event(be.E_STATE, d)\\n\\t\\tpygame.event.post(event)\\n\\n\\t\\tself.hide_all()\\n\\t\\tself.renderer.color = (0, 0, 0, 0)\",\n \"def newPlayer():\\r\\n global player\\r\\n if player == 1:\\r\\n player = 2\\r\\n else:\\r\\n player = 1\",\n \"def player(self):\\n legal = self.board.legal_move(self.black)\\n if(len(legal) == 0):\\n self.p_no_move = 1\\n print(\\\"No legal move for player!\\\")\\n self.computer_turn = True\\n self.player_turn = False\",\n \"def __init__(self, player):\\n self.platform_list = pygame.sprite.Group()\\n #self.enemy_list = pygame.sprite.Group()\\n self.player = player\\n self.bullet_list = pygame.sprite.Group()\\n self.enemy_list = pygame.sprite.Group()\\n self.active_sprite_list = pygame.sprite.Group()\\n \\n # How far this world has been scrolled left/right\\n self.world_shift = 0\",\n \"def set_next_first_player(self):\\n if self.current_player == self.player1:\\n self.player1.won_previous = True\\n self.player2.won_previous = False\\n else:\\n self.player2.won_previous = True\\n self.player1.won_previous = False\",\n \"def place_player(self, player, position):\\n quadrant = position // self.quadrant_positions_count\\n quadrant_position = position % self.quadrant_positions_count\\n self.play_area[quadrant].place_player(player, quadrant_position)\",\n \"def __init__(self):\\n self.played_pos = []\\n self.grid = [['-', '-', '-'],\\n ['-', '-', '-'],\\n ['-', '-', '-']]\\n self.player_played_pos = {'p1': set(), 'p2': set()}\",\n \"async def set_player(self, player: Optional[andesite.Player]) -> None:\\n ...\",\n \"def change_player(self):\\n if self.__root.children is None:\\n if self.__root.win[0] == 1:\\n self.win = Board.PLAYER_0\\n elif self.__root.win[1] == 1:\\n self.win = Board.PLAYER_1\\n elif self.__root.win[0] == 0 and self.__root.win[1] == 0:\\n self.win = 'tie'\\n\\n self.player = Board.PLAYERS[(Board.PLAYERS.index(self.player) + 1) %\\n len(Board.PLAYERS)]\",\n \"def set_init_pose(self):\\n self.move_joints(self.init_cart_vel)\\n\\n return True\",\n \"def set_starting_pos(self):\\n if self.start and self.is_unoccupied(*self.start):\\n self.current_pos = self.start[:]\\n else:\\n self.set_random_pos('starting')\",\n \"def switchPlayer(self):\\n self.player = Nim.otherPlayer(self.player)\",\n \"def on_key_press(self, key):\\n if key == LEFT:\\n self.player.change_x = -5\\n elif key == RIGHT:\\n self.player.change_x = 5\\n elif key == UP:\\n self.player.change_y = -5 \\n elif key == DOWN:\\n self.player.change_y = 5\",\n \"def set_start_position(self) -> None:\\n self.cozmo.set_head_angle(degrees(0)).wait_for_completed()\\n self.cozmo.set_lift_height(0.0).wait_for_completed()\",\n \"def set_player(self, char_data):\\n self.player = self.server.object_manager.add_player(char_data)\",\n \"def place_player(self, start_position=None, uid=None):\\n if start_position is None:\\n temp_player_index = np.random.choice(np.arange(self.maze.size),\\n replace=False,\\n size=1)\\n # Create flattened array to map\\n temp_arr = self.maze.flatten()\\n\\n # Provide stop placeholder for loop\\n loop_brake = 0\\n\\n while int(temp_player_index) in self.forbid_indices[0]:\\n # Propose index for player to occupy\\n temp_player_index = np.random.choice(np.arange(self.maze.size),\\n replace=False,\\n size=1)\\n\\n # To keep the placeholder loop from running to infinity\\n loop_brake += 1\\n if loop_brake > len(temp_arr):\\n sys.exit(\\\"Player Placement Failed! No unreserved space detected\\\")\\n else:\\n continue\\n\\n if uid is None:\\n # Remake original structure\\n temp_arr[temp_player_index] = self.next_play_id\\n\\n # Carry progress to values list\\n self.black_list.append(self.next_play_id)\\n\\n elif uid not in self.black_list:\\n temp_arr[temp_player_index] = uid\\n\\n # Carry progress to values list\\n self.black_list.append(uid)\\n\\n else:\\n sys.exit(\\\"Player Placement Failed! Proposed UID already in black_list\\\")\\n\\n self.forbid_indices[0].append(int(temp_player_index))\\n\\n # Remake original structure\\n self.maze = temp_arr.reshape(self.dims)\\n\\n if uid is None:\\n self.find_player(self.next_play_id)\\n self.next_play_id += 1\\n else:\\n self.find_player(uid)\",\n \"def set_player(self, player_params):\\n\\n self.saved_player = player_params\",\n \"def set_init_pose(self, init_pose):\\n \\tself.check_publishers_connection()\\n \\tself.move_joints(init_pose)\",\n \"def place_marker(self, player, position):\\n\\n assert player in [1,2]\\n assert position[0] in range(10)\\n assert position[1] in range(10)\\n\\n if position in self.board.keys():\\n return False\\n \\n self.board[position] = player\\n return True\",\n \"def initGame(self):\\n self.map = {}\\n self.blocks = Group()\\n self.Coins =Group()\\n self.players = Group()\\n self.player1 = Player(1525,75,2)\\n self.players.add(self.player1)\\n if self.playernum == 2:\\n self.player2 = Player(75,825,1)\\n self.players.add(self.player2)\\n else:\\n self.player2 = False\",\n \"def set_player(self, player):\\n\\n self._player = player\",\n \"def start_of_game(self):\\n pass\",\n \"def init_game(self):\\n self.view.carregar_jogadores_possiveis(self._possible_players_list())\\n self.view.put_view_in_main_loop()\",\n \"def on_player_join(self, pid):\\n logging.info(\\\"%s joined.\\\", pid)\\n\\n # first, look if this server has a default class established\\n # if not, pick a random class stored in the World personae\\n if self.default_class is not None:\\n PlayerCls = self.default_class\\n else:\\n PlayerCls = self.world.random_cls()\\n\\n # initialize the Character and add it to the server\\n character = PlayerCls()\\n self.players[pid] = character\\n\\n # now prepare a location for the player\\n # as with default_class, a server-wide default_location takes\\n # precedence\\n if self.default_location is not None:\\n start_loc = self.default_location\\n elif PlayerCls.starting_location is not None:\\n start_loc = PlayerCls.starting_location\\n # if no default location has been defined for CharacterClass or\\n # server, resort to picking the first location in locations\\n else:\\n try:\\n start_loc = next(iter(self.world.locations.values()))\\n except StopIteration:\\n logging.critical(\\\"Could not spawn %d, \\\"\\n \\\"world has no locations\\\", pid)\\n return\\n logging.warning(\\\"%s has no default location, \\\"\\n \\\"so %d will be spawned in %s\\\",\\n PlayerCls, pid, start_loc)\\n\\n # put the character in \\\"greet\\\" mode\\n character.spawn(start_loc)\",\n \"def player_update(self,p,player):\\n node = self._validate(p)\\n node._player = player\",\n \"def init_player():\\n global active_track_idx\\n global track_last_slided_pos\\n global track_last_paused_pos\\n global track_total_play_time \\n\\n # INITIALIZE Player\\n active_track_idx = -1\\n cancel_update_play_time_loop()\\n cancel_track_end_event_loop()\\n track_status.set(\\\"---\\\")\\n track_title.set(\\\"--- : \\\")\\n play_pause_btn.configure(image=play_img)\\n track_last_slided_pos = 0\\n track_last_paused_pos = 0\\n track_total_play_time = 0\\n track_pos_label.configure(text=\\\"00:00\\\")\\n track_length_label.configure(text=\\\"00:00\\\")\\n track_pos_slider.configure(state=\\\"disabled\\\")\\n track_pos.set(0)\",\n \"def _set_init_pose(self):\\n #raw_input(\\\"INIT SPEED PRESS\\\")\\n self.move_base(self.init_linear_speed_vector,\\n self.init_angular_turn_speed,\\n epsilon=0.05,\\n update_rate=10)\\n # We Issue the landing command to be sure it starts landing\\n #raw_input(\\\"LAND PRESS\\\")\\n # self.land()\\n\\n return True\",\n \"def player_collision(self, player):\\n return True\",\n \"def player_movement(self):\",\n \"def player_up(self) -> None:\\n self._routes[self._current_route_key][\\\"UP\\\"] += 1\\n new_pos = self._player.y - self.MOVE_INC\\n if new_pos + self.PLAYER_DIM <= self._height and new_pos - self.PLAYER_DIM >= 0:\\n self._player.y = new_pos\",\n \"def setNewPosition(self,board_object,x,y):\\n\\t\\tif checkClash(board_object,self,x,y)==0:\\n\\t\\t\\toverlayMatrix(board_object,self,x,y)\\n\\t\\t\\tself.setPos(x,y)\\n\\t\\t\\treturn 0\\n\\t\\telse:\\n\\t\\t\\treturn 1\",\n \"def bot_init():\\n client.Console.Say('Hello World')\\n global player\\n player = client.GetPlayer()\",\n \"def spawnPlayer( player ):\\r\\n \\r\\n room = random.sample(world.maps.World.roomsList, 1)[0]\\r\\n \\r\\n # Uncomment below to force spawn in a certain room\\r\\n room = \\\"544\\\"\\r\\n \\r\\n player.room = room\\r\\n world.maps.World.mapGrid[room].players[player.name] = player\\r\\n player.status = PLAYING\\r\\n sendToRoomNotPlayer( player, \\\"{0}{1} appears in a flash!{2}\\\".format(BLUE, player, WHITE) )\\r\\n tellWorld( player, None, \\\"{0} has entered the arena!\\\".format(player.name) )\\r\\n \\r\\n displayRoom(player, player.room)\",\n \"def set_ready(self):\\n if self.game.has_started() or self.status == self.PLAYER_READY:\\n return\\n self.status = self.PLAYER_READY\\n self.game.player_is_ready()\",\n \"def before_turn(self, playerInfo):\\n self.PlayerInfo = playerInfo\",\n \"def set_points(self):\\n self.white_player.play_against(self.black_player)\\n self.black_player.play_against(self.white_player)\\n\\n if self.ended:\\n if self.winner is not None:\\n self.winner.points += 1\\n else:\\n self.white_player.points += 0.5\\n self.black_player.points += 0.5\",\n \"def setup_players(self, players):\\n\\t\\tself.players.clear()\\n\\t\\tids = set([p.get_player_id() for p in players])\\n\\t\\tfor p in self.state.get_players():\\n\\t\\t\\tif p not in ids:\\n\\t\\t\\t\\traise PlayerException(p)\\n\\t\\tfor p in players:\\n\\t\\t\\tself.players[p.get_player_id()] = p\",\n \"def move_me_on_spawn(self):\\r\\n\\t\\tif self.points_to_go:\\r\\n\\t\\t\\tself.start_pos = self.points_to_go[0]\\r\\n\\t\\t\\tfor point in self.points_to_go[1:]:\\r\\n\\t\\t\\t\\tfor i in range(len(self.points_to_go[1:])):\\r\\n\\t\\t\\t\\t\\tself.goal_pos = self.points_to_go[i]\\r\\n\\t\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t\\tself.move_me()\\r\\n\\t\\t\\t\\t\\t#self.start_pos = \\r\\n\\t\\t\\t\\t\\t#print(self.goal_pos)\\r\\n\\t\\t\\t\\t\\t#if self.move_me():\\r\\n\\t\\t\\t\\t\\t#\\ti += 1\\r\\n\\t\\t\\t\\t\\t#\\tprint('switch')\\r\",\n \"def start(self):\\n self.player = Player()\\n self.dealer = Dealer()\\n self.pot = 0\\n self.side_bet = 0\\n start_game()\",\n \"async def async_set_playhead_position(self, position):\\n self._playhead_position = position\",\n \"def reset(self, starting_player):\\n self.__turn = starting_player.value\\n self.__turns_played = 0\\n self.__winner = MarkerType.NONE\\n self.__loser = MarkerType.NONE\\n\\n for y in range(Settings.SIZE_Y):\\n for x in range(Settings.SIZE_X):\\n self.__grid[y][x] = MarkerType.NONE\\n\\n self.__state = GameState.PLAYING\",\n \"def _set_init_pose(self):\\n cmd = np.zeros(16 * self.n)\\n self.move_joints(cmd)\",\n \"def initGameState(self):\\n print(\\\"Setting game state: \\\")\\n self.playGUI = GUI()\\n self.playGUI.drawBoard(self.player)\",\n \"def __init__(self):\\n pos = _get_mc().player.getTilePos() + Vec3(2, 0, 0)\\n pos = _Vec3(pos.x, pos.y, pos.z)\\n _GenericBot.__init__(self, pos)\\n self._pos = pos\\n self._move(self._pos)\",\n \"def reset_position(self):\\n self.snd_explosion.play()\\n pygame.time.delay(1000)\\n self.score.iff = \\\"\\\"\\n self.ship.alive = True\\n self.ship.position.x = self.world.left + self.config['Ship']['ship_pos_x'] * self.aspect_ratio\\n self.ship.position.y = self.world.top + self.config['Ship']['ship_pos_y'] * self.aspect_ratio\\n self.ship.velocity.x = self.config['Ship']['ship_vel_x']\\n self.ship.velocity.y = self.config['Ship']['ship_vel_y']\\n self.ship.orientation = self.config['Ship']['ship_orientation']\",\n \"def to_init_position(self):\\n if self._pinit == None:\\n raise Exception('initial position for motor {} not known'.format(self._port))\\n self.change_position(self._pinit)\",\n \"def init_position(self):\\n\\t\\t\\n\\t\\t# Starting position, 1 is for WHITE, -1 is for BLACK\\n\\t\\tself['D4'] = self['E5'] = 1\\n\\t\\tself['D5'] = self['E4'] = -1\",\n \"def at_start(self):\\n if not self.db.started:\\n self.player.start()\\n self.db.started = True\",\n \"def set_movement(self, x, y):\\r\\n if x < 0 or x > 2:\\r\\n return False\\r\\n if y < 0 or y > 2:\\r\\n return False\\r\\n rotation_one = self.rotate_matrix(self.matrix)\\r\\n rotation_two = self.rotate_matrix(rotation_one)\\r\\n matrix = self.rotate_matrix(rotation_two)\\r\\n if matrix[x][y] == \\\" \\\":\\r\\n matrix[x][y] = self.player\\r\\n self.rotate_matrix = self.rotate_matrix(matrix)\\r\\n self.round_game = self.round_game + 1\\r\\n if self.player == self.players[0]:\\r\\n self.player = self.players[1]\\r\\n else:\\r\\n self.player = self.players[0]\\r\\n return True\\r\\n return False\",\n \"def player_moves_player(self, x, y):\\n activePlayer = self.get_active_player()\\n if activePlayer.humanControlled:\\n super(RobotGame, self).player_moves_player(x, y)\",\n \"def move(self, position):\\n if self.win:\\n raise ValueError('Game finished!')\\n\\n if self.board[position] != Board.CELL_EMPTY:\\n raise ValueError('Cell not empty')\\n\\n self.board[position] = self.player\\n self.__root = BinaryNode(self.board, position, self.player)\\n\\n self.change_player()\",\n \"def move_player(direction):\\n global ZERO_BASE_PLYR_POS\\n if direction == \\\"north\\\":\\n ZERO_BASE_PLYR_POS -= 10\\n elif direction == \\\"south\\\":\\n ZERO_BASE_PLYR_POS += 10\\n elif direction == \\\"west\\\":\\n ZERO_BASE_PLYR_POS -= 1\\n elif direction == \\\"east\\\":\\n ZERO_BASE_PLYR_POS += 1\\n \\n sleep(0.5) # all moves have a 0.5 second delay\\n \\n show_ground_feature()\",\n \"def _acting_player_position(self):\\n return self._env.acting_player_position\",\n \"def init_position(self):\\n if self.invert_init_angle is False:\\n self.theta_i_top = -self.theta_s_top\\n self.theta_i_bot = -self.theta_s_bot\\n else:\\n self.theta_i_top = self.theta_s_top\\n self.theta_i_bot = self.theta_s_bot\\n\\n self.move_mid_block(theta=self.theta_i_bot)\\n self.move_top_block(theta=self.theta_i_top)\\n\\n # Variables used to motion\\n self.x_offset = self.block_top.center.x\\n self.d_top = np.sin(self.theta_s_top) * self.bars_top.length * 2\\n self.d_bot = np.sin(self.theta_s_bot) * self.bars_bot.length * 2\",\n \"def _initialize_player_stats(self):\\r\\n self.reset()\\r\\n for x in range(self.num_players):\\r\\n self.player_draws[f'{x}']=[]\\r\\n self.player_points[f'{x}']= 0\",\n \"def on_key_release(self, key):\\n if key == LEFT:\\n self.player.change_x = 0\\n elif key == RIGHT:\\n self.player.change_x = 0\\n elif key == UP:\\n self.player.change_y = 0\\n elif key == DOWN:\\n self.player.change_y = 0\",\n \"def update_player_location(player):\\n global winners_index\\n print \\\"started handling requests for player: %r\\\" % str(player)\\n msg = str(player.player_socket.recv(32768))\\n while msg != \\\"finished!\\\":\\n if msg != \\\"\\\":\\n player.state = msg.strip(\\\"\\\\n\\\") + \\\" ~ \\\"\\n msg = str(player.player_socket.recv(32768))\\n\\n msg = str(player.player_socket.recv(32768))\\n if msg != \\\"\\\" and int(msg.split()[1]) == player.index:\\n winners_index = player.index\",\n \"def __init__(self, player):\\n self.root = Node(GameState(is_upper=(player == \\\"upper\\\")))\\n self.root.pruning_is_aggressive = True\\n self.start_time = self.end_time = self.time_consumed = 0\\n self.norm = norm(350, 200)\",\n \"def setup(player, state):\\n global ME\\n global THEM\\n global STATE\\n\\n player = player.upper()\\n assert player == 'X' or player == 'O'\\n ME = player\\n THEM = 'O' if player is 'X' else 'X'\\n assert state\\n STATE = state\",\n \"async def on_ready():\\n print(\\\"I'm in\\\")\\n print(client.user)\\n await client.change_presence(activity=discord.Game(name=IN_GAME))\",\n \"def update(self, pos, direction):\\n #self.rect.topleft = (xCent*30,yCent*30,)\\n self.rect.topleft = (pos)\\n if direction == 'left':\\n self.image = pygame.image.load('mainplayerleft.png').convert_alpha()\\n facing = 'left'\\n elif direction == 'right':\\n self.image = pygame.image.load('mainplayerright.png').convert_alpha()\\n facing = 'right'\",\n \"def track_players(self, boom_pos):\\n self.update_players()\\n for player in self.players:\\n if self.if_near_boom(player.get_char().get_pos(), boom_pos):\\n player.update_lives(-1)\\n self.gui.set_doneBlinkingAnimation(False)\",\n \"def setPlayerOne(self, boardSize):\\n mid = int(boardSize / 2)\\n for i in range(mid):\\n for j in range(mid):\\n if (i + j < mid):\\n self.addPion(Pion.Pion(self.noPlayer, Posisi.Posisi(i, j)))\",\n \"def check_trying_using(self):\\r\\n if self.opportunity or 'key' in inventory:\\r\\n if self.rect.colliderect(player):\\r\\n music_acceptor.usingPortalSound()\\r\\n player.rect.x = random.randrange(75, WIDTH - 125)\\r\\n player.rect.y = random.randrange(25, HEIGHT - 100)\",\n \"def follow_player(self, player_x, player_y):\\n \\n # Determines the horizontal and vertical distance between the Player and the\\n # Minotaur, converting them into that are measured by the tiles (Dividing the\\n # difference by 50 turns each of these values into integers that represent tile\\n # distances)\\n x_distance = (self.rect.x - player_x) / 50 \\n y_distance = (self.rect.y - player_y) / 50 \\n \\n # If the Minotaur is NOT on the same tile as the Player i.e. touching them\\n if x_distance != 0 and y_distance != 0:\\n \\n # Check if the Player is situated ABOVE the Minotaur and if the Minotaur is\\n # not currently animating\\n if y_distance > 0 and not self.__animating:\\n \\n # If the tile above the Minotaur is free, then set direction as up, set\\n # animating to True, and change the minotaur_y (Tile space)\\n if (self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y - 1] != 1):\\n self.__direction = \\\"UP\\\"\\n self.__animating = True\\n self.__minotaur_y -= 1\\n \\n # If the tile above the Minotaur is NOT free, and the tile to the left\\n # of the Minotaur IS free, then set direction to left, set animating\\n # to True, and change the minotaur_x (Tile space) accordingly\\n elif self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y - 1] and \\\\\\n (self.__maze_arrangement[self.__minotaur_x - 1][self.__minotaur_y] != 1) and \\\\\\n player_x < self.rect.x:\\n self.__direction = \\\"LEFT\\\"\\n self.__animating = True\\n self.__minotaur_x -= 1\\n \\n # If the tile above the Minotaur is NOT free, and the tile to the RIGHT\\n # of the Minotaur IS free, then set direction to right, set animating\\n # to True, and change the minotaur_x (Tile space) accordingly \\n elif self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y - 1] and \\\\\\n (self.__maze_arrangement[self.__minotaur_x + 1][self.__minotaur_y] != 1) and \\\\\\n player_x > self.rect.x:\\n self.__direction = \\\"RIGHT\\\"\\n self.__animating = True\\n self.__minotaur_x += 1 \\n \\n # Check if the Player is situated BELOW the Minotaur and if the Minotaur is\\n # not currently animating \\n if y_distance < 0 and not self.__animating:\\n \\n # If the tile below the Minotaur is free, then set direction as down, set\\n # animating to True, and change the minotaur_y (Tile space) \\n if (self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y + 1] != 1):\\n self.__direction = \\\"DOWN\\\"\\n self.__animating = True\\n self.__minotaur_y += 1\\n \\n # If the tile below the Minotaur is NOT free, and the tile to the RIGHT\\n # of the Minotaur IS free, then set direction to right, set animating\\n # to True, and change the minotaur_x (Tile space) accordingly \\n elif self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y + 1] and \\\\\\n (self.__maze_arrangement[self.__minotaur_x + 1][self.__minotaur_y] != 1) and \\\\\\n player_x > self.rect.x:\\n self.__direction = \\\"RIGHT\\\"\\n self.__animating = True\\n self.__minotaur_x += 1\\n \\n # If the tile below the Minotaur is NOT free, and the tile to the LEFT\\n # of the Minotaur IS free, then set direction to left, set animating\\n # to True, and change the minotaur_x (Tile space) accordingly \\n elif self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y + 1] and \\\\\\n (self.__maze_arrangement[self.__minotaur_x - 1][self.__minotaur_y] != 1) and \\\\\\n player_x < self.rect.x:\\n self.__direction = \\\"LEFT\\\"\\n self.__animating = True\\n self.__minotaur_x -= 1 \\n \\n # Check if the Player is situated RIGHT of the Minotaur and if the Minotaur is\\n # not currently animating \\n if x_distance < 0 and not self.__animating:\\n \\n # If the tile to the right of the Minotaur is free, then set direction as \\n # right, set animating to True, and change the minotaur_x (Tile space) \\n if (self.__maze_arrangement[self.__minotaur_x + 1][self.__minotaur_y] != 1):\\n self.__direction = \\\"RIGHT\\\"\\n self.__animating = True\\n self.__minotaur_x += 1 \\n \\n # If the tile to the right of the Minotaur is NOT free, and the tile ABOVE\\n # the Minotaur IS free, then set direction to up, set animating\\n # to True, and change the minotaur_y (Tile space) accordingly \\n elif self.__maze_arrangement[self.__minotaur_x + 1][self.__minotaur_y] and \\\\\\n (self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y - 1] != 1) and \\\\\\n player_y < self.rect.y:\\n self.__direction = \\\"UP\\\"\\n self.__animating = True\\n self.__minotaur_y -= 1\\n \\n # If the tile to the right of the Minotaur is NOT free, and the tile BELOW\\n # the Minotaur IS free, then set direction to down, set animating\\n # to True, and change the minotaur_y (Tile space) accordingly \\n elif self.__maze_arrangement[self.__minotaur_x + 1][self.__minotaur_y] and \\\\\\n (self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y + 1] != 1) and \\\\\\n player_y > self.rect.y:\\n self.__direction = \\\"DOWN\\\"\\n self.__animating = True\\n self.__minotaur_y += 1 \\n \\n # Check if the Player is situated LEFT of the Minotaur and if the Minotaur is\\n # not currently animating \\n if x_distance > 0 and not self.__animating:\\n \\n # If the tile to the LEFT of the Minotaur is free, then set direction as \\n # left, set animating to True, and change the minotaur_x (Tile space) \\n if (self.__maze_arrangement[self.__minotaur_x - 1][self.__minotaur_y] != 1):\\n self.__direction = \\\"LEFT\\\"\\n self.__animating = True\\n self.__minotaur_x -= 1\\n \\n # If the tile to the LEFT of the Minotaur is NOT free, and the tile BELOW\\n # the Minotaur IS free, then set direction to down, set animating\\n # to True, and change the minotaur_y (Tile space) accordingly \\n elif self.__maze_arrangement[self.__minotaur_x - 1][self.__minotaur_y] and \\\\\\n (self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y + 1] != 1) and \\\\\\n player_y > self.rect.y:\\n self.__direction = \\\"DOWN\\\"\\n self.__animating = True\\n self.__minotaur_y += 1\\n \\n # If the tile to the LEFT of the Minotaur is NOT free, and the tile ABOVE\\n # the Minotaur IS free, then set direction to up, set animating\\n # to True, and change the minotaur_y (Tile space) accordingly \\n elif self.__maze_arrangement[self.__minotaur_x - 1][self.__minotaur_y] and \\\\\\n (self.__maze_arrangement[self.__minotaur_x][self.__minotaur_y - 1] != 1) and \\\\\\n player_y > self.rect.y:\\n self.__direction = \\\"UP\\\"\\n self.__animating = True\\n self.__minotaur_y -= 1\",\n \"def player_position(self, player_ip, *args):\\r\\n\\t\\ttry:\\r\\n\\t\\t\\tteam_type = self._teammates[player_ip]\\r\\n\\t\\texcept KeyError:\\r\\n\\t\\t\\tself._comm_server.send_message(player_ip, \\\"position -1 -1\\\")\\r\\n\\t\\t\\treturn\\r\\n\\t\\telse:\\r\\n\\t\\t\\tmaze_pos_finder = self._teams[team_type].maze_pos_finder\\r\\n\\t\\t\\tplayer_info = self._teams[team_type].get_player_info_by_IP(player_ip)\\r\\n\\r\\n\\t\\t\\tpos = maze_pos_finder.get_maze_pos(player_info.color_bgr)\\r\\n\\r\\n\\t\\t\\tif pos is not None:\\r\\n\\t\\t\\t\\tself._comm_server.send_message(player_ip, \\\"position {0} {1}\\\" \\\\\\r\\n\\t\\t\\t\\t\\t.format(*pos.position))\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tself._comm_server.send_message(player_ip, \\\"position -1 -1\\\")\",\n \"def assign_leftLimit():\\r\\n player.rect.x = 25\",\n \"def setPosition(position):\",\n \"def maybe_start(self):\\r\\n\\t\\tif not [p for p in self.players if not p.ready]\\\\\\r\\n\\t\\t and len(self.players) == self.max_players \\\\\\r\\n\\t\\t and not self.started:\\r\\n\\t\\t\\tself.start()\",\n \"def send_player_position(self):\\n pl_coor_dict = {}\\n for pl in self.player_list:\\n #coor_list = [[p.x(),p.y()] for p in pl._line_list]\\n pl_coor_dict[pl.id] = pl.get_line_list_float()\\n self.on_data_to_all_clients({\\\"game\\\":{\\\"player_coor\\\":pl_coor_dict}})\",\n \"def set_plays(self) -> None:\\n player1 = self._get_input('What is the name of player 1?')\\n player2 = self._get_input('What is the name of player 2?')\\n self.state = State(player1, player2)\",\n \"def setUp(self):\\n self.player = ship.Player(\\n constants.PLAYER_START_PLACE,\\n constants.PLAYER_WIDTH,\\n constants.PLAYER_HEIGHT,\\n constants.PLAYER_IMG,\\n constants.PLAYER_HEALTH\\n )\\n\\n self.alien = ship.Alien(\\n [320, 300],\\n 30,\\n 30,\\n constants.GREEN_ALIEN_IMG,\\n 1\\n )\\n\\n self.alien.shooting([320, 300], 5, False)\\n\\n self.player.shooting([self.player.position[0] + 3, self.player.position[1]], 1, True)\",\n \"def update(self):\\r\\n if not self.tr.game_over and self.tr.turn_tracker:\\r\\n self.computer_play()\",\n \"def __init__(self, player1, player2, state_machine, restore = False):\\r\\n super().__init__()\\r\\n self.__players[0] = player1\\r\\n self.__players[1] = player2\\r\\n self.__player_names[player1] = 'Human'\\r\\n self.__player_names[player2] = 'Bot'\\r\\n self.__state_machine = state_machine\",\n \"def place_entrance(self):\\r\\n x = random.randint(0, (self.__nx - 1))\\r\\n y = random.randint(0, (self.__ny - 1))\\r\\n self.__current_room = x, y # places adventurer in dungeon at start of game\\r\\n self.__entrance_room = x, y\\r\\n self.__maze[x][y].set_entrance(True)\",\n \"def join_player(self, data, user):\\n self.remove(user)\\n\\n user.room = \\\"100\\\"\\n user.x = \\\"0\\\"\\n user.y = \\\"0\\\"\\n user.frame = \\\"0\\\"\\n\\n self.add(user)\",\n \"def setup_game(self, player, opponent):\\n\\n self.display.clear_screen()\\n\\n ship_index = 0\\n\\n while not player.ready(len(self.SHIP_INFO)):\\n # prints the currrent board\\n board = self.display.construct_player_board(player, opponent, True)\\n self.display.print_board(board)\\n\\n ship_name, ship_length = self.SHIP_INFO[ship_index]\\n ship_to_add = Ship(ship_name, ship_length)\\n\\n try:\\n player.add_ship(ship_to_add)\\n except Exception as e:\\n ship_to_add = player.ships[ship_index]\\n\\n origin, orientation = self.display.prompt_for_ship_placement(\\n ship_to_add)\\n\\n try:\\n player.place_ship(ship_to_add, origin, orientation,\\n self.BOARD_SIZE)\\n except ValueError as ve:\\n self.display.clear_screen()\\n print(ve)\\n print()\\n continue\\n\\n self.display.clear_screen()\\n ship_index += 1\\n self.display.prompt_switch(opponent.name)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67391527","0.6602128","0.6521799","0.64235747","0.6403209","0.6356068","0.6108178","0.6093458","0.60934067","0.6075032","0.60552895","0.6033364","0.597676","0.59481853","0.58926964","0.58049136","0.5797736","0.5780764","0.577982","0.5772904","0.5766168","0.5756142","0.5748849","0.5744815","0.57444316","0.5738558","0.57284653","0.5728142","0.57253474","0.57021666","0.56949186","0.56901634","0.5689566","0.5641579","0.5637239","0.56147015","0.5611571","0.560987","0.5588452","0.5585842","0.5573452","0.5570917","0.55682343","0.55603224","0.55582875","0.55540234","0.5553847","0.55435264","0.5541365","0.55400884","0.5514359","0.55023074","0.5498428","0.54969466","0.5493766","0.5489843","0.5487016","0.54793715","0.5468877","0.5463896","0.5455988","0.54520494","0.5451366","0.5446715","0.5438561","0.5435732","0.5423129","0.5421144","0.54199964","0.54147613","0.5407565","0.5406398","0.54049736","0.5400074","0.5398498","0.53928643","0.538745","0.5386919","0.5381965","0.53808177","0.5374858","0.53734505","0.53680754","0.5364777","0.5358935","0.5357105","0.5352717","0.5350849","0.5349674","0.5346343","0.53422856","0.53395337","0.533792","0.5337382","0.5333908","0.5333902","0.5319204","0.53183794","0.5314495","0.53117484"],"string":"[\n \"0.67391527\",\n \"0.6602128\",\n \"0.6521799\",\n \"0.64235747\",\n \"0.6403209\",\n \"0.6356068\",\n \"0.6108178\",\n \"0.6093458\",\n \"0.60934067\",\n \"0.6075032\",\n \"0.60552895\",\n \"0.6033364\",\n \"0.597676\",\n \"0.59481853\",\n \"0.58926964\",\n \"0.58049136\",\n \"0.5797736\",\n \"0.5780764\",\n \"0.577982\",\n \"0.5772904\",\n \"0.5766168\",\n \"0.5756142\",\n \"0.5748849\",\n \"0.5744815\",\n \"0.57444316\",\n \"0.5738558\",\n \"0.57284653\",\n \"0.5728142\",\n \"0.57253474\",\n \"0.57021666\",\n \"0.56949186\",\n \"0.56901634\",\n \"0.5689566\",\n \"0.5641579\",\n \"0.5637239\",\n \"0.56147015\",\n \"0.5611571\",\n \"0.560987\",\n \"0.5588452\",\n \"0.5585842\",\n \"0.5573452\",\n \"0.5570917\",\n \"0.55682343\",\n \"0.55603224\",\n \"0.55582875\",\n \"0.55540234\",\n \"0.5553847\",\n \"0.55435264\",\n \"0.5541365\",\n \"0.55400884\",\n \"0.5514359\",\n \"0.55023074\",\n \"0.5498428\",\n \"0.54969466\",\n \"0.5493766\",\n \"0.5489843\",\n \"0.5487016\",\n \"0.54793715\",\n \"0.5468877\",\n \"0.5463896\",\n \"0.5455988\",\n \"0.54520494\",\n \"0.5451366\",\n \"0.5446715\",\n \"0.5438561\",\n \"0.5435732\",\n \"0.5423129\",\n \"0.5421144\",\n \"0.54199964\",\n \"0.54147613\",\n \"0.5407565\",\n \"0.5406398\",\n \"0.54049736\",\n \"0.5400074\",\n \"0.5398498\",\n \"0.53928643\",\n \"0.538745\",\n \"0.5386919\",\n \"0.5381965\",\n \"0.53808177\",\n \"0.5374858\",\n \"0.53734505\",\n \"0.53680754\",\n \"0.5364777\",\n \"0.5358935\",\n \"0.5357105\",\n \"0.5352717\",\n \"0.5350849\",\n \"0.5349674\",\n \"0.5346343\",\n \"0.53422856\",\n \"0.53395337\",\n \"0.533792\",\n \"0.5337382\",\n \"0.5333908\",\n \"0.5333902\",\n \"0.5319204\",\n \"0.53183794\",\n \"0.5314495\",\n \"0.53117484\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6329127"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":84798,"cells":{"query":{"kind":"string","value":"game status is changed from hold to go , on game start"},"document":{"kind":"string","value":"def on_game_go(self):\n print(\"============game go\")\n # create dict with players - defines the players that are playing\n self.on_data_to_all_clients({\"game\":{\"hide_all_dialogs\":\"\"}})\n\n for pl in self.player_list:\n if pl.client not in self.client_pl_dict :\n self.client_pl_dict[pl.client] = pl\n pl.override_direction(4)\n\n self.add_food_item()\n\n self.is_game_going = True\n #for pl in self.player_list:\n # pl.direction = 4"},"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 get_new_gamestate(self):","def update_state(self):\n if not self.platforms:\n self.state = self.states['Win']\n elif self.player.y > 389:\n self.state = self.states['Lose'] \n else:\n self.state = self.states['Game']","def update(self):\r\n if not self.tr.game_over and self.tr.turn_tracker:\r\n self.computer_play()","def change_player_state(self):\n if self.active_player.get() is True:\n # Get game phase and unlock respective buttons?\n # or should game do that\n pass\n else:\n pass\n #self.disable_all_buttons()","def _active(self):\n self._soundhelper()\n k = self._game.getPlayerLives()\n self._movePaddle()\n self._game.moveBall(self._sound)\n if self._game.getPlayerLives() == 0:\n self._state = STATE_COMPLETE\n elif self._game.getPlayerLives() < k:\n self._state = STATE_PAUSED","def start_of_game(self):\n pass","def game_play(self):","def set_game_state(self,winner):\r\n if winner == 'b':\r\n self._game_state = \"BLACK_WON\"\r\n else:\r\n self._game_state = \"RED_WON\"","def handleGameState(self):\n if self.state == GameState.PLAYER_LOOSE:\n self.drawMessage(\" Hai perso! \", 3000)\n elif self.state == GameState.LEVEL_COMPLETED:\n self.sound_completed_level.play()\n code = self.get_code(self.levelIndex+1)\n code_msg = \"\"\n if code:\n code_msg = \"[Codice Bonus:%s]\" % code\n self.drawMessage(\" %s completato! %s\" % (self.level_name, code_msg), 3000)\n self.levelIndex += 1\n self.screen.fill(Game.BLACK)\n self.setupLevel()\n self.run()\n elif self.state == GameState.PLAYER_WON:\n self.drawMessage(\"Hai vinto!\", 5000)\n # esco dal gioco poiche' ho terminato\n # valutare se chiedere di rincominciare la partita...\n pygame.quit()\n elif self.state == GameState.PAUSED:\n self.drawMessage(\"Pausa\", 0, False)\n elif self.state == GameState.HELP:\n self.drawHelpText()","def _active(self):\n self._game.updatePaddle(self.input)\n self._game.updateBall()\n self._game.updateFP()\n self._lose_life()\n self._new_n_press()\n self._points_mssg.text = str(self._game.getPoints())\n if not self._game.getPointsFP() is None:\n self._catchFP()\n self._FP_mssg_timer()\n # check for victory\n if self._game.getLengthBricks() <= 0:\n self._state = STATE_COMPLETED\n \n self.draw()\n self._game.draw()","def notify_game_over(self):\n self.is_game_over = True","def init_game_setting(self):\n self.state.state_counter_while_testing += 1","def start_game(self):\n\n\t\tpass","def update(self):\n if self.game_over is False:\n self.player_turn = not self.player_turn\n self.turn_display_timer = self.TURN_TEXT_TIMER","def state_wait_enter(cfg, app, win):","def update_game(game, episode, buttons,run_status):\n\n game_round = game.round\n if game_round == 'newround':\n newround(game)\n print(game_round)\n game.round = 'preflop'\n print(game.round)\n\n\n return 'go'\n elif game_round == 'preflop':\n check = preflop(game, episode, buttons)\n if check == True:\n game.round = 'flop'\n return 'go'\n elif check == False:\n game.round = 'showdown'\n print(game.round)\n return 'go'\n elif check == 'no input':\n game.round = 'preflop'\n return 'stop'\n return 'stop'\n elif game_round == 'flop':\n check = flop(game, episode, buttons, run_status)\n if check == True:\n game.round = 'turn'\n return 'go'\n elif check == False:\n game.round = 'showdown'\n return 'go'\n elif check == 'no input':\n game.round = 'flop'\n return 'stop'\n return 'stop'\n pass\n elif game_round == 'turn':\n check = turn(game, episode, buttons, run_status)\n if check == True:\n game.round = 'river'\n return 'go'\n elif check == False:\n game.round = 'showdown'\n return 'go'\n elif check == 'no input':\n game.round = 'turn'\n return 'stop'\n return 'stop'\n elif game_round == 'river':\n check = turn(game, episode, buttons, run_status)\n if check == True:\n game.round = 'showdown'\n return 'go'\n elif check == False:\n game.round = 'showdown'\n return 'go'\n elif check == 'no input':\n game.round = 'river'\n return 'stop'\n return 'stop'\n elif game_round == 'showdown':\n showdown(game, episode)\n #game.player1.wager = 100\n #game.player2.wager = 50\n # game.update_tablepot()\n game.round = 'newround'\n return 'go'\n pass","def state_wait_do(cfg, app, win, events):","def resign_game(self):\n if self._current_player == \"BLACK\":\n self._game_state = \"WHITE_WON\"\n\n else:\n self._game_state = \"BLACK_WON\"","async def change_status():\n await client.change_presence(activity=discord.Game(next(appearance.status)))","def process_game_logic(self):\n self.dmod = -1\n self.smod = -1\n if self.state == self.STATE_SETUP:\n if self.current_game < self.config['General']['games_per_session']:\n self.current_game += 1\n self.state = self.STATE_GAMENO\n self.game_title = \"Game: %d of %d\" % (self.current_game, self.config['General']['games_per_session'])\n self.game_title = pygl2d.font.RenderText(self.game_title, (255, 255, 0), self.f36)\n self.game_title_rect = self.game_title.get_rect()\n self.game_title_rect.center = (self.SCREEN_WIDTH / 2, self.SCREEN_HEIGHT / 16 * 7)\n self.gameevents.add(\"display_game\", self.current_game)\n else:\n self.state = self.STATE_DONE\n self.ret = 0\n self.lc.stop()\n elif self.state == self.STATE_SETUP_IFF:\n self.mine_list.generate_foes()\n self.gameevents.add(\"display_foes\", \" \".join(self.mine_list.foe_letters), \"player\")\n self.foe_top = pygl2d.font.RenderText(\"The Type-2 mines for this session are:\", (255, 255, 0), self.f24)\n self.foe_top_rect = self.foe_top.get_rect()\n self.foe_top_rect.center = (self.SCREEN_WIDTH / 2, 270 * self.aspect_ratio)\n self.foe_middle = pygl2d.font.RenderText(\", \".join(self.mine_list.foe_letters), (255, 255, 255), self.f96)\n self.foe_middle_rect = self.foe_middle.get_rect()\n self.foe_middle_rect.center = (self.SCREEN_WIDTH / 2, self.SCREEN_HEIGHT / 2)\n self.foe_midbot = pygl2d.font.RenderText(\"Try to memorize them before proceeding\", (255, 255, 0), self.f24)\n self.foe_midbot_rect = self.foe_midbot.get_rect()\n self.foe_midbot_rect.center = (self.SCREEN_WIDTH / 2, 500 * self.aspect_ratio)\n self.foe_bottom = pygl2d.font.RenderText(\"Press return to begin\", (255, 255, 0), self.f24)\n self.foe_bottom_rect = self.foe_bottom.get_rect()\n self.foe_bottom_rect.center = (self.SCREEN_WIDTH / 2, 600 * self.aspect_ratio)\n self.state = self.STATE_IFF\n elif self.state == self.STATE_PREPARE:\n self.gameevents.add(\"game\", \"ready\", type='EVENT_SYSTEM')\n self.setup_world()\n self.state = self.STATE_PLAY\n self.gameevents.add(\"game\", \"start\", type='EVENT_SYSTEM')\n elif self.state == self.STATE_PLAY:\n self.ship.compute()\n if not self.ship.jumped:\n\n overlay = np.zeros((int(self.world.bottom-self.world.top),int(self.world.right-self.world.left),3),np.uint8)\n\n\n cv2.line(overlay,(int(self.ship.position.x-self.world.left),int(self.ship.position.y-self.world.top)),(int(self.ship.oldPosx-self.world.left),int(self.ship.oldPosy-self.world.top)),(255,255,255),self.config['Playback']['line_width'])\n\n cv2.addWeighted(overlay,self.config['Playback']['intensity']/100.0,self.img,1.0,0,self.img)\n\n distance = self.ship.get_distance_to_point(self.WORLD_WIDTH / 2, self.WORLD_HEIGHT / 2)\n flight_max_inc = self.config['Score']['flight_max_increment']\n dmod = 1 - (distance - self.smallhex.radius * 1.125) / (self.WORLD_WIDTH / 2)\n if dmod > 1.0: dmod = 1.0\n if dmod < 0.0: dmod = 0.0\n smod = max([abs(self.ship.velocity.x), abs(self.ship.velocity.y)]) / self.ship.max_vel\n self.dmod = dmod\n self.smod = smod\n for missile in self.missile_list:\n missile.compute()\n if self.fortress_exists == True:\n self.fortress.compute()\n for shell in self.shell_list:\n shell.compute()\n if self.config['Hexagon']['hex_shrink']:\n self.bighex.compute()\n if self.mine_exists:\n if self.mine_list.flag == False and self.mine_list.timer.elapsed() > self.mine_list.spawn_time:\n self.gameevents.add(\"spawn\", \"mine\")\n elif self.mine_list.flag and self.mine_list.timer.elapsed() > self.mine_list.timeout:\n self.gameevents.add(\"timeout\", \"mine\")\n self.mine_list.compute()\n self.check_bounds()\n #test collisions to generate game events\n self.test_collisions()\n if self.flighttimer.elapsed() > self.config['Score']['update_timer']:\n self.flighttimer.reset()\n def pointspace (a0, a1, a2, b0, b1, b2): return math.exp(a1 ** (a0 * a2)) * math.exp(b1 ** (b0 * b2))\n points = flight_max_inc * pointspace(self.dmod, 2, 1, self.smod, 2, 1.75) / pointspace(1, 2, 1, 1, 2, 1.75)\n self.gameevents.add(\"score+\", \"flight\", points)\n self.flight2 += flight_max_inc * pointspace(self.dmod, 2, .45, self.smod, 2, 1) / pointspace(1, 2, .45, 1, 2, 1)\n if (self.ship.velocity.x ** 2 + self.ship.velocity.y ** 2) ** 0.5 < self.config['Score']['speed_threshold']:\n self.gameevents.add(\"score+\", \"vlcty\", self.config['Score']['VLCTY_increment'])\n #self.gameevents.add(\"score+\", \"flight\", self.config['Score']['VLCTY_increment'])\n else:\n self.gameevents.add(\"score-\", \"vlcty\", self.config['Score']['VLCTY_increment'])\n #self.gameevents.add(\"score-\", \"flight\", self.config['Score']['VLCTY_increment'])\n if self.bighex.collide(self.ship):\n self.gameevents.add(\"score+\", \"cntrl\", self.config['Score']['CNTRL_increment'])\n #self.gameevents.add(\"score+\", \"flight\", self.config['Score']['CNTRL_increment'])\n else:\n self.gameevents.add(\"score+\", \"cntrl\", self.config['Score']['CNTRL_increment'] / 2)\n #self.gameevents.add(\"score+\", \"flight\", self.config['Score']['CNTRL_increment']/2)\n if self.bonus_exists:\n if self.config['General']['bonus_system'] == \"AX-CPT\":\n self.bonus.axcpt_update()\n else:\n if self.bonus.visible == False and self.bonus.timer.elapsed() > self.config['Bonus']['symbol_down_time']:\n self.gameevents.add(\"activate\", \"bonus\")\n elif self.bonus.visible == True and self.bonus.timer.elapsed() >= self.config['Bonus']['symbol_up_time']:\n self.gameevents.add(\"deactivate\", \"bonus\", self.bonus.current_symbol)\n #update scores\n self.score.pnts = self.score.__getattribute__(\"pnts\")\n self.score.vlcty = self.score.__getattribute__(\"vlcty\")\n self.score.cntrl = self.score.__getattribute__(\"cntrl\")\n self.score.speed = self.score.__getattribute__(\"speed\")\n self.score.flight = self.score.__getattribute__(\"flight\")\n self.score.fortress = self.score.__getattribute__(\"fortress\")\n self.score.mines = self.score.__getattribute__(\"mines\")\n self.score.bonus = self.score.__getattribute__(\"bonus\")\n\n if self.gametimer.elapsed() > self.config['General']['game_time']:\n self.gameevents.add(\"game\", \"over\", type='EVENT_SYSTEM')\n self.state = self.STATE_SCORES\n self.img = 255-self.img\n now = datetime.datetime.now()\n cv2.imwrite('../Recordings/' + str(now.year) + \"_\"+str(now.month)+\"_\" + str(now.day) + \"_\" + str(now.hour) + \"_\" + str(now.minute)+\"_\" + 'lines.jpg',(self.img),[int(cv2.IMWRITE_JPEG_QUALITY), 100])","def run(self, GameState):\n pass","def state_processing_do(cfg, app, win, events):","def game_over(self):\n self.over = True","def change_game_state(self, state):\n self._game_state = state","def play_game():\n pass","def initGameState(self):\n print(\"Setting game state: \")\n self.playGUI = GUI()\n self.playGUI.drawBoard(self.player)","def init_game_setting(self):\n ##################\n # YOUR CODE HERE #\n ##################\n self.state = np.zeros((1, 80, 80))\n self.clear_action()","def check_status(self, sensor, state):\n self.sensed = sensor\n if state == 1:\n self.winner = True\n elif state == -1:\n self.alive = False","def reset_game(self):\n self.bHasWon = False\n self.game_over = False\n self.game_active = False\n self.player_points = 0\n self.enemy_points = 0\n self.remainingBalls = 0","def update(self, new_gameStateData):\r\n pass","def game_over(self, won=True):\n if won is True:\n self.game[\"game_status\"] = self.WON\n else:\n self.game[\"game_status\"] = self.DISCONNECTED\n db.save_game(self.game_id, self.game)","def grab_paused(self):\n\t\tif time.time() - self.time_paused > PAUSE_INTERVAL:\n\t\t\tself.status.state = 'stop'","def _paused(self):\n self.view.clear()\n if self._game.getLives() == 2:\n self._mssg = (GLabel(text=TWO_LIFE_MSSG, x=GAME_WIDTH/2, y=GAME_HEIGHT/2,\n font_size=20))\n elif self._game.getLives() == 1:\n self._mssg = (GLabel(text=ONE_LIFE_MSSG, x=GAME_WIDTH/2, y=GAME_HEIGHT/2,\n \n font_size=20))\n if self._new_n_press():\n self._state = STATE_COUNTDOWN\n self._mssg = None\n self._game.resetPaddle()\n self.time = 0","def state_processing_enter(cfg, app, win):","def setup_game(self):","def update(self):\n # If the game is not over.\n if self.tictactoe:\n # If the player is human, the choice can only be detected by the game,\n # because the player has no responsibility over the window\n if self.player.chooser:\n choice = self.choice\n self.choice = None\n else:\n choice = self.player.play(self.tictactoe)\n self.tictactoe.choose(choice)\n else:\n if self.on:\n self.end_time = time.time()\n self.on = False\n if self.restart_at_end:\n if time.time() - self.end_time > self.end_duration:\n self.restart()","def get_game_state(self):\n return self._game_status","def update(self, dt: float) -> GameStateID:\n if self.user_clicked:\n self.user_clicked = False\n return GameStateID.START_MENU\n else:\n return GameStateID.GAME_OVER","def process(self, state, game):\n if state.isWin(): self.win(state, game)\n if state.isLose(): self.lose(state, game)","def change_status(self):\n if self.status == \"Still Loaned\":\n self.status = \"Given Back\"\n else:\n self.status = \"Still Loaned\"","def update_to_state(self, game_state):\n pass","def state_chosen_do(cfg, app, win, events):","def stand(self):\n self.endgame()","def player_stage(niv): \n playing = True\n a = niv[0][0] \n b = niv[0][1] \n (x, y) = (a, b) \n state = [[a, b]] #Create a list with the starting point of the selected level patern.\n sense.stick.get_events()\n while playing:\n for event in sense.stick.get_events(): #It moves the pixel with the player moves and add the point passed by the player in the state[].\n if event.action == 'pressed':\n if event.direction == 'left':\n if x > 0:\n x = min(x-1, 7)\n state.append([x, y])\n elif event.direction == 'right':\n if x < 7:\n x = max(x+1, 0)\n state.append([x, y])\n if event.direction == 'down':\n if y < 7:\n y = min(y+1, 7)\n state.append([x, y])\n elif event.direction == 'up':\n if y > 0:\n y = max(y-1, 0)\n state.append([x, y])\n elif event.direction == 'middle':\n playing = False\n sense.set_pixel(x, y, RED)\n if state[:] == niv[:]: #Compare the way choosen by the player with the selected level patern. Results of the try.\n sense.show_message(\"WINNER !\",\n text_colour=LEMON, scroll_speed=0.05)\n sleep(2)\n main() #brings back to the level selection.\n else:\n sense.show_message(\"LOSER !\",\n text_colour=BLUE, scroll_speed=0.05)\n sleep(2)\n try_again(niv) #cf. try_again() function","def resign_game(self):\n # If entered, it will return winner status for the opposing player\n if self._current_player == 'W':\n self._game_status = 'BLACK_WON'\n if self._current_player == 'B':\n self._game_status = 'WHITE_WON'","def update_state_game_variables(self):\n self.model.numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8]\n self.model.player_mark = \"\"\n self.model.player_move = 0\n self.model.boards = [\"board\"] * 9\n self.update_score_board()","def game_on(self) -> None:\n if self.msg.sender != self.owner:\n revert(f'Only the game owner can turn it on.')\n if not self._game_on.get():\n self._game_on.set(True)\n self._day.set(self.now() // U_SECONDS_DAY)","def _completed(self):\n if self._game.getLives() == 0: # loss\n self.view.clear()\n self._mssg = (GLabel(text=LOSS_MSSG, x=GAME_WIDTH/2, y=GAME_HEIGHT/2, font_size=16))\n else: # win\n self.view.clear()\n self._mssg = (GLabel(text='You won! (' + str(self._game.getPoints()) + ' Points)' +\n WIN_MSSG, x=GAME_WIDTH/2, y=GAME_HEIGHT/2, font_size=16))\n \n if self._new_n_press():\n self._state = STATE_NEWGAME\n self._mssg = None","def _inactive(self):\n if self._new_key_press():\n self._state = STATE_NEWGAME\n self._mssg = None","def check_status(board, player_mark, turn_counter):","def Gameloop():","def change_state(self, state, interface=None):\n \n self._state = state\n if interface != None:\n self._interface = interface\n \n if self._state == config.GS_LOADING:\n \n # Background with loading text\n self._background = self._pygame.Surface(self._screen.get_size())\n self._background = self._background.convert()\n self._background.fill((0, 0, 0))\n draw_text(self._background, (180, 180), 'Loading...', 36,\n self._white, self._pygame)\n \n elif self._state == config.GS_GAME:\n \n # Background with static text\n self._background = self._pygame.Surface(self._screen.get_size())\n self._background = self._background.convert()\n self._background.fill((0, 0, 0))\n \n draw_text(self._background, (410, 130), 'Score:', 10,\n self._white, self._pygame)\n draw_text(self._background, (410, 190), 'Lines Cleared:', 10,\n self._white, self._pygame)\n \n next_text = 'Next ' + \\\n config.names[self._interface.get_order()].title() + ':'\n draw_text(self._background, (410, 250), next_text, 10,\n self._white, self._pygame)\n \n # Grid\n w = 210 + 10 - self._interface.get_field().get_size()[0] + 1\n h = 420 + 10 - self._interface.get_field().get_size()[1] + 1\n self._grid = self._pygame.Surface((w, h))\n self._grid = self._grid.convert()\n self._grid.fill((0, 0, 0))\n self._grid.set_colorkey((0, 0, 0))\n \n elif self._state in [config.GS_MENU, config.GS_MENU_ENTER_HIGHSCORE,\n config.GS_MENU_HIGHSCORES]:\n \n # Background with static text\n self._background = self._pygame.Surface(self._screen.get_size())\n self._background = self._background.convert()\n self._background.fill((0, 0, 0))\n \n draw_text(self._background, (110, 300), 'Settings:', 10,\n self._white, self._pygame)\n draw_text(self._background, (130, 340), 'Difficulty Level:', 10,\n self._white, self._pygame)\n draw_text(self._background, (130, 400), 'Polyomino Order:', 10,\n self._white, self._pygame)\n \n draw_text(self._background, (370, 300), 'Audio:', 10,\n self._white, self._pygame)\n draw_text(self._background, (400, 340), 'Sound Effects:', 10,\n self._white, self._pygame)\n draw_text(self._background, (400, 400), 'Music:', 10,\n self._white, self._pygame)\n \n # Buttons\n self._buttons = {}\n start_game_button = Button('Start Game', 10, (90, 150))\n self._buttons.update({config.MENU_START: start_game_button})\n view_highscores_button = Button('View Highscores', 10, (90, 180))\n self._buttons.update({config.MENU_HIGHSCORES: view_highscores_button})\n help_button = Button('Help', 10, (90, 210))\n self._buttons.update({config.MENU_HELP: help_button})\n quit_button = Button('Quit', 10, (90, 240))\n self._buttons.update({config.MENU_QUIT: quit_button})\n \n # Radio Selections\n self._radios = {}\n level_selection = Radio_Selection([str(n + 1) for n in range(9)],\n 10, (160, 365))\n self._radios.update({config.MENU_LEVEL: level_selection})\n order_selection = Radio_Selection([str(n + 1) for n in range(6)],\n 10, (160, 425))\n self._radios.update({config.MENU_ORDER: order_selection})\n sfx_selection = Radio_Selection(['On', 'Off'], 10, (435, 365))\n self._radios.update({config.MENU_SFX: sfx_selection})\n music_selection = Radio_Selection(['On', 'Off'], 10, (435, 425))\n self._radios.update({config.MENU_MUSIC: music_selection})\n \n # Highscores Screen\n self._highscores = self._pygame.Surface((250, 300))\n self._highscores = self._highscores.convert()\n self._highscores.fill((0, 0, 0))\n \n draw_text(self._highscores, (15, 10), 'Highscores:', 10,\n self._white, self._pygame)\n \n # Enter highscore name screen\n self._enterhighscore = self._pygame.Surface((250, 210))\n self._enterhighscore = self._enterhighscore.convert()\n self._enterhighscore.fill((0, 0, 0))\n self._name_entry = Text_Entry(3, ['A', 'A', 'A'], 20, (85, 105))\n \n # Help Screen\n self._help = self._pygame.Surface((410, 240))\n self._help = self._help.convert()\n self._help.fill((0, 0, 0))\n \n draw_text(self._help, (15, 10), 'Controls:', 10, self._white,\n self._pygame)\n draw_text(self._help, (205, 10), 'Instructions:', 10,\n self._white, self._pygame)\n \n draw_text(self._help, (20, 45), 'Up - Rotate', 10, self._white,\n self._pygame)\n draw_text(self._help, (20, 75), 'Left - Move Left', 10,\n self._white, self._pygame)\n draw_text(self._help, (20, 105), 'Right - Move Right', 10,\n self._white, self._pygame)\n draw_text(self._help, (20, 135), 'Down - Move Down', 10,\n self._white, self._pygame)\n draw_text(self._help, (20, 165), 'Space - Drop', 10, self._white,\n self._pygame)\n draw_text(self._help, (20, 195), 'Esc - Pause', 10, self._white,\n self._pygame)\n \n text = config.instructions\n rect = self._pygame.Rect(0, 0, 190, 190)\n instructions = render_textrect(text, 8, rect, self._white,\n (0, 0, 0), 0, self._pygame)\n self._help.blit(instructions, (210, 45))","def update_status_fields(self, *args):\n\n self.connection_status = 'Connection established' if self.ml_interface.is_connected else ('Debug' if self.debug == True else 'Disconnected')\n\n self.requested_position = self.ml_interface.requested_position\n self.standby_position = self.ml_interface.standby_position\n\n self.rp = self.ml_interface.rp\n\n if self.requested_position is '':\n self.requested_position = '0'\n\n if self.standby_position is '':\n self.standby_position = '0'\n\n if self.settingsWindow.requested_position is '':\n self.settingsWindow.requested_position = '0'\n\n if self.settingsWindow.standby_position is '':\n self.settingsWindow.standby_position = '0'\n\n if int(self.requested_position) > self.settings[\"max_position\"]:\n self.requested_position = str(self.settings[\"max_position\"])\n self.set_requested_position()\n\n if int(self.standby_position) > self.settings[\"max_position\"]:\n self.standby_position = str(self.settings[\"max_position\"])\n self.set_standby_position()\n\n if int(self.rp) >= int(self.requested_position) and self.inserted == 0:\n self.inserted = 1\n\n if(self.trigger == 'Pressed'):\n self.trig = not self.trig\n state = int(float(self.ml_interface.current_state))\n self.current_state = 'Standby' if state == 4 else ('Stopped'if state == 3 else ('Moving' if state == 2 else ('Inserted' if state == 1 else 'Retracted')))\n self.gatan_in_msg = 'Yes' if self.ml_interface.gatan_in else 'No'\n self.gatan_veto_msg = 'Yes' if self.ml_interface.gatan_veto else 'No'\n\n if int(self.settingsWindow.requested_position) > self.settings[\"max_position\"]:\n self.settingsWindow.requested_position = str(self.settings[\"max_position\"])\n\n if int(self.settingsWindow.standby_position) > self.settings[\"max_position\"]:\n self.settingsWindow.standby_position = str(self.settings[\"max_position\"])\n\n # Called last\n self._rp = self.rp","def start(self):\n running = True\n while running:\n k=self.Game.playgame()\n if k=='Exit':\n running = False\n continue\n elif k=='resume':\n continue\n elif k=='GameOver':\n o=self.gameover()\n if o=='newgame':\n self.Game=Game(self.Display)\n else:\n running = False\n while k=='Won':\n o=self.won()\n if o=='newgame':\n self.Game=Game(self.Display)\n break\n elif o==\"Exit\":\n output = self.Game.popup()\n if output == 'resume':\n self.Game.GameBoard.display()\n continue\n else:\n running = True\n break","def event_m20_11_x78():\n \"\"\"State 0,1: State\"\"\"\n ChangeOwnObjState(30)\n \"\"\"State 2: End state\"\"\"\n return 0","def event_m20_11_x43():\n \"\"\"State 0,1: Are you in the map?\"\"\"\n IsPlayerInTheMap(0, 1, 0)\n assert ConditionGroup(0)\n \"\"\"State 2: End state\"\"\"\n return 0","def _activate(self):\n self.game.lives += 1","def __handle_view_win_condition(self, gamestate_component):","def GAMEOVER_LOOP():\n pass","def update_turn(self):\n pass","def tellIfStarted(self):\n if self.game_number == 1:\n self.welcome()\n else:\n self.tellGameNumber()","def events(self):\n # catch all events here\n for event in pg.event.get():\n if event.type == pg.QUIT:\n self.quit_game()\n if event.type == pg.KEYDOWN:\n if event.key == pg.K_ESCAPE:\n menu.paused = True\n menu.pause_menu() #code gets stuck in this call until a button is pressed in the pause menu\n self.clock=pg.time.Clock()\n if event.key == pg.K_h:\n self.draw_debug = not self.draw_debug\n if event.key == pg.K_o:\n if self.flashlight.on:#turning off flashlight\n self.darkness.on = True\n self.battery.duration-=pg.time.get_ticks()-self.battery.last_update\n self.flashlight.on=False\n else: #turning on flashlight\n self.darkness.on = False\n self.battery.last_update=pg.time.get_ticks()\n self.flashlight.on=True\n\n #darkness condition\n if self.transition:\n self.darkness_transition(self.player)\n self.kidnap(self.player)\n\n # win condition\n if pg.sprite.spritecollide(self.player, self.win, False, collide_hit_rect):\n menu.win_menu()\n\n #got hit condition\n hit=pg.sprite.spritecollide(self.player, self.threat, False, collide_hit2_rect)\n if hit:\n self.hit(self.player, hit[0])\n \n #mirror\n self.portal(self.player)\n self.portal(self.monster)","def put_state(request):\n game = request.matchdict['game']\n GAMES[game] = GAMES[game].update(request.PUT['state'])\n return {'end': not GAMES[request.matchdict['game']]}","def new_game(self):\n old_state = self.rstate\n del old_state\n self.rstate = self.rsimulator.new_game()","def game_updated(self):\n\n # replace with your game updated logic\n self.update_board()","def behaviors_paused(self) -> bool:","def leave_win_game(self):\n self.end = True\n self.canevas.config(bg='black')\n self.canevas.itemconfig(self.ball.ball, fill='black')\n self.canevas.itemconfig(self.paddle.paddle, fill='black')\n self.canevas.update()\n time.sleep(2)\n self.canevas.config(bg='light blue')\n self.canevas.itemconfig(self.ball.ball, fill='red')\n self.canevas.itemconfig(self.paddle.paddle, fill='grey')\n self.brick.next_level()","async def game(self):\n pass","def _inactive(self):\n self._click()\n if self._last is None and self._touch is not None:\n self._state = STATE_COUNTDOWN\n self._game = Gameplay()\n self._last = self._touch","def update_after_move(self, move):\n self.toggle_next_player()\n self.status = self.get_status(move)","def main(self):\n while 1:\n events = get_gamepad()\n for event in events:\n\n if(event.ev_type == \"Absolute\" ):\n\n if event.code in self.map[GAMEPAD].keys():\n self.absolute_switch[ self.map[GAMEPAD][event.code] ](event.state)\n\n\n if(event.ev_type == \"Key\" ):\n\n if event.code in self.map[GAMEPAD].keys():\n self.btn_switch[ self.map[GAMEPAD][event.code] ](self.map[GAMEPAD][event.code], event.state)\n \n\n\n\n #print(event.ev_type, event.code, event.state)","def reset_status(self):\r\n self.ship_left = self.ai_settings.ship_limit\r\n self.score = 0\r\n self.level = 1","def win_game(self):\r\n self.board.clear_hovered_tiles_list()\r\n self.is_game_over = True\r\n self.reset_button.won_game()\r\n self.high_score.update(self.timer.seconds)","def change_level(self):\n new_level = GameLevel[self.scoreboard.current_level]\n self.greeterboard.reset(level=new_level, msg='')\n self.end_game(i18n.OUT_MSG_NEW_GAME)\n self.init_game_metrics()","async def on_ready():\n await bot.change_presence(status=discord.Status.online, activity=discord.Game(activity))","def reset_game_state(self):\n self.is_playing = False","def init_game_setting(self):\r\n pass","def run(self):\n self.soundtrack.play(-1, 0, 2000)\n pygame.time.set_timer(Game.REFRESH_EVENT, 1000 // Game.FPS)\n\n while 1 < 2:\n event = pygame.event.wait()\n\n # Android-specific: always be ready to sleep\n if android:\n if android.check_pause():\n android.wait_for_resume()\n\n # Refresh display\n if event.type == Game.REFRESH_EVENT:\n # Android-specific: keep the soundtrack playing\n if android:\n android.mixer.periodic()\n\n self.draw()\n self.physics()\n pygame.display.flip()\n\n # The announcement is over---start playing\n elif event.type == Game.ANNOUNCE_EVENT:\n pygame.time.set_timer(Game.ANNOUNCE_EVENT, 0)\n self.state = Game.PLAY_STATE\n\n # The congratulations is over---announce new target\n elif event.type == Game.BRAVO_EVENT:\n pygame.time.set_timer(Game.BRAVO_EVENT, 0)\n self.announce_target()\n\n # The user clicked somewhere\n elif event.type == pygame.MOUSEBUTTONDOWN \\\n and self.state != Game.BRAVO_STATE:\n self.clicked(event.pos)\n\n # The user hit escape (or back); quit\n elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:\n break","def set_state(self, state: ApplicationState) -> None:\n self.state = state\n if state == ApplicationState.IDLE:\n self.generate_cards.config(text=\"Generate Bingo Game\")\n elif state == ApplicationState.GENERATING_GAME:\n self.generate_cards.config(text=\"Stop Generating Game\")\n else: # state == ApplicationState.GAME_GENERATED\n self.generate_cards.config(text=\"Regenerate Game\")","def __status(self):\r\n if self.__currentCell == self.storageCell:\r\n return Status.WIN\r\n\r\n if self.__totalReward < self.__rewardThreshold: # force end of game after to much loss\r\n return Status.LOSE\r\n\r\n return Status.PLAYING","def start_state():\n return chess.Board()","def idle(self):\n self.shooterLPID.disable()\n self.shooterRPID.disable()\n self.vIntake.set(0)\n self.tShooterL.set(0)\n self.tShooterR.set(0)","def _newgame(self):\n self._view.clear()\n self._game = Play(self._view)\n self._state = STATE_COUNTDOWN\n self.time = 0","def run_game(self):\n while True:\n self._check_events() # check event listener\n \n if self.stats.game_active:\n self.ship.update() # update position\n # self.bullets.update() # will update each sprite in the group\n self._update_bullets() \n self._update_aliens()\n\n# self.laser.update()\n self._update_screen() # refresh screen","def _reset_game(self):\n\t\tself.is_play = True\n\t\tself.is_gameover = False\n\t\tself.bolan.rect.y = self.bolan.default_y\n\t\tself.scoreboard.score = 0\n\t\tself.obstacles._reset_positions()","def GAME_LOOP():\n pass","def get_game_on_status(self) -> bool:\n return self._game_on.get()","def state_finish_enter(cfg, app, win):","def main(self, game_screen: pygame.Surface, vals: dict) -> None:\r\n self.paint(game_screen)\r\n if not vals['bools']['pausing']:\r\n self.move()\r\n self.check_speed(vals)","def action_handler(self):\n if self.state == data.DEAD:\n return\n\n x = 0\n for check in self.state_chart[self.state]:\n if not check:\n x += 1\n continue\n elif check():\n self.state = x\n\n # Some messages when state changes\n if self.state == data.CHASE:\n self.handler.message_box.add_msg(\"{} sees you!\".format(self.name), \n data.COLOURS['mob_behaviour_text'])\n elif self.state == data.RUN:\n self.handler.message_box.add_msg(\"{} runs away!\".format(self.name), \n data.COLOURS['mob_behaviour_text'])\n\n x += 1\n\n if self.state == data.HOLD:\n return\n elif self.state == data.CHASE:\n self.chase(self.handler.player)\n elif self.state == data.RUN:\n self.run(self.handler.player)","def lobby_screen_game_start_action(ai_settings, grid,screen, buttons,screen_status, button_status, card_database_filter, user, action, player2):\n\n\n # Clear up and initiate all display/progress indicator on battle screen\n # screen_status\n screen_status.battle_screen_my_hand_page_id = 1\n screen_status.battle_screen_action_indicator = 'stage-0'\n screen_status.battle_screen_player2_action_display_indicator = False\n # button_status\n button_status.battle_screen_win_lost_display = False\n button_status.battle_screen_win_lost_indicator = ''\n button_status.battle_screen_instruction_bar_yes_display = True\n button_status.battle_screen_instruction_bar_yes_backend = True\n button_status.battle_screen_instruction_bar_skip_display = False\n button_status.battle_screen_instruction_bar_skip_backend = False\n button_status.battle_screen_stable_button_backend = True\n button_status.battle_screen_my_hand_page_change_button_backend = True\n button_status.battle_screen_menu_display = False\n button_status.battle_screen_history_bar_detail_display = False\n button_status.battle_screen_history_bar_text_dict = {\n '1' : '',\n '2' : '',\n '3' : '',\n '4' : '',\n '5' : '',\n '6' : '',\n '7' : '',\n '8' : '',\n '9' : '',\n '10' : '',\n '11' : '',\n '12' : '',\n '13' : '',\n '14' : '',\n '15' : '',\n }\n button_status.battle_screen_my_hand_indicator_display = False\n button_status.battle_screen_my_hand_indicator_position = '1'\n button_status.battle_screen_player1_battleground_indicator_display = False\n button_status.battle_screen_player1_battleground_indicator_position = '1'\n button_status.battle_screen_player2_battleground_indicator_display = False\n button_status.battle_screen_player2_battleground_indicator_position = '1'\n button_status.card_zoom_active = False\n button_status.card_zoom_screen_indicator = 'build_deck_screen'\n button_status.card_zoom_part_indicator = ''\n button_status.card_zoom_position_indicator = '1'\n button_status.battle_screen_win_lost_indicator = ''\n\n #user\n user.monster_in_play_dict = {\n '1' : '',\n '2' : '',\n '3' : '',\n '4' : '',\n '5' : '',\n '6' : '',\n }\n user.monster_in_play_length = '0'\n user.item_in_play_dict = {\n '1' : '',\n '2' : '',\n '3' : '',\n '4' : '',\n '5' : '',\n '6' : '',\n }\n user.item_in_play_length = '0'\n user.character_under_card_by_level = {\n '10' : '',\n '20' : '',\n '30' : '',\n '40' : '',\n '50' : '',\n '60' : '',\n '70' : '',\n '80' : '',\n '90' : '',\n '100' : '',\n '110' : '',\n '120' : '',\n '130' : '',\n '140' : '',\n '150' : '',\n }\n user.stage_2_other_card_usable_list = []\n\n #player2\n player2.character_under_card_by_level = {\n '10' : '',\n '20' : '',\n '30' : '',\n '40' : '',\n '50' : '',\n '60' : '',\n '70' : '',\n '80' : '',\n '90' : '',\n '100' : '',\n '110' : '',\n '120' : '',\n '130' : '',\n '140' : '',\n '150' : '',\n }\n player2.monster_in_play_dict = {\n '1' : '',\n '2' : '',\n '3' : '',\n '4' : '',\n '5' : '',\n '6' : '',\n }\n player2.monster_in_play_length = '0'\n player2.item_in_play_dict = {\n '1' : '',\n '2' : '',\n '3' : '',\n '4' : '',\n '5' : '',\n '6' : '',\n }\n player2.item_in_play_length = '0'\n player2.stage_2_other_card_usable_list = []","def set_state( self ):","def check_events_lobby_screen(ai_settings, grid,screen, buttons,screen_status, button_status, card_database_filter, user, action, player2):\n for event in pygame.event.get():\n if event.type == pygame.QUIT:\n clear_text_file(ai_settings,grid, screen, buttons,screen_status, button_status, card_database_filter, user, action, player2)\n button_status.lobby_screen_room_detail_display = 'none'\n sys.exit()\n\n elif event.type == pygame.KEYDOWN:\n if event.key == pygame.K_ESCAPE:\n clear_text_file(ai_settings,grid, screen, buttons,screen_status, button_status, card_database_filter, user, action, player2)\n button_status.lobby_screen_room_detail_display = 'none'\n sys.exit()\n\n elif event.type == pygame.MOUSEBUTTONDOWN:\n # Back button\n if Rect(0, 0, 50, 50).collidepoint(pygame.mouse.get_pos()):\n clear_text_file(ai_settings,grid, screen, buttons,screen_status, button_status, card_database_filter, user, action, player2)\n button_status.lobby_screen_room_detail_display = 'none'\n screen_status.lobby_screen_display = False\n screen_status.welcome_screen_display = True\n # Change name button\n elif Rect(780, 10, 110, 30).collidepoint(pygame.mouse.get_pos()):\n button_status.text_input_box_display = True\n\n # Create/next/ready/start button\n elif Rect(920, 607, 100, 50).collidepoint(pygame.mouse.get_pos()):\n # create\n if button_status.lobby_screen_room_detail_display == 'none':\n if button_status.lobby_screen_room_list_display == 'N/A':\n button_status.lobby_screen_room_detail_display = 'my'\n button_status.lobby_screen_room_status = '1/2'\n button_status.lobby_screen_room_list_display = user.name\n\n #my next/ready/start\n elif button_status.lobby_screen_room_detail_display == 'my' and button_status.lobby_screen_room_status == '2/2':\n if button_status.lobby_screen_prepare_to_go_display == False:\n button_status.lobby_screen_prepare_to_go_display = True\n elif button_status.lobby_screen_prepare_to_go_display == True:\n # Click on ready\n if button_status.lobby_screen_my_ready_to_go == False:\n lobby_screen_to_other_ready_action(ai_settings, screen,buttons, screen_status, button_status, card_database_filter, user, player2)\n\n\n # Click on play\n elif button_status.lobby_screen_my_ready_to_go == True and button_status.lobby_screen_other_ready_to_go == True:\n button_status.lobby_screen_game_start = True\n lobby_screen_game_start_action(ai_settings, grid,screen, buttons,screen_status, button_status, card_database_filter, user, action, player2)\n\n\n\n # other Ready\n elif button_status.lobby_screen_room_detail_display == 'other' and button_status.lobby_screen_prepare_to_go_display == True:\n lobby_screen_to_other_ready_action(ai_settings, screen,buttons, screen_status, button_status, card_database_filter, user, player2)\n\n\n # click on ok on end screen warning sign\n elif Rect(1100, 642, 40, 30).collidepoint(pygame.mouse.get_pos()):\n button_status.lobby_screen_end_screen_warning_button_display = ''\n\n # Join\n elif Rect(530, 230, 50, 30).collidepoint(pygame.mouse.get_pos()):\n if button_status.lobby_screen_room_detail_display == 'none':\n button_status.lobby_screen_room_detail_display = 'other'\n button_status.lobby_screen_room_status = '2/2'\n # quit\n elif Rect(920, 684, 100, 50).collidepoint(pygame.mouse.get_pos()):\n if button_status.lobby_screen_room_detail_display == 'my' or button_status.lobby_screen_room_detail_display == 'other':\n clear_text_file(ai_settings,grid, screen, buttons,screen_status, button_status, card_database_filter, user, action, player2)\n button_status.lobby_screen_room_detail_display = 'none'\n button_status.lobby_screen_room_list_display = 'N/A'\n #button_status.lobby_screen_room_status = '0/2'\n\n # When in lobby_prepare to go screen\n for i in range(1,7):\n # Display edit/delete buttons\n if Rect(85 + 180* (i-1), 165, 130,110).collidepoint(pygame.mouse.get_pos()):\n with open('user_deck_list_string.txt','r') as f:\n f.seek(0)\n for line in f:\n if 'DECK_LIST_' + str(i) in line:\n user.deck_list_index = str(i)\n\n # Click on Edit\n elif Rect(85 + 180* (i-1), 282, 60, 30).collidepoint(pygame.mouse.get_pos()):\n with open('user_deck_list_string.txt','r') as f:\n f.seek(0)\n for line in f:\n if 'DECK_LIST_' + str(i) in line:\n user.deck_list = make_card_list_from_string(line.replace('DECK_LIST_' + str(i) + ' = ', ''), ai_settings, screen, buttons,screen_status, button_status, card_database_filter, user, player2)\n if 'CHARACTER_' + str(i) in line:\n user.character_card = eval('card_' + line.replace('CHARACTER_' + str(i) + ' = ', '')[7:12])\n screen_status.build_deck_screen_display = True\n screen_status.lobby_screen_display = False\n\n # Click on Delete\n elif Rect(155 + 180* (i-1), 282, 60, 30).collidepoint(pygame.mouse.get_pos()):\n with open('user_deck_list_string.txt','r') as f:\n f.seek(0)\n for line in f:\n if 'DECK_LIST_' + str(i) in line:\n\n with open('user_deck_list_string.txt','a+') as f:\n\n f.seek(0)\n x = f.readlines()\n y = 1\n\n f.seek(0)\n for line in f:\n if 'DECK_LIST_' + str(i) not in line:\n y += 1\n else:\n break\n\n del x[y-1] # Delete DECK_LIST_\n del x[y-1] # Delete CHARACTER_\n\n with open('user_deck_list_string.txt','w') as f:\n f.writelines(x)\n\n user.deck_list_index = 'new'\n\n # create new deck\n if Rect(1020, 110, 120, 35).collidepoint(pygame.mouse.get_pos()):\n with open('user_deck_list_string.txt','r') as f:\n f.seek(0)\n if len(f.readlines()) >= 12:\n pass\n\n else:\n user.deck_list_index = 'new'\n user.deck_list = []\n user.character_card = ''\n screen_status.build_deck_screen_display = True\n screen_status.lobby_screen_display = False","def gameStarted(self):\n\t\tself.server.gamesToStart -= 1\n\t\tif self.server.gamesToStart == 0:\n\t\t\tself.server.allGamesStarted.emit()","def run_game(self) -> None:\n\n self.setup_play()\n pg.mixer.music.load(path.join(sound_dir, 'theme_full.wav'))\n pg.mixer.music.set_volume(0.3)\n pg.mixer.music.play(-1, fade_ms=1000)\n\n while self.state == State.PLAY:\n\n # Using clock.tick each loop ensures framerate is limited to target FPS\n self.dt = self.clock.tick(FPS)\n\n self.events()\n\n if self.game_state == InGameState.READY:\n # A pause before the game starts.\n\n state_text = \"READY!\"\n\n if self.display_timer is None:\n self.display_timer = 1\n\n elif self.display_timer == 0:\n self.display_timer = None\n self.game_state = InGameState.RUNNING\n\n elif self.game_state == InGameState.COMPLETE:\n # Player survived the time limit and moves n to next level.\n\n state_text = \"You survived!\"\n\n if self.display_timer is None:\n self.display_timer = 1\n\n elif self.display_timer == 0:\n self.display_timer = None\n self.setup_play(reset=True)\n self.game_state = InGameState.READY\n\n else:\n # Regular update step\n\n self.update()\n\n if self.display_timer is None:\n state_text = None\n elif self.display_timer == self.timer:\n self.display_timer = None\n\n if self.player.death_timer == 0:\n if self.lives == 0:\n self.state = State.GAME_OVER\n else:\n self.setup_play(reset=True)\n self.game_state = InGameState.READY\n\n if self.kill_bonus is None:\n\n if self.no_kills() >= self.target_no_kills:\n\n self.display_timer = self.timer - 2\n\n half_time = TIME_LIMIT // 2\n if self.timer >= half_time:\n self.kill_bonus = (self.timer - half_time) // 10 * ENEMY_CLEARANCE_BONUS\n state_text = f\"Kill bonus: {self.kill_bonus}\"\n else:\n self.kill_bonus = 0\n state_text = f\"Too slow - No kill bonus\"\n\n if self.timer == 0:\n self.game_state = InGameState.COMPLETE\n\n self.draw(state_text=state_text)","def update(self):\n self.active = False\n self.top.update(self.rgb,self.cmyk,self.hsv)\n self.bot.update(self.rgb,self.cmyk,self.hsv)\n self.active = True","def check_events_welcome_screen(ai_settings,grid, screen, buttons,screen_status, button_status, card_database_filter, user,action, player2):\n for event in pygame.event.get():\n if event.type == pygame.QUIT:\n sys.exit()\n\n elif event.type == pygame.KEYDOWN:\n if event.key == pygame.K_ESCAPE:\n sys.exit()\n\n elif event.type == pygame.MOUSEBUTTONDOWN:\n\n # If settings window is on\n if button_status.welcome_screen_settings_display == True:\n # Turn sound on\n if Rect(510, 333, 40, 40).collidepoint(pygame.mouse.get_pos()):\n ai_settings.sound_indicator = True\n # Turn sound off\n elif Rect(560, 333, 40, 40).collidepoint(pygame.mouse.get_pos()):\n ai_settings.sound_indicator = False\n # Turn music on\n elif Rect(510, 403, 40, 40).collidepoint(pygame.mouse.get_pos()):\n ai_settings.music_indicator = True\n # Turn music off\n elif Rect(560, 403, 40, 40).collidepoint(pygame.mouse.get_pos()):\n ai_settings.music_indicator = False\n\n # Change Theme\n elif Rect(510, 470, 140, 50).collidepoint(pygame.mouse.get_pos()):\n ai_settings.theme_indicator = 'Lith Harbor'\n change_bg_music('Lith Harbor')\n\n elif Rect(670, 470, 140, 50).collidepoint(pygame.mouse.get_pos()):\n ai_settings.theme_indicator = 'Leafre'\n change_bg_music('Leafre')\n\n elif Rect(510, 540, 140, 50).collidepoint(pygame.mouse.get_pos()):\n ai_settings.theme_indicator = 'Pantheon'\n change_bg_music('Pantheon')\n\n elif Rect(670, 540, 140, 50).collidepoint(pygame.mouse.get_pos()):\n ai_settings.theme_indicator = 'Ellinia'\n change_bg_music('Ellinia')\n\n # change AI speeding\n elif Rect(550, 620, 80, 50).collidepoint(pygame.mouse.get_pos()):\n ai_settings.AI_speed_indicator = '1000'\n\n elif Rect(650, 620, 80, 50).collidepoint(pygame.mouse.get_pos()):\n ai_settings.AI_speed_indicator = '2000'\n\n elif Rect(750, 620, 80, 50).collidepoint(pygame.mouse.get_pos()):\n ai_settings.AI_speed_indicator = '3000'\n\n # Quit settings window\n elif Rect(870, 300, 30, 30).collidepoint(pygame.mouse.get_pos()):\n button_status.welcome_screen_settings_display = False\n\n elif button_status.rules_display == True:\n # When we click on '>'\n if Rect(640, 37, 20, 20).collidepoint(pygame.mouse.get_pos()):\n if int(button_status.rules_page_id) < 4:\n button_status.rules_page_id = str(int(button_status.rules_page_id)+1)\n else:\n pass\n # When we click on '<'\n elif Rect(540, 37, 20, 20).collidepoint(pygame.mouse.get_pos()):\n if int(button_status.rules_page_id) > 1:\n button_status.rules_page_id = str(int(button_status.rules_page_id)-1)\n else:\n pass\n\n elif Rect(975, 35, 25, 25).collidepoint(pygame.mouse.get_pos()):\n button_status.rules_display = False\n\n else:\n # Click on single player\n if Rect(402, 269, 396, 62).collidepoint(pygame.mouse.get_pos()):\n screen_status.welcome_screen_display = False\n screen_status.prepare_screen_display = True\n if user.name == '':\n button_status.text_input_box_display = True\n else:\n pass\n # Click on multiplayer\n elif Rect(434, 370, 333, 61).collidepoint(pygame.mouse.get_pos()):\n screen_status.welcome_screen_display = False\n screen_status.lobby_screen_display = True\n player2.identity = 'pvp'\n if user.name == '':\n button_status.text_input_box_display = True\n else:\n pass\n #enter_as_network_client(ai_settings,grid, screen, buttons,screen_status, button_status, card_database_filter, user,action, player2)\n # Click on settings\n elif Rect(474, 469, 253, 62).collidepoint(pygame.mouse.get_pos()):\n button_status.welcome_screen_settings_display = True\n\n # Click on rules\n elif Rect(517, 570, 167, 61).collidepoint(pygame.mouse.get_pos()):\n button_status.rules_display = True\n\n # click on exit\n elif Rect(541, 670, 119, 61).collidepoint(pygame.mouse.get_pos()):\n sys.exit()","def play(self, state,currentplayer):\n\t\tpass","def game_updated(self):\n # <<-- Creer-Merge: game-updated -->> - Code you add between this comment and the end comment will be preserved between Creer re-runs.\n game = self.game\n\n for x in range(game.board_width):\n for y in range(game.board_height):\n self.checkers_map[x][y] = None\n\n self.force_checker = None\n self.cant_move = False\n for checker in game.checkers:\n self.checkers_map[checker.x][checker.y] = checker\n if checker.owner is self.player and checker is game.checker_moved:\n if game.checker_moved_jumped:\n self.force_checker = checker\n else:\n self.cant_move = True\n # <<-- /Creer-Merge: game-updated -->>","def _paused(self):\n self._last = self._touch\n m = 'You have '+`self._game.getPlayerLives()`+' lives remaining.\\nClick to continue'\n f = 25\n self._click()\n if self._last is None and self._touch is not None:\n self._state = STATE_COUNTDOWN\n self._game.resetBall()\n self._game.resetPaddle()\n m = ''\n self._last = self._touch\n self._countdownTime = 0\n self._countdownMessage = GLabel(text='3', font_size=40,x=GAME_WIDTH / 2.0,\n y=GAME_HEIGHT*(2.0/3.0), halign='center',\n valign='middle', linecolor=colormodel.WHITE)\n self._pausedMessage = GLabel(text=m,font_size=f,x=GAME_WIDTH / 2.0,\n y=GAME_HEIGHT*(2.0/3.0), halign='center',\n valign='middle', linecolor=colormodel.WHITE)"],"string":"[\n \"def get_new_gamestate(self):\",\n \"def update_state(self):\\n if not self.platforms:\\n self.state = self.states['Win']\\n elif self.player.y > 389:\\n self.state = self.states['Lose'] \\n else:\\n self.state = self.states['Game']\",\n \"def update(self):\\r\\n if not self.tr.game_over and self.tr.turn_tracker:\\r\\n self.computer_play()\",\n \"def change_player_state(self):\\n if self.active_player.get() is True:\\n # Get game phase and unlock respective buttons?\\n # or should game do that\\n pass\\n else:\\n pass\\n #self.disable_all_buttons()\",\n \"def _active(self):\\n self._soundhelper()\\n k = self._game.getPlayerLives()\\n self._movePaddle()\\n self._game.moveBall(self._sound)\\n if self._game.getPlayerLives() == 0:\\n self._state = STATE_COMPLETE\\n elif self._game.getPlayerLives() < k:\\n self._state = STATE_PAUSED\",\n \"def start_of_game(self):\\n pass\",\n \"def game_play(self):\",\n \"def set_game_state(self,winner):\\r\\n if winner == 'b':\\r\\n self._game_state = \\\"BLACK_WON\\\"\\r\\n else:\\r\\n self._game_state = \\\"RED_WON\\\"\",\n \"def handleGameState(self):\\n if self.state == GameState.PLAYER_LOOSE:\\n self.drawMessage(\\\" Hai perso! \\\", 3000)\\n elif self.state == GameState.LEVEL_COMPLETED:\\n self.sound_completed_level.play()\\n code = self.get_code(self.levelIndex+1)\\n code_msg = \\\"\\\"\\n if code:\\n code_msg = \\\"[Codice Bonus:%s]\\\" % code\\n self.drawMessage(\\\" %s completato! %s\\\" % (self.level_name, code_msg), 3000)\\n self.levelIndex += 1\\n self.screen.fill(Game.BLACK)\\n self.setupLevel()\\n self.run()\\n elif self.state == GameState.PLAYER_WON:\\n self.drawMessage(\\\"Hai vinto!\\\", 5000)\\n # esco dal gioco poiche' ho terminato\\n # valutare se chiedere di rincominciare la partita...\\n pygame.quit()\\n elif self.state == GameState.PAUSED:\\n self.drawMessage(\\\"Pausa\\\", 0, False)\\n elif self.state == GameState.HELP:\\n self.drawHelpText()\",\n \"def _active(self):\\n self._game.updatePaddle(self.input)\\n self._game.updateBall()\\n self._game.updateFP()\\n self._lose_life()\\n self._new_n_press()\\n self._points_mssg.text = str(self._game.getPoints())\\n if not self._game.getPointsFP() is None:\\n self._catchFP()\\n self._FP_mssg_timer()\\n # check for victory\\n if self._game.getLengthBricks() <= 0:\\n self._state = STATE_COMPLETED\\n \\n self.draw()\\n self._game.draw()\",\n \"def notify_game_over(self):\\n self.is_game_over = True\",\n \"def init_game_setting(self):\\n self.state.state_counter_while_testing += 1\",\n \"def start_game(self):\\n\\n\\t\\tpass\",\n \"def update(self):\\n if self.game_over is False:\\n self.player_turn = not self.player_turn\\n self.turn_display_timer = self.TURN_TEXT_TIMER\",\n \"def state_wait_enter(cfg, app, win):\",\n \"def update_game(game, episode, buttons,run_status):\\n\\n game_round = game.round\\n if game_round == 'newround':\\n newround(game)\\n print(game_round)\\n game.round = 'preflop'\\n print(game.round)\\n\\n\\n return 'go'\\n elif game_round == 'preflop':\\n check = preflop(game, episode, buttons)\\n if check == True:\\n game.round = 'flop'\\n return 'go'\\n elif check == False:\\n game.round = 'showdown'\\n print(game.round)\\n return 'go'\\n elif check == 'no input':\\n game.round = 'preflop'\\n return 'stop'\\n return 'stop'\\n elif game_round == 'flop':\\n check = flop(game, episode, buttons, run_status)\\n if check == True:\\n game.round = 'turn'\\n return 'go'\\n elif check == False:\\n game.round = 'showdown'\\n return 'go'\\n elif check == 'no input':\\n game.round = 'flop'\\n return 'stop'\\n return 'stop'\\n pass\\n elif game_round == 'turn':\\n check = turn(game, episode, buttons, run_status)\\n if check == True:\\n game.round = 'river'\\n return 'go'\\n elif check == False:\\n game.round = 'showdown'\\n return 'go'\\n elif check == 'no input':\\n game.round = 'turn'\\n return 'stop'\\n return 'stop'\\n elif game_round == 'river':\\n check = turn(game, episode, buttons, run_status)\\n if check == True:\\n game.round = 'showdown'\\n return 'go'\\n elif check == False:\\n game.round = 'showdown'\\n return 'go'\\n elif check == 'no input':\\n game.round = 'river'\\n return 'stop'\\n return 'stop'\\n elif game_round == 'showdown':\\n showdown(game, episode)\\n #game.player1.wager = 100\\n #game.player2.wager = 50\\n # game.update_tablepot()\\n game.round = 'newround'\\n return 'go'\\n pass\",\n \"def state_wait_do(cfg, app, win, events):\",\n \"def resign_game(self):\\n if self._current_player == \\\"BLACK\\\":\\n self._game_state = \\\"WHITE_WON\\\"\\n\\n else:\\n self._game_state = \\\"BLACK_WON\\\"\",\n \"async def change_status():\\n await client.change_presence(activity=discord.Game(next(appearance.status)))\",\n \"def process_game_logic(self):\\n self.dmod = -1\\n self.smod = -1\\n if self.state == self.STATE_SETUP:\\n if self.current_game < self.config['General']['games_per_session']:\\n self.current_game += 1\\n self.state = self.STATE_GAMENO\\n self.game_title = \\\"Game: %d of %d\\\" % (self.current_game, self.config['General']['games_per_session'])\\n self.game_title = pygl2d.font.RenderText(self.game_title, (255, 255, 0), self.f36)\\n self.game_title_rect = self.game_title.get_rect()\\n self.game_title_rect.center = (self.SCREEN_WIDTH / 2, self.SCREEN_HEIGHT / 16 * 7)\\n self.gameevents.add(\\\"display_game\\\", self.current_game)\\n else:\\n self.state = self.STATE_DONE\\n self.ret = 0\\n self.lc.stop()\\n elif self.state == self.STATE_SETUP_IFF:\\n self.mine_list.generate_foes()\\n self.gameevents.add(\\\"display_foes\\\", \\\" \\\".join(self.mine_list.foe_letters), \\\"player\\\")\\n self.foe_top = pygl2d.font.RenderText(\\\"The Type-2 mines for this session are:\\\", (255, 255, 0), self.f24)\\n self.foe_top_rect = self.foe_top.get_rect()\\n self.foe_top_rect.center = (self.SCREEN_WIDTH / 2, 270 * self.aspect_ratio)\\n self.foe_middle = pygl2d.font.RenderText(\\\", \\\".join(self.mine_list.foe_letters), (255, 255, 255), self.f96)\\n self.foe_middle_rect = self.foe_middle.get_rect()\\n self.foe_middle_rect.center = (self.SCREEN_WIDTH / 2, self.SCREEN_HEIGHT / 2)\\n self.foe_midbot = pygl2d.font.RenderText(\\\"Try to memorize them before proceeding\\\", (255, 255, 0), self.f24)\\n self.foe_midbot_rect = self.foe_midbot.get_rect()\\n self.foe_midbot_rect.center = (self.SCREEN_WIDTH / 2, 500 * self.aspect_ratio)\\n self.foe_bottom = pygl2d.font.RenderText(\\\"Press return to begin\\\", (255, 255, 0), self.f24)\\n self.foe_bottom_rect = self.foe_bottom.get_rect()\\n self.foe_bottom_rect.center = (self.SCREEN_WIDTH / 2, 600 * self.aspect_ratio)\\n self.state = self.STATE_IFF\\n elif self.state == self.STATE_PREPARE:\\n self.gameevents.add(\\\"game\\\", \\\"ready\\\", type='EVENT_SYSTEM')\\n self.setup_world()\\n self.state = self.STATE_PLAY\\n self.gameevents.add(\\\"game\\\", \\\"start\\\", type='EVENT_SYSTEM')\\n elif self.state == self.STATE_PLAY:\\n self.ship.compute()\\n if not self.ship.jumped:\\n\\n overlay = np.zeros((int(self.world.bottom-self.world.top),int(self.world.right-self.world.left),3),np.uint8)\\n\\n\\n cv2.line(overlay,(int(self.ship.position.x-self.world.left),int(self.ship.position.y-self.world.top)),(int(self.ship.oldPosx-self.world.left),int(self.ship.oldPosy-self.world.top)),(255,255,255),self.config['Playback']['line_width'])\\n\\n cv2.addWeighted(overlay,self.config['Playback']['intensity']/100.0,self.img,1.0,0,self.img)\\n\\n distance = self.ship.get_distance_to_point(self.WORLD_WIDTH / 2, self.WORLD_HEIGHT / 2)\\n flight_max_inc = self.config['Score']['flight_max_increment']\\n dmod = 1 - (distance - self.smallhex.radius * 1.125) / (self.WORLD_WIDTH / 2)\\n if dmod > 1.0: dmod = 1.0\\n if dmod < 0.0: dmod = 0.0\\n smod = max([abs(self.ship.velocity.x), abs(self.ship.velocity.y)]) / self.ship.max_vel\\n self.dmod = dmod\\n self.smod = smod\\n for missile in self.missile_list:\\n missile.compute()\\n if self.fortress_exists == True:\\n self.fortress.compute()\\n for shell in self.shell_list:\\n shell.compute()\\n if self.config['Hexagon']['hex_shrink']:\\n self.bighex.compute()\\n if self.mine_exists:\\n if self.mine_list.flag == False and self.mine_list.timer.elapsed() > self.mine_list.spawn_time:\\n self.gameevents.add(\\\"spawn\\\", \\\"mine\\\")\\n elif self.mine_list.flag and self.mine_list.timer.elapsed() > self.mine_list.timeout:\\n self.gameevents.add(\\\"timeout\\\", \\\"mine\\\")\\n self.mine_list.compute()\\n self.check_bounds()\\n #test collisions to generate game events\\n self.test_collisions()\\n if self.flighttimer.elapsed() > self.config['Score']['update_timer']:\\n self.flighttimer.reset()\\n def pointspace (a0, a1, a2, b0, b1, b2): return math.exp(a1 ** (a0 * a2)) * math.exp(b1 ** (b0 * b2))\\n points = flight_max_inc * pointspace(self.dmod, 2, 1, self.smod, 2, 1.75) / pointspace(1, 2, 1, 1, 2, 1.75)\\n self.gameevents.add(\\\"score+\\\", \\\"flight\\\", points)\\n self.flight2 += flight_max_inc * pointspace(self.dmod, 2, .45, self.smod, 2, 1) / pointspace(1, 2, .45, 1, 2, 1)\\n if (self.ship.velocity.x ** 2 + self.ship.velocity.y ** 2) ** 0.5 < self.config['Score']['speed_threshold']:\\n self.gameevents.add(\\\"score+\\\", \\\"vlcty\\\", self.config['Score']['VLCTY_increment'])\\n #self.gameevents.add(\\\"score+\\\", \\\"flight\\\", self.config['Score']['VLCTY_increment'])\\n else:\\n self.gameevents.add(\\\"score-\\\", \\\"vlcty\\\", self.config['Score']['VLCTY_increment'])\\n #self.gameevents.add(\\\"score-\\\", \\\"flight\\\", self.config['Score']['VLCTY_increment'])\\n if self.bighex.collide(self.ship):\\n self.gameevents.add(\\\"score+\\\", \\\"cntrl\\\", self.config['Score']['CNTRL_increment'])\\n #self.gameevents.add(\\\"score+\\\", \\\"flight\\\", self.config['Score']['CNTRL_increment'])\\n else:\\n self.gameevents.add(\\\"score+\\\", \\\"cntrl\\\", self.config['Score']['CNTRL_increment'] / 2)\\n #self.gameevents.add(\\\"score+\\\", \\\"flight\\\", self.config['Score']['CNTRL_increment']/2)\\n if self.bonus_exists:\\n if self.config['General']['bonus_system'] == \\\"AX-CPT\\\":\\n self.bonus.axcpt_update()\\n else:\\n if self.bonus.visible == False and self.bonus.timer.elapsed() > self.config['Bonus']['symbol_down_time']:\\n self.gameevents.add(\\\"activate\\\", \\\"bonus\\\")\\n elif self.bonus.visible == True and self.bonus.timer.elapsed() >= self.config['Bonus']['symbol_up_time']:\\n self.gameevents.add(\\\"deactivate\\\", \\\"bonus\\\", self.bonus.current_symbol)\\n #update scores\\n self.score.pnts = self.score.__getattribute__(\\\"pnts\\\")\\n self.score.vlcty = self.score.__getattribute__(\\\"vlcty\\\")\\n self.score.cntrl = self.score.__getattribute__(\\\"cntrl\\\")\\n self.score.speed = self.score.__getattribute__(\\\"speed\\\")\\n self.score.flight = self.score.__getattribute__(\\\"flight\\\")\\n self.score.fortress = self.score.__getattribute__(\\\"fortress\\\")\\n self.score.mines = self.score.__getattribute__(\\\"mines\\\")\\n self.score.bonus = self.score.__getattribute__(\\\"bonus\\\")\\n\\n if self.gametimer.elapsed() > self.config['General']['game_time']:\\n self.gameevents.add(\\\"game\\\", \\\"over\\\", type='EVENT_SYSTEM')\\n self.state = self.STATE_SCORES\\n self.img = 255-self.img\\n now = datetime.datetime.now()\\n cv2.imwrite('../Recordings/' + str(now.year) + \\\"_\\\"+str(now.month)+\\\"_\\\" + str(now.day) + \\\"_\\\" + str(now.hour) + \\\"_\\\" + str(now.minute)+\\\"_\\\" + 'lines.jpg',(self.img),[int(cv2.IMWRITE_JPEG_QUALITY), 100])\",\n \"def run(self, GameState):\\n pass\",\n \"def state_processing_do(cfg, app, win, events):\",\n \"def game_over(self):\\n self.over = True\",\n \"def change_game_state(self, state):\\n self._game_state = state\",\n \"def play_game():\\n pass\",\n \"def initGameState(self):\\n print(\\\"Setting game state: \\\")\\n self.playGUI = GUI()\\n self.playGUI.drawBoard(self.player)\",\n \"def init_game_setting(self):\\n ##################\\n # YOUR CODE HERE #\\n ##################\\n self.state = np.zeros((1, 80, 80))\\n self.clear_action()\",\n \"def check_status(self, sensor, state):\\n self.sensed = sensor\\n if state == 1:\\n self.winner = True\\n elif state == -1:\\n self.alive = False\",\n \"def reset_game(self):\\n self.bHasWon = False\\n self.game_over = False\\n self.game_active = False\\n self.player_points = 0\\n self.enemy_points = 0\\n self.remainingBalls = 0\",\n \"def update(self, new_gameStateData):\\r\\n pass\",\n \"def game_over(self, won=True):\\n if won is True:\\n self.game[\\\"game_status\\\"] = self.WON\\n else:\\n self.game[\\\"game_status\\\"] = self.DISCONNECTED\\n db.save_game(self.game_id, self.game)\",\n \"def grab_paused(self):\\n\\t\\tif time.time() - self.time_paused > PAUSE_INTERVAL:\\n\\t\\t\\tself.status.state = 'stop'\",\n \"def _paused(self):\\n self.view.clear()\\n if self._game.getLives() == 2:\\n self._mssg = (GLabel(text=TWO_LIFE_MSSG, x=GAME_WIDTH/2, y=GAME_HEIGHT/2,\\n font_size=20))\\n elif self._game.getLives() == 1:\\n self._mssg = (GLabel(text=ONE_LIFE_MSSG, x=GAME_WIDTH/2, y=GAME_HEIGHT/2,\\n \\n font_size=20))\\n if self._new_n_press():\\n self._state = STATE_COUNTDOWN\\n self._mssg = None\\n self._game.resetPaddle()\\n self.time = 0\",\n \"def state_processing_enter(cfg, app, win):\",\n \"def setup_game(self):\",\n \"def update(self):\\n # If the game is not over.\\n if self.tictactoe:\\n # If the player is human, the choice can only be detected by the game,\\n # because the player has no responsibility over the window\\n if self.player.chooser:\\n choice = self.choice\\n self.choice = None\\n else:\\n choice = self.player.play(self.tictactoe)\\n self.tictactoe.choose(choice)\\n else:\\n if self.on:\\n self.end_time = time.time()\\n self.on = False\\n if self.restart_at_end:\\n if time.time() - self.end_time > self.end_duration:\\n self.restart()\",\n \"def get_game_state(self):\\n return self._game_status\",\n \"def update(self, dt: float) -> GameStateID:\\n if self.user_clicked:\\n self.user_clicked = False\\n return GameStateID.START_MENU\\n else:\\n return GameStateID.GAME_OVER\",\n \"def process(self, state, game):\\n if state.isWin(): self.win(state, game)\\n if state.isLose(): self.lose(state, game)\",\n \"def change_status(self):\\n if self.status == \\\"Still Loaned\\\":\\n self.status = \\\"Given Back\\\"\\n else:\\n self.status = \\\"Still Loaned\\\"\",\n \"def update_to_state(self, game_state):\\n pass\",\n \"def state_chosen_do(cfg, app, win, events):\",\n \"def stand(self):\\n self.endgame()\",\n \"def player_stage(niv): \\n playing = True\\n a = niv[0][0] \\n b = niv[0][1] \\n (x, y) = (a, b) \\n state = [[a, b]] #Create a list with the starting point of the selected level patern.\\n sense.stick.get_events()\\n while playing:\\n for event in sense.stick.get_events(): #It moves the pixel with the player moves and add the point passed by the player in the state[].\\n if event.action == 'pressed':\\n if event.direction == 'left':\\n if x > 0:\\n x = min(x-1, 7)\\n state.append([x, y])\\n elif event.direction == 'right':\\n if x < 7:\\n x = max(x+1, 0)\\n state.append([x, y])\\n if event.direction == 'down':\\n if y < 7:\\n y = min(y+1, 7)\\n state.append([x, y])\\n elif event.direction == 'up':\\n if y > 0:\\n y = max(y-1, 0)\\n state.append([x, y])\\n elif event.direction == 'middle':\\n playing = False\\n sense.set_pixel(x, y, RED)\\n if state[:] == niv[:]: #Compare the way choosen by the player with the selected level patern. Results of the try.\\n sense.show_message(\\\"WINNER !\\\",\\n text_colour=LEMON, scroll_speed=0.05)\\n sleep(2)\\n main() #brings back to the level selection.\\n else:\\n sense.show_message(\\\"LOSER !\\\",\\n text_colour=BLUE, scroll_speed=0.05)\\n sleep(2)\\n try_again(niv) #cf. try_again() function\",\n \"def resign_game(self):\\n # If entered, it will return winner status for the opposing player\\n if self._current_player == 'W':\\n self._game_status = 'BLACK_WON'\\n if self._current_player == 'B':\\n self._game_status = 'WHITE_WON'\",\n \"def update_state_game_variables(self):\\n self.model.numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8]\\n self.model.player_mark = \\\"\\\"\\n self.model.player_move = 0\\n self.model.boards = [\\\"board\\\"] * 9\\n self.update_score_board()\",\n \"def game_on(self) -> None:\\n if self.msg.sender != self.owner:\\n revert(f'Only the game owner can turn it on.')\\n if not self._game_on.get():\\n self._game_on.set(True)\\n self._day.set(self.now() // U_SECONDS_DAY)\",\n \"def _completed(self):\\n if self._game.getLives() == 0: # loss\\n self.view.clear()\\n self._mssg = (GLabel(text=LOSS_MSSG, x=GAME_WIDTH/2, y=GAME_HEIGHT/2, font_size=16))\\n else: # win\\n self.view.clear()\\n self._mssg = (GLabel(text='You won! (' + str(self._game.getPoints()) + ' Points)' +\\n WIN_MSSG, x=GAME_WIDTH/2, y=GAME_HEIGHT/2, font_size=16))\\n \\n if self._new_n_press():\\n self._state = STATE_NEWGAME\\n self._mssg = None\",\n \"def _inactive(self):\\n if self._new_key_press():\\n self._state = STATE_NEWGAME\\n self._mssg = None\",\n \"def check_status(board, player_mark, turn_counter):\",\n \"def Gameloop():\",\n \"def change_state(self, state, interface=None):\\n \\n self._state = state\\n if interface != None:\\n self._interface = interface\\n \\n if self._state == config.GS_LOADING:\\n \\n # Background with loading text\\n self._background = self._pygame.Surface(self._screen.get_size())\\n self._background = self._background.convert()\\n self._background.fill((0, 0, 0))\\n draw_text(self._background, (180, 180), 'Loading...', 36,\\n self._white, self._pygame)\\n \\n elif self._state == config.GS_GAME:\\n \\n # Background with static text\\n self._background = self._pygame.Surface(self._screen.get_size())\\n self._background = self._background.convert()\\n self._background.fill((0, 0, 0))\\n \\n draw_text(self._background, (410, 130), 'Score:', 10,\\n self._white, self._pygame)\\n draw_text(self._background, (410, 190), 'Lines Cleared:', 10,\\n self._white, self._pygame)\\n \\n next_text = 'Next ' + \\\\\\n config.names[self._interface.get_order()].title() + ':'\\n draw_text(self._background, (410, 250), next_text, 10,\\n self._white, self._pygame)\\n \\n # Grid\\n w = 210 + 10 - self._interface.get_field().get_size()[0] + 1\\n h = 420 + 10 - self._interface.get_field().get_size()[1] + 1\\n self._grid = self._pygame.Surface((w, h))\\n self._grid = self._grid.convert()\\n self._grid.fill((0, 0, 0))\\n self._grid.set_colorkey((0, 0, 0))\\n \\n elif self._state in [config.GS_MENU, config.GS_MENU_ENTER_HIGHSCORE,\\n config.GS_MENU_HIGHSCORES]:\\n \\n # Background with static text\\n self._background = self._pygame.Surface(self._screen.get_size())\\n self._background = self._background.convert()\\n self._background.fill((0, 0, 0))\\n \\n draw_text(self._background, (110, 300), 'Settings:', 10,\\n self._white, self._pygame)\\n draw_text(self._background, (130, 340), 'Difficulty Level:', 10,\\n self._white, self._pygame)\\n draw_text(self._background, (130, 400), 'Polyomino Order:', 10,\\n self._white, self._pygame)\\n \\n draw_text(self._background, (370, 300), 'Audio:', 10,\\n self._white, self._pygame)\\n draw_text(self._background, (400, 340), 'Sound Effects:', 10,\\n self._white, self._pygame)\\n draw_text(self._background, (400, 400), 'Music:', 10,\\n self._white, self._pygame)\\n \\n # Buttons\\n self._buttons = {}\\n start_game_button = Button('Start Game', 10, (90, 150))\\n self._buttons.update({config.MENU_START: start_game_button})\\n view_highscores_button = Button('View Highscores', 10, (90, 180))\\n self._buttons.update({config.MENU_HIGHSCORES: view_highscores_button})\\n help_button = Button('Help', 10, (90, 210))\\n self._buttons.update({config.MENU_HELP: help_button})\\n quit_button = Button('Quit', 10, (90, 240))\\n self._buttons.update({config.MENU_QUIT: quit_button})\\n \\n # Radio Selections\\n self._radios = {}\\n level_selection = Radio_Selection([str(n + 1) for n in range(9)],\\n 10, (160, 365))\\n self._radios.update({config.MENU_LEVEL: level_selection})\\n order_selection = Radio_Selection([str(n + 1) for n in range(6)],\\n 10, (160, 425))\\n self._radios.update({config.MENU_ORDER: order_selection})\\n sfx_selection = Radio_Selection(['On', 'Off'], 10, (435, 365))\\n self._radios.update({config.MENU_SFX: sfx_selection})\\n music_selection = Radio_Selection(['On', 'Off'], 10, (435, 425))\\n self._radios.update({config.MENU_MUSIC: music_selection})\\n \\n # Highscores Screen\\n self._highscores = self._pygame.Surface((250, 300))\\n self._highscores = self._highscores.convert()\\n self._highscores.fill((0, 0, 0))\\n \\n draw_text(self._highscores, (15, 10), 'Highscores:', 10,\\n self._white, self._pygame)\\n \\n # Enter highscore name screen\\n self._enterhighscore = self._pygame.Surface((250, 210))\\n self._enterhighscore = self._enterhighscore.convert()\\n self._enterhighscore.fill((0, 0, 0))\\n self._name_entry = Text_Entry(3, ['A', 'A', 'A'], 20, (85, 105))\\n \\n # Help Screen\\n self._help = self._pygame.Surface((410, 240))\\n self._help = self._help.convert()\\n self._help.fill((0, 0, 0))\\n \\n draw_text(self._help, (15, 10), 'Controls:', 10, self._white,\\n self._pygame)\\n draw_text(self._help, (205, 10), 'Instructions:', 10,\\n self._white, self._pygame)\\n \\n draw_text(self._help, (20, 45), 'Up - Rotate', 10, self._white,\\n self._pygame)\\n draw_text(self._help, (20, 75), 'Left - Move Left', 10,\\n self._white, self._pygame)\\n draw_text(self._help, (20, 105), 'Right - Move Right', 10,\\n self._white, self._pygame)\\n draw_text(self._help, (20, 135), 'Down - Move Down', 10,\\n self._white, self._pygame)\\n draw_text(self._help, (20, 165), 'Space - Drop', 10, self._white,\\n self._pygame)\\n draw_text(self._help, (20, 195), 'Esc - Pause', 10, self._white,\\n self._pygame)\\n \\n text = config.instructions\\n rect = self._pygame.Rect(0, 0, 190, 190)\\n instructions = render_textrect(text, 8, rect, self._white,\\n (0, 0, 0), 0, self._pygame)\\n self._help.blit(instructions, (210, 45))\",\n \"def update_status_fields(self, *args):\\n\\n self.connection_status = 'Connection established' if self.ml_interface.is_connected else ('Debug' if self.debug == True else 'Disconnected')\\n\\n self.requested_position = self.ml_interface.requested_position\\n self.standby_position = self.ml_interface.standby_position\\n\\n self.rp = self.ml_interface.rp\\n\\n if self.requested_position is '':\\n self.requested_position = '0'\\n\\n if self.standby_position is '':\\n self.standby_position = '0'\\n\\n if self.settingsWindow.requested_position is '':\\n self.settingsWindow.requested_position = '0'\\n\\n if self.settingsWindow.standby_position is '':\\n self.settingsWindow.standby_position = '0'\\n\\n if int(self.requested_position) > self.settings[\\\"max_position\\\"]:\\n self.requested_position = str(self.settings[\\\"max_position\\\"])\\n self.set_requested_position()\\n\\n if int(self.standby_position) > self.settings[\\\"max_position\\\"]:\\n self.standby_position = str(self.settings[\\\"max_position\\\"])\\n self.set_standby_position()\\n\\n if int(self.rp) >= int(self.requested_position) and self.inserted == 0:\\n self.inserted = 1\\n\\n if(self.trigger == 'Pressed'):\\n self.trig = not self.trig\\n state = int(float(self.ml_interface.current_state))\\n self.current_state = 'Standby' if state == 4 else ('Stopped'if state == 3 else ('Moving' if state == 2 else ('Inserted' if state == 1 else 'Retracted')))\\n self.gatan_in_msg = 'Yes' if self.ml_interface.gatan_in else 'No'\\n self.gatan_veto_msg = 'Yes' if self.ml_interface.gatan_veto else 'No'\\n\\n if int(self.settingsWindow.requested_position) > self.settings[\\\"max_position\\\"]:\\n self.settingsWindow.requested_position = str(self.settings[\\\"max_position\\\"])\\n\\n if int(self.settingsWindow.standby_position) > self.settings[\\\"max_position\\\"]:\\n self.settingsWindow.standby_position = str(self.settings[\\\"max_position\\\"])\\n\\n # Called last\\n self._rp = self.rp\",\n \"def start(self):\\n running = True\\n while running:\\n k=self.Game.playgame()\\n if k=='Exit':\\n running = False\\n continue\\n elif k=='resume':\\n continue\\n elif k=='GameOver':\\n o=self.gameover()\\n if o=='newgame':\\n self.Game=Game(self.Display)\\n else:\\n running = False\\n while k=='Won':\\n o=self.won()\\n if o=='newgame':\\n self.Game=Game(self.Display)\\n break\\n elif o==\\\"Exit\\\":\\n output = self.Game.popup()\\n if output == 'resume':\\n self.Game.GameBoard.display()\\n continue\\n else:\\n running = True\\n break\",\n \"def event_m20_11_x78():\\n \\\"\\\"\\\"State 0,1: State\\\"\\\"\\\"\\n ChangeOwnObjState(30)\\n \\\"\\\"\\\"State 2: End state\\\"\\\"\\\"\\n return 0\",\n \"def event_m20_11_x43():\\n \\\"\\\"\\\"State 0,1: Are you in the map?\\\"\\\"\\\"\\n IsPlayerInTheMap(0, 1, 0)\\n assert ConditionGroup(0)\\n \\\"\\\"\\\"State 2: End state\\\"\\\"\\\"\\n return 0\",\n \"def _activate(self):\\n self.game.lives += 1\",\n \"def __handle_view_win_condition(self, gamestate_component):\",\n \"def GAMEOVER_LOOP():\\n pass\",\n \"def update_turn(self):\\n pass\",\n \"def tellIfStarted(self):\\n if self.game_number == 1:\\n self.welcome()\\n else:\\n self.tellGameNumber()\",\n \"def events(self):\\n # catch all events here\\n for event in pg.event.get():\\n if event.type == pg.QUIT:\\n self.quit_game()\\n if event.type == pg.KEYDOWN:\\n if event.key == pg.K_ESCAPE:\\n menu.paused = True\\n menu.pause_menu() #code gets stuck in this call until a button is pressed in the pause menu\\n self.clock=pg.time.Clock()\\n if event.key == pg.K_h:\\n self.draw_debug = not self.draw_debug\\n if event.key == pg.K_o:\\n if self.flashlight.on:#turning off flashlight\\n self.darkness.on = True\\n self.battery.duration-=pg.time.get_ticks()-self.battery.last_update\\n self.flashlight.on=False\\n else: #turning on flashlight\\n self.darkness.on = False\\n self.battery.last_update=pg.time.get_ticks()\\n self.flashlight.on=True\\n\\n #darkness condition\\n if self.transition:\\n self.darkness_transition(self.player)\\n self.kidnap(self.player)\\n\\n # win condition\\n if pg.sprite.spritecollide(self.player, self.win, False, collide_hit_rect):\\n menu.win_menu()\\n\\n #got hit condition\\n hit=pg.sprite.spritecollide(self.player, self.threat, False, collide_hit2_rect)\\n if hit:\\n self.hit(self.player, hit[0])\\n \\n #mirror\\n self.portal(self.player)\\n self.portal(self.monster)\",\n \"def put_state(request):\\n game = request.matchdict['game']\\n GAMES[game] = GAMES[game].update(request.PUT['state'])\\n return {'end': not GAMES[request.matchdict['game']]}\",\n \"def new_game(self):\\n old_state = self.rstate\\n del old_state\\n self.rstate = self.rsimulator.new_game()\",\n \"def game_updated(self):\\n\\n # replace with your game updated logic\\n self.update_board()\",\n \"def behaviors_paused(self) -> bool:\",\n \"def leave_win_game(self):\\n self.end = True\\n self.canevas.config(bg='black')\\n self.canevas.itemconfig(self.ball.ball, fill='black')\\n self.canevas.itemconfig(self.paddle.paddle, fill='black')\\n self.canevas.update()\\n time.sleep(2)\\n self.canevas.config(bg='light blue')\\n self.canevas.itemconfig(self.ball.ball, fill='red')\\n self.canevas.itemconfig(self.paddle.paddle, fill='grey')\\n self.brick.next_level()\",\n \"async def game(self):\\n pass\",\n \"def _inactive(self):\\n self._click()\\n if self._last is None and self._touch is not None:\\n self._state = STATE_COUNTDOWN\\n self._game = Gameplay()\\n self._last = self._touch\",\n \"def update_after_move(self, move):\\n self.toggle_next_player()\\n self.status = self.get_status(move)\",\n \"def main(self):\\n while 1:\\n events = get_gamepad()\\n for event in events:\\n\\n if(event.ev_type == \\\"Absolute\\\" ):\\n\\n if event.code in self.map[GAMEPAD].keys():\\n self.absolute_switch[ self.map[GAMEPAD][event.code] ](event.state)\\n\\n\\n if(event.ev_type == \\\"Key\\\" ):\\n\\n if event.code in self.map[GAMEPAD].keys():\\n self.btn_switch[ self.map[GAMEPAD][event.code] ](self.map[GAMEPAD][event.code], event.state)\\n \\n\\n\\n\\n #print(event.ev_type, event.code, event.state)\",\n \"def reset_status(self):\\r\\n self.ship_left = self.ai_settings.ship_limit\\r\\n self.score = 0\\r\\n self.level = 1\",\n \"def win_game(self):\\r\\n self.board.clear_hovered_tiles_list()\\r\\n self.is_game_over = True\\r\\n self.reset_button.won_game()\\r\\n self.high_score.update(self.timer.seconds)\",\n \"def change_level(self):\\n new_level = GameLevel[self.scoreboard.current_level]\\n self.greeterboard.reset(level=new_level, msg='')\\n self.end_game(i18n.OUT_MSG_NEW_GAME)\\n self.init_game_metrics()\",\n \"async def on_ready():\\n await bot.change_presence(status=discord.Status.online, activity=discord.Game(activity))\",\n \"def reset_game_state(self):\\n self.is_playing = False\",\n \"def init_game_setting(self):\\r\\n pass\",\n \"def run(self):\\n self.soundtrack.play(-1, 0, 2000)\\n pygame.time.set_timer(Game.REFRESH_EVENT, 1000 // Game.FPS)\\n\\n while 1 < 2:\\n event = pygame.event.wait()\\n\\n # Android-specific: always be ready to sleep\\n if android:\\n if android.check_pause():\\n android.wait_for_resume()\\n\\n # Refresh display\\n if event.type == Game.REFRESH_EVENT:\\n # Android-specific: keep the soundtrack playing\\n if android:\\n android.mixer.periodic()\\n\\n self.draw()\\n self.physics()\\n pygame.display.flip()\\n\\n # The announcement is over---start playing\\n elif event.type == Game.ANNOUNCE_EVENT:\\n pygame.time.set_timer(Game.ANNOUNCE_EVENT, 0)\\n self.state = Game.PLAY_STATE\\n\\n # The congratulations is over---announce new target\\n elif event.type == Game.BRAVO_EVENT:\\n pygame.time.set_timer(Game.BRAVO_EVENT, 0)\\n self.announce_target()\\n\\n # The user clicked somewhere\\n elif event.type == pygame.MOUSEBUTTONDOWN \\\\\\n and self.state != Game.BRAVO_STATE:\\n self.clicked(event.pos)\\n\\n # The user hit escape (or back); quit\\n elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:\\n break\",\n \"def set_state(self, state: ApplicationState) -> None:\\n self.state = state\\n if state == ApplicationState.IDLE:\\n self.generate_cards.config(text=\\\"Generate Bingo Game\\\")\\n elif state == ApplicationState.GENERATING_GAME:\\n self.generate_cards.config(text=\\\"Stop Generating Game\\\")\\n else: # state == ApplicationState.GAME_GENERATED\\n self.generate_cards.config(text=\\\"Regenerate Game\\\")\",\n \"def __status(self):\\r\\n if self.__currentCell == self.storageCell:\\r\\n return Status.WIN\\r\\n\\r\\n if self.__totalReward < self.__rewardThreshold: # force end of game after to much loss\\r\\n return Status.LOSE\\r\\n\\r\\n return Status.PLAYING\",\n \"def start_state():\\n return chess.Board()\",\n \"def idle(self):\\n self.shooterLPID.disable()\\n self.shooterRPID.disable()\\n self.vIntake.set(0)\\n self.tShooterL.set(0)\\n self.tShooterR.set(0)\",\n \"def _newgame(self):\\n self._view.clear()\\n self._game = Play(self._view)\\n self._state = STATE_COUNTDOWN\\n self.time = 0\",\n \"def run_game(self):\\n while True:\\n self._check_events() # check event listener\\n \\n if self.stats.game_active:\\n self.ship.update() # update position\\n # self.bullets.update() # will update each sprite in the group\\n self._update_bullets() \\n self._update_aliens()\\n\\n# self.laser.update()\\n self._update_screen() # refresh screen\",\n \"def _reset_game(self):\\n\\t\\tself.is_play = True\\n\\t\\tself.is_gameover = False\\n\\t\\tself.bolan.rect.y = self.bolan.default_y\\n\\t\\tself.scoreboard.score = 0\\n\\t\\tself.obstacles._reset_positions()\",\n \"def GAME_LOOP():\\n pass\",\n \"def get_game_on_status(self) -> bool:\\n return self._game_on.get()\",\n \"def state_finish_enter(cfg, app, win):\",\n \"def main(self, game_screen: pygame.Surface, vals: dict) -> None:\\r\\n self.paint(game_screen)\\r\\n if not vals['bools']['pausing']:\\r\\n self.move()\\r\\n self.check_speed(vals)\",\n \"def action_handler(self):\\n if self.state == data.DEAD:\\n return\\n\\n x = 0\\n for check in self.state_chart[self.state]:\\n if not check:\\n x += 1\\n continue\\n elif check():\\n self.state = x\\n\\n # Some messages when state changes\\n if self.state == data.CHASE:\\n self.handler.message_box.add_msg(\\\"{} sees you!\\\".format(self.name), \\n data.COLOURS['mob_behaviour_text'])\\n elif self.state == data.RUN:\\n self.handler.message_box.add_msg(\\\"{} runs away!\\\".format(self.name), \\n data.COLOURS['mob_behaviour_text'])\\n\\n x += 1\\n\\n if self.state == data.HOLD:\\n return\\n elif self.state == data.CHASE:\\n self.chase(self.handler.player)\\n elif self.state == data.RUN:\\n self.run(self.handler.player)\",\n \"def lobby_screen_game_start_action(ai_settings, grid,screen, buttons,screen_status, button_status, card_database_filter, user, action, player2):\\n\\n\\n # Clear up and initiate all display/progress indicator on battle screen\\n # screen_status\\n screen_status.battle_screen_my_hand_page_id = 1\\n screen_status.battle_screen_action_indicator = 'stage-0'\\n screen_status.battle_screen_player2_action_display_indicator = False\\n # button_status\\n button_status.battle_screen_win_lost_display = False\\n button_status.battle_screen_win_lost_indicator = ''\\n button_status.battle_screen_instruction_bar_yes_display = True\\n button_status.battle_screen_instruction_bar_yes_backend = True\\n button_status.battle_screen_instruction_bar_skip_display = False\\n button_status.battle_screen_instruction_bar_skip_backend = False\\n button_status.battle_screen_stable_button_backend = True\\n button_status.battle_screen_my_hand_page_change_button_backend = True\\n button_status.battle_screen_menu_display = False\\n button_status.battle_screen_history_bar_detail_display = False\\n button_status.battle_screen_history_bar_text_dict = {\\n '1' : '',\\n '2' : '',\\n '3' : '',\\n '4' : '',\\n '5' : '',\\n '6' : '',\\n '7' : '',\\n '8' : '',\\n '9' : '',\\n '10' : '',\\n '11' : '',\\n '12' : '',\\n '13' : '',\\n '14' : '',\\n '15' : '',\\n }\\n button_status.battle_screen_my_hand_indicator_display = False\\n button_status.battle_screen_my_hand_indicator_position = '1'\\n button_status.battle_screen_player1_battleground_indicator_display = False\\n button_status.battle_screen_player1_battleground_indicator_position = '1'\\n button_status.battle_screen_player2_battleground_indicator_display = False\\n button_status.battle_screen_player2_battleground_indicator_position = '1'\\n button_status.card_zoom_active = False\\n button_status.card_zoom_screen_indicator = 'build_deck_screen'\\n button_status.card_zoom_part_indicator = ''\\n button_status.card_zoom_position_indicator = '1'\\n button_status.battle_screen_win_lost_indicator = ''\\n\\n #user\\n user.monster_in_play_dict = {\\n '1' : '',\\n '2' : '',\\n '3' : '',\\n '4' : '',\\n '5' : '',\\n '6' : '',\\n }\\n user.monster_in_play_length = '0'\\n user.item_in_play_dict = {\\n '1' : '',\\n '2' : '',\\n '3' : '',\\n '4' : '',\\n '5' : '',\\n '6' : '',\\n }\\n user.item_in_play_length = '0'\\n user.character_under_card_by_level = {\\n '10' : '',\\n '20' : '',\\n '30' : '',\\n '40' : '',\\n '50' : '',\\n '60' : '',\\n '70' : '',\\n '80' : '',\\n '90' : '',\\n '100' : '',\\n '110' : '',\\n '120' : '',\\n '130' : '',\\n '140' : '',\\n '150' : '',\\n }\\n user.stage_2_other_card_usable_list = []\\n\\n #player2\\n player2.character_under_card_by_level = {\\n '10' : '',\\n '20' : '',\\n '30' : '',\\n '40' : '',\\n '50' : '',\\n '60' : '',\\n '70' : '',\\n '80' : '',\\n '90' : '',\\n '100' : '',\\n '110' : '',\\n '120' : '',\\n '130' : '',\\n '140' : '',\\n '150' : '',\\n }\\n player2.monster_in_play_dict = {\\n '1' : '',\\n '2' : '',\\n '3' : '',\\n '4' : '',\\n '5' : '',\\n '6' : '',\\n }\\n player2.monster_in_play_length = '0'\\n player2.item_in_play_dict = {\\n '1' : '',\\n '2' : '',\\n '3' : '',\\n '4' : '',\\n '5' : '',\\n '6' : '',\\n }\\n player2.item_in_play_length = '0'\\n player2.stage_2_other_card_usable_list = []\",\n \"def set_state( self ):\",\n \"def check_events_lobby_screen(ai_settings, grid,screen, buttons,screen_status, button_status, card_database_filter, user, action, player2):\\n for event in pygame.event.get():\\n if event.type == pygame.QUIT:\\n clear_text_file(ai_settings,grid, screen, buttons,screen_status, button_status, card_database_filter, user, action, player2)\\n button_status.lobby_screen_room_detail_display = 'none'\\n sys.exit()\\n\\n elif event.type == pygame.KEYDOWN:\\n if event.key == pygame.K_ESCAPE:\\n clear_text_file(ai_settings,grid, screen, buttons,screen_status, button_status, card_database_filter, user, action, player2)\\n button_status.lobby_screen_room_detail_display = 'none'\\n sys.exit()\\n\\n elif event.type == pygame.MOUSEBUTTONDOWN:\\n # Back button\\n if Rect(0, 0, 50, 50).collidepoint(pygame.mouse.get_pos()):\\n clear_text_file(ai_settings,grid, screen, buttons,screen_status, button_status, card_database_filter, user, action, player2)\\n button_status.lobby_screen_room_detail_display = 'none'\\n screen_status.lobby_screen_display = False\\n screen_status.welcome_screen_display = True\\n # Change name button\\n elif Rect(780, 10, 110, 30).collidepoint(pygame.mouse.get_pos()):\\n button_status.text_input_box_display = True\\n\\n # Create/next/ready/start button\\n elif Rect(920, 607, 100, 50).collidepoint(pygame.mouse.get_pos()):\\n # create\\n if button_status.lobby_screen_room_detail_display == 'none':\\n if button_status.lobby_screen_room_list_display == 'N/A':\\n button_status.lobby_screen_room_detail_display = 'my'\\n button_status.lobby_screen_room_status = '1/2'\\n button_status.lobby_screen_room_list_display = user.name\\n\\n #my next/ready/start\\n elif button_status.lobby_screen_room_detail_display == 'my' and button_status.lobby_screen_room_status == '2/2':\\n if button_status.lobby_screen_prepare_to_go_display == False:\\n button_status.lobby_screen_prepare_to_go_display = True\\n elif button_status.lobby_screen_prepare_to_go_display == True:\\n # Click on ready\\n if button_status.lobby_screen_my_ready_to_go == False:\\n lobby_screen_to_other_ready_action(ai_settings, screen,buttons, screen_status, button_status, card_database_filter, user, player2)\\n\\n\\n # Click on play\\n elif button_status.lobby_screen_my_ready_to_go == True and button_status.lobby_screen_other_ready_to_go == True:\\n button_status.lobby_screen_game_start = True\\n lobby_screen_game_start_action(ai_settings, grid,screen, buttons,screen_status, button_status, card_database_filter, user, action, player2)\\n\\n\\n\\n # other Ready\\n elif button_status.lobby_screen_room_detail_display == 'other' and button_status.lobby_screen_prepare_to_go_display == True:\\n lobby_screen_to_other_ready_action(ai_settings, screen,buttons, screen_status, button_status, card_database_filter, user, player2)\\n\\n\\n # click on ok on end screen warning sign\\n elif Rect(1100, 642, 40, 30).collidepoint(pygame.mouse.get_pos()):\\n button_status.lobby_screen_end_screen_warning_button_display = ''\\n\\n # Join\\n elif Rect(530, 230, 50, 30).collidepoint(pygame.mouse.get_pos()):\\n if button_status.lobby_screen_room_detail_display == 'none':\\n button_status.lobby_screen_room_detail_display = 'other'\\n button_status.lobby_screen_room_status = '2/2'\\n # quit\\n elif Rect(920, 684, 100, 50).collidepoint(pygame.mouse.get_pos()):\\n if button_status.lobby_screen_room_detail_display == 'my' or button_status.lobby_screen_room_detail_display == 'other':\\n clear_text_file(ai_settings,grid, screen, buttons,screen_status, button_status, card_database_filter, user, action, player2)\\n button_status.lobby_screen_room_detail_display = 'none'\\n button_status.lobby_screen_room_list_display = 'N/A'\\n #button_status.lobby_screen_room_status = '0/2'\\n\\n # When in lobby_prepare to go screen\\n for i in range(1,7):\\n # Display edit/delete buttons\\n if Rect(85 + 180* (i-1), 165, 130,110).collidepoint(pygame.mouse.get_pos()):\\n with open('user_deck_list_string.txt','r') as f:\\n f.seek(0)\\n for line in f:\\n if 'DECK_LIST_' + str(i) in line:\\n user.deck_list_index = str(i)\\n\\n # Click on Edit\\n elif Rect(85 + 180* (i-1), 282, 60, 30).collidepoint(pygame.mouse.get_pos()):\\n with open('user_deck_list_string.txt','r') as f:\\n f.seek(0)\\n for line in f:\\n if 'DECK_LIST_' + str(i) in line:\\n user.deck_list = make_card_list_from_string(line.replace('DECK_LIST_' + str(i) + ' = ', ''), ai_settings, screen, buttons,screen_status, button_status, card_database_filter, user, player2)\\n if 'CHARACTER_' + str(i) in line:\\n user.character_card = eval('card_' + line.replace('CHARACTER_' + str(i) + ' = ', '')[7:12])\\n screen_status.build_deck_screen_display = True\\n screen_status.lobby_screen_display = False\\n\\n # Click on Delete\\n elif Rect(155 + 180* (i-1), 282, 60, 30).collidepoint(pygame.mouse.get_pos()):\\n with open('user_deck_list_string.txt','r') as f:\\n f.seek(0)\\n for line in f:\\n if 'DECK_LIST_' + str(i) in line:\\n\\n with open('user_deck_list_string.txt','a+') as f:\\n\\n f.seek(0)\\n x = f.readlines()\\n y = 1\\n\\n f.seek(0)\\n for line in f:\\n if 'DECK_LIST_' + str(i) not in line:\\n y += 1\\n else:\\n break\\n\\n del x[y-1] # Delete DECK_LIST_\\n del x[y-1] # Delete CHARACTER_\\n\\n with open('user_deck_list_string.txt','w') as f:\\n f.writelines(x)\\n\\n user.deck_list_index = 'new'\\n\\n # create new deck\\n if Rect(1020, 110, 120, 35).collidepoint(pygame.mouse.get_pos()):\\n with open('user_deck_list_string.txt','r') as f:\\n f.seek(0)\\n if len(f.readlines()) >= 12:\\n pass\\n\\n else:\\n user.deck_list_index = 'new'\\n user.deck_list = []\\n user.character_card = ''\\n screen_status.build_deck_screen_display = True\\n screen_status.lobby_screen_display = False\",\n \"def gameStarted(self):\\n\\t\\tself.server.gamesToStart -= 1\\n\\t\\tif self.server.gamesToStart == 0:\\n\\t\\t\\tself.server.allGamesStarted.emit()\",\n \"def run_game(self) -> None:\\n\\n self.setup_play()\\n pg.mixer.music.load(path.join(sound_dir, 'theme_full.wav'))\\n pg.mixer.music.set_volume(0.3)\\n pg.mixer.music.play(-1, fade_ms=1000)\\n\\n while self.state == State.PLAY:\\n\\n # Using clock.tick each loop ensures framerate is limited to target FPS\\n self.dt = self.clock.tick(FPS)\\n\\n self.events()\\n\\n if self.game_state == InGameState.READY:\\n # A pause before the game starts.\\n\\n state_text = \\\"READY!\\\"\\n\\n if self.display_timer is None:\\n self.display_timer = 1\\n\\n elif self.display_timer == 0:\\n self.display_timer = None\\n self.game_state = InGameState.RUNNING\\n\\n elif self.game_state == InGameState.COMPLETE:\\n # Player survived the time limit and moves n to next level.\\n\\n state_text = \\\"You survived!\\\"\\n\\n if self.display_timer is None:\\n self.display_timer = 1\\n\\n elif self.display_timer == 0:\\n self.display_timer = None\\n self.setup_play(reset=True)\\n self.game_state = InGameState.READY\\n\\n else:\\n # Regular update step\\n\\n self.update()\\n\\n if self.display_timer is None:\\n state_text = None\\n elif self.display_timer == self.timer:\\n self.display_timer = None\\n\\n if self.player.death_timer == 0:\\n if self.lives == 0:\\n self.state = State.GAME_OVER\\n else:\\n self.setup_play(reset=True)\\n self.game_state = InGameState.READY\\n\\n if self.kill_bonus is None:\\n\\n if self.no_kills() >= self.target_no_kills:\\n\\n self.display_timer = self.timer - 2\\n\\n half_time = TIME_LIMIT // 2\\n if self.timer >= half_time:\\n self.kill_bonus = (self.timer - half_time) // 10 * ENEMY_CLEARANCE_BONUS\\n state_text = f\\\"Kill bonus: {self.kill_bonus}\\\"\\n else:\\n self.kill_bonus = 0\\n state_text = f\\\"Too slow - No kill bonus\\\"\\n\\n if self.timer == 0:\\n self.game_state = InGameState.COMPLETE\\n\\n self.draw(state_text=state_text)\",\n \"def update(self):\\n self.active = False\\n self.top.update(self.rgb,self.cmyk,self.hsv)\\n self.bot.update(self.rgb,self.cmyk,self.hsv)\\n self.active = True\",\n \"def check_events_welcome_screen(ai_settings,grid, screen, buttons,screen_status, button_status, card_database_filter, user,action, player2):\\n for event in pygame.event.get():\\n if event.type == pygame.QUIT:\\n sys.exit()\\n\\n elif event.type == pygame.KEYDOWN:\\n if event.key == pygame.K_ESCAPE:\\n sys.exit()\\n\\n elif event.type == pygame.MOUSEBUTTONDOWN:\\n\\n # If settings window is on\\n if button_status.welcome_screen_settings_display == True:\\n # Turn sound on\\n if Rect(510, 333, 40, 40).collidepoint(pygame.mouse.get_pos()):\\n ai_settings.sound_indicator = True\\n # Turn sound off\\n elif Rect(560, 333, 40, 40).collidepoint(pygame.mouse.get_pos()):\\n ai_settings.sound_indicator = False\\n # Turn music on\\n elif Rect(510, 403, 40, 40).collidepoint(pygame.mouse.get_pos()):\\n ai_settings.music_indicator = True\\n # Turn music off\\n elif Rect(560, 403, 40, 40).collidepoint(pygame.mouse.get_pos()):\\n ai_settings.music_indicator = False\\n\\n # Change Theme\\n elif Rect(510, 470, 140, 50).collidepoint(pygame.mouse.get_pos()):\\n ai_settings.theme_indicator = 'Lith Harbor'\\n change_bg_music('Lith Harbor')\\n\\n elif Rect(670, 470, 140, 50).collidepoint(pygame.mouse.get_pos()):\\n ai_settings.theme_indicator = 'Leafre'\\n change_bg_music('Leafre')\\n\\n elif Rect(510, 540, 140, 50).collidepoint(pygame.mouse.get_pos()):\\n ai_settings.theme_indicator = 'Pantheon'\\n change_bg_music('Pantheon')\\n\\n elif Rect(670, 540, 140, 50).collidepoint(pygame.mouse.get_pos()):\\n ai_settings.theme_indicator = 'Ellinia'\\n change_bg_music('Ellinia')\\n\\n # change AI speeding\\n elif Rect(550, 620, 80, 50).collidepoint(pygame.mouse.get_pos()):\\n ai_settings.AI_speed_indicator = '1000'\\n\\n elif Rect(650, 620, 80, 50).collidepoint(pygame.mouse.get_pos()):\\n ai_settings.AI_speed_indicator = '2000'\\n\\n elif Rect(750, 620, 80, 50).collidepoint(pygame.mouse.get_pos()):\\n ai_settings.AI_speed_indicator = '3000'\\n\\n # Quit settings window\\n elif Rect(870, 300, 30, 30).collidepoint(pygame.mouse.get_pos()):\\n button_status.welcome_screen_settings_display = False\\n\\n elif button_status.rules_display == True:\\n # When we click on '>'\\n if Rect(640, 37, 20, 20).collidepoint(pygame.mouse.get_pos()):\\n if int(button_status.rules_page_id) < 4:\\n button_status.rules_page_id = str(int(button_status.rules_page_id)+1)\\n else:\\n pass\\n # When we click on '<'\\n elif Rect(540, 37, 20, 20).collidepoint(pygame.mouse.get_pos()):\\n if int(button_status.rules_page_id) > 1:\\n button_status.rules_page_id = str(int(button_status.rules_page_id)-1)\\n else:\\n pass\\n\\n elif Rect(975, 35, 25, 25).collidepoint(pygame.mouse.get_pos()):\\n button_status.rules_display = False\\n\\n else:\\n # Click on single player\\n if Rect(402, 269, 396, 62).collidepoint(pygame.mouse.get_pos()):\\n screen_status.welcome_screen_display = False\\n screen_status.prepare_screen_display = True\\n if user.name == '':\\n button_status.text_input_box_display = True\\n else:\\n pass\\n # Click on multiplayer\\n elif Rect(434, 370, 333, 61).collidepoint(pygame.mouse.get_pos()):\\n screen_status.welcome_screen_display = False\\n screen_status.lobby_screen_display = True\\n player2.identity = 'pvp'\\n if user.name == '':\\n button_status.text_input_box_display = True\\n else:\\n pass\\n #enter_as_network_client(ai_settings,grid, screen, buttons,screen_status, button_status, card_database_filter, user,action, player2)\\n # Click on settings\\n elif Rect(474, 469, 253, 62).collidepoint(pygame.mouse.get_pos()):\\n button_status.welcome_screen_settings_display = True\\n\\n # Click on rules\\n elif Rect(517, 570, 167, 61).collidepoint(pygame.mouse.get_pos()):\\n button_status.rules_display = True\\n\\n # click on exit\\n elif Rect(541, 670, 119, 61).collidepoint(pygame.mouse.get_pos()):\\n sys.exit()\",\n \"def play(self, state,currentplayer):\\n\\t\\tpass\",\n \"def game_updated(self):\\n # <<-- Creer-Merge: game-updated -->> - Code you add between this comment and the end comment will be preserved between Creer re-runs.\\n game = self.game\\n\\n for x in range(game.board_width):\\n for y in range(game.board_height):\\n self.checkers_map[x][y] = None\\n\\n self.force_checker = None\\n self.cant_move = False\\n for checker in game.checkers:\\n self.checkers_map[checker.x][checker.y] = checker\\n if checker.owner is self.player and checker is game.checker_moved:\\n if game.checker_moved_jumped:\\n self.force_checker = checker\\n else:\\n self.cant_move = True\\n # <<-- /Creer-Merge: game-updated -->>\",\n \"def _paused(self):\\n self._last = self._touch\\n m = 'You have '+`self._game.getPlayerLives()`+' lives remaining.\\\\nClick to continue'\\n f = 25\\n self._click()\\n if self._last is None and self._touch is not None:\\n self._state = STATE_COUNTDOWN\\n self._game.resetBall()\\n self._game.resetPaddle()\\n m = ''\\n self._last = self._touch\\n self._countdownTime = 0\\n self._countdownMessage = GLabel(text='3', font_size=40,x=GAME_WIDTH / 2.0,\\n y=GAME_HEIGHT*(2.0/3.0), halign='center',\\n valign='middle', linecolor=colormodel.WHITE)\\n self._pausedMessage = GLabel(text=m,font_size=f,x=GAME_WIDTH / 2.0,\\n y=GAME_HEIGHT*(2.0/3.0), halign='center',\\n valign='middle', linecolor=colormodel.WHITE)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7380898","0.7280429","0.6983609","0.6962316","0.6960264","0.6905935","0.6833638","0.677917","0.6773883","0.6686437","0.66210973","0.66116637","0.65953153","0.6575552","0.65732825","0.65653706","0.6519847","0.64996016","0.6478882","0.64316595","0.64263415","0.64237976","0.64127135","0.6407158","0.6388259","0.63869727","0.63860285","0.63668925","0.6353181","0.63519156","0.634344","0.6340914","0.6337721","0.6336406","0.6333282","0.63230634","0.63153434","0.6312497","0.63002664","0.62928915","0.62892985","0.62865037","0.6285184","0.62726974","0.6258674","0.6253497","0.62466663","0.6238969","0.6222369","0.6221557","0.62190616","0.62106085","0.6210021","0.6204906","0.6193252","0.6177791","0.6170863","0.616685","0.6165775","0.61622465","0.61564004","0.6154787","0.6154475","0.6153497","0.6153185","0.6150401","0.6145671","0.61298484","0.6111535","0.61112607","0.6102378","0.6101014","0.60996413","0.6097955","0.60964465","0.6096214","0.609592","0.6093485","0.6092347","0.6083148","0.6080917","0.6076761","0.60590476","0.6054251","0.6052966","0.6031892","0.60287666","0.60284466","0.60279125","0.60276127","0.6026284","0.6024586","0.6018516","0.60182357","0.6016604","0.60134894","0.60131216","0.6009512","0.59971213","0.59945375"],"string":"[\n \"0.7380898\",\n \"0.7280429\",\n \"0.6983609\",\n \"0.6962316\",\n \"0.6960264\",\n \"0.6905935\",\n \"0.6833638\",\n \"0.677917\",\n \"0.6773883\",\n \"0.6686437\",\n \"0.66210973\",\n \"0.66116637\",\n \"0.65953153\",\n \"0.6575552\",\n \"0.65732825\",\n \"0.65653706\",\n \"0.6519847\",\n \"0.64996016\",\n \"0.6478882\",\n \"0.64316595\",\n \"0.64263415\",\n \"0.64237976\",\n \"0.64127135\",\n \"0.6407158\",\n \"0.6388259\",\n \"0.63869727\",\n \"0.63860285\",\n \"0.63668925\",\n \"0.6353181\",\n \"0.63519156\",\n \"0.634344\",\n \"0.6340914\",\n \"0.6337721\",\n \"0.6336406\",\n \"0.6333282\",\n \"0.63230634\",\n \"0.63153434\",\n \"0.6312497\",\n \"0.63002664\",\n \"0.62928915\",\n \"0.62892985\",\n \"0.62865037\",\n \"0.6285184\",\n \"0.62726974\",\n \"0.6258674\",\n \"0.6253497\",\n \"0.62466663\",\n \"0.6238969\",\n \"0.6222369\",\n \"0.6221557\",\n \"0.62190616\",\n \"0.62106085\",\n \"0.6210021\",\n \"0.6204906\",\n \"0.6193252\",\n \"0.6177791\",\n \"0.6170863\",\n \"0.616685\",\n \"0.6165775\",\n \"0.61622465\",\n \"0.61564004\",\n \"0.6154787\",\n \"0.6154475\",\n \"0.6153497\",\n \"0.6153185\",\n \"0.6150401\",\n \"0.6145671\",\n \"0.61298484\",\n \"0.6111535\",\n \"0.61112607\",\n \"0.6102378\",\n \"0.6101014\",\n \"0.60996413\",\n \"0.6097955\",\n \"0.60964465\",\n \"0.6096214\",\n \"0.609592\",\n \"0.6093485\",\n \"0.6092347\",\n \"0.6083148\",\n \"0.6080917\",\n \"0.6076761\",\n \"0.60590476\",\n \"0.6054251\",\n \"0.6052966\",\n \"0.6031892\",\n \"0.60287666\",\n \"0.60284466\",\n \"0.60279125\",\n \"0.60276127\",\n \"0.6026284\",\n \"0.6024586\",\n \"0.6018516\",\n \"0.60182357\",\n \"0.6016604\",\n \"0.60134894\",\n \"0.60131216\",\n \"0.6009512\",\n \"0.59971213\",\n \"0.59945375\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6229725"},"document_rank":{"kind":"string","value":"48"}}},{"rowIdx":84799,"cells":{"query":{"kind":"string","value":"culculats all status changes in the game for one game loop"},"document":{"kind":"string","value":"def calculate_scene(self):\n \n if self.is_game_going:\n for pl in self.player_list:\n pl.make_step()\n\n #obj_list = self.player_list + self.foot_list + self.border_list\n obj_list = self.player_list + self.grafik_item_list\n for pl in self.player_list:\n pl.check_for_intersection(obj_list)\n\n for pl in self.player_list:\n if pl.status_remove:\n print(\"x killll xxx\")\n self.stop_game()\n\n # filter removed/killed objecets\n for item in self.grafik_item_list:\n if item.status_remove:\n if item.type == \"food\":\n item.set_random_position()\n\n # end game if a player is removed"},"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 reset(self):\r\n self.player_hand.reset()\r\n self.dealer_hand.reset()\r\n self.player_hand.add(self.deck.deal())\r\n self.player_hand.add(self.deck.deal())\r\n self.dealer_hand.add(self.deck.deal())\r\n self.dealer_hand.add(self.deck.deal())\r\n # Checking for edge cases where player/dealer (or both) have two aces\r\n if self.player_hand.total == 22 and self.dealer_hand.total == 22:\r\n self.status_color = 'red'\r\n self.game_status = \"TIE Game... Press 'r' to start game\"\r\n self.in_progress = False\r\n elif self.player_hand.total == 22:\r\n self.status_color = 'red'\r\n self.game_status = \"Dealer WINS... Press 'r' to start game\"\r\n self.dealer_wins += 1\r\n self.in_progress = False\r\n elif self.dealer_hand.total == 22:\r\n self.status_color = 'red'\r\n self.game_status = \"Player WINS... Press 'r' to start game\"\r\n self.player_wins += 1\r\n self.in_progress = False\r\n else:\r\n self.game_status = 'In Progress...'\r\n self.status_color = 'green'\r\n self.in_progress = True\r\n self.refresh_canvas()","def reset(self):\n self.game_status = game_status.GameStatus(copy.deepcopy(self.initial_rosters),\n self.game_status.game_date)\n self._current_event_ndx = 0","def run_logic(self):\n if not self.game_over:\n # Move all the sprites\n self.all_sprites_list.update()","def reset_continued(self): \n self._recent_goal_continued = False\n self._update_action = False\n self._update_action_without_pause = False","def refresh_statuses(self):\n if self.skill_tree_displaying:\n return\n _, self.buff_rects, self.debuff_rects = player_panel_renderer.draw_status(self.player_dict['status']['buffs'],\n self.player_dict['status']['debuffs'],\n refresh=True)","def update_all_states(self):\n \n for l in range(0,4):\n temp_s = \"/loop/{}/mode\".format(l+1) # stupid using loop 1 to 4\n temp_m = self.loop_modes[self.loop_states[l]]\n self.osc_client.send_message(temp_s,temp_m)\n print(\"sent_message {} {}\".format(temp_s,temp_m))\n self.set_loop_led(l)\n \n for l in range(0,4):\n for s in range(0,8):\n temp_s = self.osc_slice_string.format(l+1,s)\n temp_m = self.slice_modes[self.slice_states[l][s] ]\n self.osc_client.send_message(temp_s,temp_m)\n print(\"sent message {} {}\".format(temp_s, temp_m))\n self.set_slice_led(l,s)\n return","def run_game(self):\n while True:\n self._check_events() # check event listener\n \n if self.stats.game_active:\n self.ship.update() # update position\n # self.bullets.update() # will update each sprite in the group\n self._update_bullets() \n self._update_aliens()\n\n# self.laser.update()\n self._update_screen() # refresh screen","def reset_status(self):\r\n self.ship_left = self.ai_settings.ship_limit\r\n self.score = 0\r\n self.level = 1","def _to_client_update_state(self):\n start_ticks = pygame.time.get_ticks()\n\n clock = pygame.time.Clock()\n while not self._exit_request:\n if self._paused:\n data = {}\n data[\"message_type\"] = \"state\"\n data[\"state\"] = self._state\n data[\"session_index\"] = self._current_session_index\n data[\"timer\"] = int(self._counter_target - self._counter + 1.0)\n\n _, writable, exceptional = select([], self._to_client_connections, self._to_client_connections, 0)\n for connection in writable:\n try:\n send(connection, data)\n except:\n print(\"Connection closed\")\n connection.close()\n self._to_client_connections.remove(connection)\n \n for connection in exceptional:\n connection.close()\n self._to_client_connections.remove(connection)\n\n start_ticks = pygame.time.get_ticks()\n clock.tick(10)\n continue\n\n seconds = (pygame.time.get_ticks() - start_ticks)/1000.0\n\n if self._counter > self._counter_target:\n self._current_session_index += 1\n\n if self._current_session_index >= len(cfg.SESSION):\n self._exit_request = True\n break\n\n self._counter_target = cfg.SECONDS_PER_SESSION[self._current_session_index]\n self._counter = 0.0\n start_ticks = pygame.time.get_ticks()\n\n elif seconds >= self._counter:\n self._counter += 1.0\n\n data = {}\n data[\"message_type\"] = \"state\"\n data[\"state\"] = self._state\n data[\"session_index\"] = self._current_session_index\n data[\"timer\"] = int(self._counter_target - self._counter + 1.0)\n\n # Record state of the game\n self._csv_writer.writerow([time(), json.dumps(data)])\n\n _, writable, exceptional = select([], self._to_client_connections, self._to_client_connections, 0)\n for connection in writable:\n try:\n send(connection, data)\n except:\n print(\"Connection closed\")\n connection.close()\n self._to_client_connections.remove(connection)\n \n for connection in exceptional:\n connection.close()\n self._to_client_connections.remove(connection)\n \n clock.tick(60)\n\n while self._to_client_connections:\n _, writable, exceptional = select([], self._to_client_connections, self._to_client_connections)\n\n for connection in writable:\n data = {}\n data[\"message_type\"] = \"command\"\n data[\"message\"] = \"CLOSE\"\n\n try:\n send(connection, data)\n except BrokenPipeError:\n print(\"Connection closed\")\n\n connection.close()\n self._to_client_connections.remove(connection)\n \n for connection in exceptional:\n connection.close()\n self._to_client_connections.remove(connection)\n \n clock.tick(60)","def round_reset(self):\n\t\tfor p in self.players: p.reset_state()\n\t\t#self.player = player(self.player.name, self.player.cards)\n\t\tself.small_blind.money -= self.blind // 2\n\t\tself.small_blind.stake += self.blind // 2\n\t\tself.big_blind.money -= self.blind\n\t\tself.big_blind.stake += self.blind\n\t\tself.last_bet_by = self.big_blind\n\t\tself.bank = self.blind\n\t\tself.bank_part = self.blind\n\t\tself.table_cards = []\n\t\tself.stage = stages.nocards","def update(delta_time):\n for event in coda.event.listing():\n if coda.event.quit_game(event):\n coda.stop()\n if coda.event.mouse_l_button_down(event):\n if MY.restart_button.collides_with_point(coda.event.mouse_position()):\n coda.state.change(0)","def update(self):\n self.active = False\n self.top.update(self.rgb,self.cmyk,self.hsv)\n self.bot.update(self.rgb,self.cmyk,self.hsv)\n self.active = True","def update_status_bars():\n for status_bar_name in init.game_state.status_bars.keys():\n gradual_status_bar_fluctuation(status_bar_name)","def update(self):\r\n if not self.tr.game_over and self.tr.turn_tracker:\r\n self.computer_play()","def reset_game():\n global x_pos, o_pos, frames, count\n\n count = 0\n x_pos = []\n o_pos = []\n result.set(\"Your Turn!\")\n for x in frames:\n for y in x.winfo_children():\n y.config(text=\" \", state='normal')","def reset_game(self):\n self.bHasWon = False\n self.game_over = False\n self.game_active = False\n self.player_points = 0\n self.enemy_points = 0\n self.remainingBalls = 0","def clearMyStatus(self):\n self.maxBattery = 0\n self.currentPower = 0\n self.thrust = 0.0\n self.rotation = 0.0\n self.radar = 0\n self.jamming = 0\n self.repair = 0\n self.mass = 0.0\n self.accel = 0.0\n self.maxAssault = 0\n self.assaultStrength = 0","async def status_update_loop(self):\n self.status_message_update_waiter = sleep(UPDATE_INTERVAL, KOKORO)\n \n while self.state == CHANNEL_MOVE_STATE_NONE:\n set_value = await self.status_message_update_waiter\n # sleep sets by `None`\n if set_value is not None:\n break\n \n self.status_message_update_waiter = sleep(UPDATE_INTERVAL, KOKORO)\n await self.update_status_message()\n continue\n \n await self.update_status_message()\n await self.send_done_notification()\n return","def update_game(game, episode, buttons,run_status):\n\n game_round = game.round\n if game_round == 'newround':\n newround(game)\n print(game_round)\n game.round = 'preflop'\n print(game.round)\n\n\n return 'go'\n elif game_round == 'preflop':\n check = preflop(game, episode, buttons)\n if check == True:\n game.round = 'flop'\n return 'go'\n elif check == False:\n game.round = 'showdown'\n print(game.round)\n return 'go'\n elif check == 'no input':\n game.round = 'preflop'\n return 'stop'\n return 'stop'\n elif game_round == 'flop':\n check = flop(game, episode, buttons, run_status)\n if check == True:\n game.round = 'turn'\n return 'go'\n elif check == False:\n game.round = 'showdown'\n return 'go'\n elif check == 'no input':\n game.round = 'flop'\n return 'stop'\n return 'stop'\n pass\n elif game_round == 'turn':\n check = turn(game, episode, buttons, run_status)\n if check == True:\n game.round = 'river'\n return 'go'\n elif check == False:\n game.round = 'showdown'\n return 'go'\n elif check == 'no input':\n game.round = 'turn'\n return 'stop'\n return 'stop'\n elif game_round == 'river':\n check = turn(game, episode, buttons, run_status)\n if check == True:\n game.round = 'showdown'\n return 'go'\n elif check == False:\n game.round = 'showdown'\n return 'go'\n elif check == 'no input':\n game.round = 'river'\n return 'stop'\n return 'stop'\n elif game_round == 'showdown':\n showdown(game, episode)\n #game.player1.wager = 100\n #game.player2.wager = 50\n # game.update_tablepot()\n game.round = 'newround'\n return 'go'\n pass","def main_loop(self):\n while self.game_manager.game_state != GameState.Quit:\n\n self.handle_events()\n self.handle_ui_response()\n #in menu\n if self.game_manager.game_state == GameState.Menu: \n self.display.clear()\n\n #in game\n elif self.game_manager.game_state == GameState.Running:\n self.game_manager.move_players()\n\n #after game\n elif self.game_manager.game_state == GameState.Finished:\n if self.game_manager.winner == None:\n self.game_manager.player1.decay()\n self.game_manager.player2.decay() \n else:\n self.game_manager.loser.decay()\n self.game_manager.loser.draw()\n\n #perform game manager actions\n self.game_manager.act()\n #do all the rendering stuff\n self.render_scene()\n #control FPS\n self.clock.tick(self.FPS)","def run_game(self):\n\t\twhile True:\n\t\t\tself._check_event()\n\t\t\tself.ship.update()\n\t\t\tself._update_bullets()\n\t\t\tself._update_aliens()\n\t\t\tself._update_screen()","def process_game_logic(self):\n self.dmod = -1\n self.smod = -1\n if self.state == self.STATE_SETUP:\n if self.current_game < self.config['General']['games_per_session']:\n self.current_game += 1\n self.state = self.STATE_GAMENO\n self.game_title = \"Game: %d of %d\" % (self.current_game, self.config['General']['games_per_session'])\n self.game_title = pygl2d.font.RenderText(self.game_title, (255, 255, 0), self.f36)\n self.game_title_rect = self.game_title.get_rect()\n self.game_title_rect.center = (self.SCREEN_WIDTH / 2, self.SCREEN_HEIGHT / 16 * 7)\n self.gameevents.add(\"display_game\", self.current_game)\n else:\n self.state = self.STATE_DONE\n self.ret = 0\n self.lc.stop()\n elif self.state == self.STATE_SETUP_IFF:\n self.mine_list.generate_foes()\n self.gameevents.add(\"display_foes\", \" \".join(self.mine_list.foe_letters), \"player\")\n self.foe_top = pygl2d.font.RenderText(\"The Type-2 mines for this session are:\", (255, 255, 0), self.f24)\n self.foe_top_rect = self.foe_top.get_rect()\n self.foe_top_rect.center = (self.SCREEN_WIDTH / 2, 270 * self.aspect_ratio)\n self.foe_middle = pygl2d.font.RenderText(\", \".join(self.mine_list.foe_letters), (255, 255, 255), self.f96)\n self.foe_middle_rect = self.foe_middle.get_rect()\n self.foe_middle_rect.center = (self.SCREEN_WIDTH / 2, self.SCREEN_HEIGHT / 2)\n self.foe_midbot = pygl2d.font.RenderText(\"Try to memorize them before proceeding\", (255, 255, 0), self.f24)\n self.foe_midbot_rect = self.foe_midbot.get_rect()\n self.foe_midbot_rect.center = (self.SCREEN_WIDTH / 2, 500 * self.aspect_ratio)\n self.foe_bottom = pygl2d.font.RenderText(\"Press return to begin\", (255, 255, 0), self.f24)\n self.foe_bottom_rect = self.foe_bottom.get_rect()\n self.foe_bottom_rect.center = (self.SCREEN_WIDTH / 2, 600 * self.aspect_ratio)\n self.state = self.STATE_IFF\n elif self.state == self.STATE_PREPARE:\n self.gameevents.add(\"game\", \"ready\", type='EVENT_SYSTEM')\n self.setup_world()\n self.state = self.STATE_PLAY\n self.gameevents.add(\"game\", \"start\", type='EVENT_SYSTEM')\n elif self.state == self.STATE_PLAY:\n self.ship.compute()\n if not self.ship.jumped:\n\n overlay = np.zeros((int(self.world.bottom-self.world.top),int(self.world.right-self.world.left),3),np.uint8)\n\n\n cv2.line(overlay,(int(self.ship.position.x-self.world.left),int(self.ship.position.y-self.world.top)),(int(self.ship.oldPosx-self.world.left),int(self.ship.oldPosy-self.world.top)),(255,255,255),self.config['Playback']['line_width'])\n\n cv2.addWeighted(overlay,self.config['Playback']['intensity']/100.0,self.img,1.0,0,self.img)\n\n distance = self.ship.get_distance_to_point(self.WORLD_WIDTH / 2, self.WORLD_HEIGHT / 2)\n flight_max_inc = self.config['Score']['flight_max_increment']\n dmod = 1 - (distance - self.smallhex.radius * 1.125) / (self.WORLD_WIDTH / 2)\n if dmod > 1.0: dmod = 1.0\n if dmod < 0.0: dmod = 0.0\n smod = max([abs(self.ship.velocity.x), abs(self.ship.velocity.y)]) / self.ship.max_vel\n self.dmod = dmod\n self.smod = smod\n for missile in self.missile_list:\n missile.compute()\n if self.fortress_exists == True:\n self.fortress.compute()\n for shell in self.shell_list:\n shell.compute()\n if self.config['Hexagon']['hex_shrink']:\n self.bighex.compute()\n if self.mine_exists:\n if self.mine_list.flag == False and self.mine_list.timer.elapsed() > self.mine_list.spawn_time:\n self.gameevents.add(\"spawn\", \"mine\")\n elif self.mine_list.flag and self.mine_list.timer.elapsed() > self.mine_list.timeout:\n self.gameevents.add(\"timeout\", \"mine\")\n self.mine_list.compute()\n self.check_bounds()\n #test collisions to generate game events\n self.test_collisions()\n if self.flighttimer.elapsed() > self.config['Score']['update_timer']:\n self.flighttimer.reset()\n def pointspace (a0, a1, a2, b0, b1, b2): return math.exp(a1 ** (a0 * a2)) * math.exp(b1 ** (b0 * b2))\n points = flight_max_inc * pointspace(self.dmod, 2, 1, self.smod, 2, 1.75) / pointspace(1, 2, 1, 1, 2, 1.75)\n self.gameevents.add(\"score+\", \"flight\", points)\n self.flight2 += flight_max_inc * pointspace(self.dmod, 2, .45, self.smod, 2, 1) / pointspace(1, 2, .45, 1, 2, 1)\n if (self.ship.velocity.x ** 2 + self.ship.velocity.y ** 2) ** 0.5 < self.config['Score']['speed_threshold']:\n self.gameevents.add(\"score+\", \"vlcty\", self.config['Score']['VLCTY_increment'])\n #self.gameevents.add(\"score+\", \"flight\", self.config['Score']['VLCTY_increment'])\n else:\n self.gameevents.add(\"score-\", \"vlcty\", self.config['Score']['VLCTY_increment'])\n #self.gameevents.add(\"score-\", \"flight\", self.config['Score']['VLCTY_increment'])\n if self.bighex.collide(self.ship):\n self.gameevents.add(\"score+\", \"cntrl\", self.config['Score']['CNTRL_increment'])\n #self.gameevents.add(\"score+\", \"flight\", self.config['Score']['CNTRL_increment'])\n else:\n self.gameevents.add(\"score+\", \"cntrl\", self.config['Score']['CNTRL_increment'] / 2)\n #self.gameevents.add(\"score+\", \"flight\", self.config['Score']['CNTRL_increment']/2)\n if self.bonus_exists:\n if self.config['General']['bonus_system'] == \"AX-CPT\":\n self.bonus.axcpt_update()\n else:\n if self.bonus.visible == False and self.bonus.timer.elapsed() > self.config['Bonus']['symbol_down_time']:\n self.gameevents.add(\"activate\", \"bonus\")\n elif self.bonus.visible == True and self.bonus.timer.elapsed() >= self.config['Bonus']['symbol_up_time']:\n self.gameevents.add(\"deactivate\", \"bonus\", self.bonus.current_symbol)\n #update scores\n self.score.pnts = self.score.__getattribute__(\"pnts\")\n self.score.vlcty = self.score.__getattribute__(\"vlcty\")\n self.score.cntrl = self.score.__getattribute__(\"cntrl\")\n self.score.speed = self.score.__getattribute__(\"speed\")\n self.score.flight = self.score.__getattribute__(\"flight\")\n self.score.fortress = self.score.__getattribute__(\"fortress\")\n self.score.mines = self.score.__getattribute__(\"mines\")\n self.score.bonus = self.score.__getattribute__(\"bonus\")\n\n if self.gametimer.elapsed() > self.config['General']['game_time']:\n self.gameevents.add(\"game\", \"over\", type='EVENT_SYSTEM')\n self.state = self.STATE_SCORES\n self.img = 255-self.img\n now = datetime.datetime.now()\n cv2.imwrite('../Recordings/' + str(now.year) + \"_\"+str(now.month)+\"_\" + str(now.day) + \"_\" + str(now.hour) + \"_\" + str(now.minute)+\"_\" + 'lines.jpg',(self.img),[int(cv2.IMWRITE_JPEG_QUALITY), 100])","def run_game(self):\n # redraw the screen during each pass thought the loop and Set the background color from settings.py.\n\n while True:\n self._check_events()\n self.ship.update(self.time_delta)\n self.bullets.update(self.time_delta)\n self._update_bullets()\n self._update_screen()","def update_screen(ai_settings,grid, screen, buttons, screen_status, button_status, card_database_filter, user,action, player2):\n screen.fill((250,250,250))\n # Theme filter\n if ai_settings.theme_indicator == 'Lith Harbor':\n screen.blit(pygame.image.load('static/bg_images/bg_02.png'), (0,0))\n elif ai_settings.theme_indicator == 'Leafre':\n screen.blit(pygame.image.load('static/bg_images/bg_05.jpg'), (0,0))\n elif ai_settings.theme_indicator == 'Pantheon':\n screen.blit(pygame.image.load('static/bg_images/bg_06.png'), (0,0))\n elif ai_settings.theme_indicator == 'Ellinia':\n screen.blit(pygame.image.load('static/bg_images/bg_04.jpeg'), (0,0))\n\n if button_status.lobby_screen_game_start == True:\n if screen_status.lobby_screen_display == True and screen_status.battle_screen_display == False:\n screen_status.lobby_screen_display = False\n screen_status.battle_screen_display = True\n\n if screen_status.welcome_screen_display:\n welcome_screen_update(ai_settings,screen, buttons, screen_status, button_status)\n\n if screen_status.lobby_screen_display:\n lobby_screen_update(ai_settings,grid, screen, buttons, screen_status, button_status, card_database_filter, user,action, player2)\n\n if screen_status.prepare_screen_display:\n prepare_screen_update(ai_settings,grid, screen, buttons, screen_status, button_status, card_database_filter, user, player2)\n\n if screen_status.build_deck_screen_display:\n build_deck_screen_update(ai_settings, grid, screen, buttons, screen_status, button_status, card_database_filter, user)\n\n if screen_status.battle_screen_display:\n battle_screen_update(ai_settings,grid, screen, buttons, screen_status, button_status, card_database_filter, user, player2)\n\n # Display zoom in affect at the end to cover previous draw when zoom in\n card_zoom_update(ai_settings, screen, buttons,screen_status, button_status, card_database_filter, user, player2)\n\n #Rules display\n rules_display(ai_settings, screen, buttons,screen_status, button_status, card_database_filter, user, player2)\n\n #Text input box display\n text_input_box_display(ai_settings, screen, buttons,screen_status, button_status, card_database_filter, user, player2)\n\n # music volume\n if ai_settings.music_indicator == True:\n pygame.mixer.music.set_volume(1.0)\n else:\n pygame.mixer.music.set_volume(0)\n\n pygame.display.flip()","def update(self):\n if self.account and OPTION.COMET in self.account.options:\n if self.get_conn().get_browser() not in IFRAME_BROWSERS:\n self.game_request.write(OUTPUT_END_TAG)\n self.seconds_played += 1\n self.inactivity += 1\n\n if FLAG.INGESTED in self.flags:\n return\n\n pass","def update(self):\n if pygame.time.get_ticks() - self.start_time > const.LEVEL_WAITING:\n self.player.update()\n self.platform_list.update()\n self.platform_grass_list.update()\n self.platform_stone_list.update()\n self.enemy_list.update()\n self.bullet_list.update()\n self.active_sprite.update()\n self.enemy_bubble_list.update()\n self.fruit_list.update()\n for bullet in self.bullet_list:\n if bullet.rect.x > const.SCREEN_WIDTH + 10 or bullet.rect.x < -10:\n self.bullet_list.remove(bullet)\n self.active_sprite.remove(bullet)\n\n\n for guy in self.enemy_list:\n enemy_hit_list = pygame.sprite.spritecollide(guy, self.bullet_list, False, pygame.sprite.collide_circle)\n for hit in enemy_hit_list:\n bub_enemy= enemy.Enemy_bubble(guy)\n self.enemy_list.remove(guy)\n\n self.bullet_list.remove(hit)\n self.active_sprite.add(bub_enemy)\n self.active_sprite.remove(hit)\n self.active_sprite.remove(guy)\n\n self.enemy_bubble_list.add(bub_enemy)\n\n\n if len(self.enemy_list) == 0 and len(self.enemy_bubble_list) == 0 and self.close_time == 0:\n self.close_time=pygame.time.get_ticks()\n\n if self.close_time > 0 and pygame.time.get_ticks()-self.close_time > 2000:\n self.close = True","def on_update(self):\n \n # update physics engine\n \n \n # use code from pick up coins lab to pick up coins\n # you don't need all of the code from that lab(no gameover or reset)","def GAMEOVER_LOOP():\n pass","def breakout_loop(self):\n while self.playing:\n self.handle_events()\n self.update()\n if self.game_over:\n self.current_menu = self.fail_menu\n self.playing = False\n self.reset()\n self.draw()","def run_game(self):\n while True:\n self._check_events()\n self._update_rain()\n self._update_screen()","def run_game(self):\n while True:\n self._check_events()\n\n if self.stats.game_active:\n self.ship.update()\n self._update_bullet()\n self._update_aliens()\n \n self._update_screen()","def updateComplete(self):\n self.livesScreen()\n if self.getWave().getLives() == 0:\n self.deathScreen()\n else:\n self.winScreen()","def update(self):\n self.wall_list.update()\n self.enemy_list.update()\n self.sludge.update()\n self.consumeable.update()\n self.can_climb.update()","def reset_stage_move_counters(self):\n self.total_xyz_move_counter = [[0, 0, 0], [0, 0, 0], [0, 0]]\n self.failed_xyz_move_counter = [0, 0, 0]\n self.slow_xy_move_counter = 0\n self.slow_xy_move_warnings.clear()\n self.failed_x_move_warnings.clear()\n self.failed_y_move_warnings.clear()\n self.failed_z_move_warnings.clear()","def update_state_game_variables(self):\n self.model.numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8]\n self.model.player_mark = \"\"\n self.model.player_move = 0\n self.model.boards = [\"board\"] * 9\n self.update_score_board()","def update(self):\n\t\t# If being controlled by COM\n\t\tif self.controled_by_com :\n\t\t\t# Substract 1 from the update counter\n\t\t\tself.update_counter -= 1\n\t\t\t# If the update counter reaches zero\n\t\t\tif self.update_counter == 0. :\n\t\t\t\t# then ask for an action \n\t\t\t\tif self.intermediate_phase is False :\n\t\t\t\t\tself.action_required = True \n\t\t\t\t\t\t\n\t\t\t\t# if during a change\n\t\t\t\t# then make the change\n\t\t\t\tif self.intermediate_phase is True : \n\t\t\t\t\tself.action_required = False\n\t\t\t\t\tself._color_changer() #Make the change in the Simulator\n\t\telse :\n\t\t\tpass","def refresh_all_players(all_players):\n for player in all_players:\n player.locked_actions = player.available_actions\n player.available_actions = []\n player.hand = CardGroup()\n player.is_down = False\n player.buy_count = 0\n #update screens here to show the locking.","def reset_game(self):\n self._buttons_active = False\n self._laser_label.clear()\n self.add_items_labels()\n self.add_question_marks()\n QtCore.QTimer.singleShot(conf.second_display_duration,\n self.enter_phase_two)","def reset(self):\n self.players = [Player(), Player(), Player(), Player()]\n self.hist = []\n self.round = 1\n self.current_player = 0\n self.first_winner_was = -1\n self.current_dice = -1\n self.observation_pending = False\n self.current_move_pieces = []\n self.current_enemys = []\n self.current_start_attempts = 0\n self.game_winners = []","def update_main_game_loop(self):\n delta_time = self.delta_time()\n\n if delta_time >= 1.0 / self.target_fps:\n self.update_keys(delta_time)\n for game_object in [g for g in self.game_objects if g.enabled]:\n game_object.update(delta_time)\n # end for\n self.time_node.setAttr('unwarpedTime', self.time_node.getAttr('unwarpedTime') + delta_time * 24)\n self.time_node.setAttr('outTime', self.time_node.getAttr('outTime') + delta_time * 24)\n pm.refresh(f=True)\n else:\n pm.refresh(f=True)\n # end if","def update_gameclock():\n global game_ticks\n ## GOTCHA: Both Ball.update() and Ball.predict() modify sprite\n ## position, so the update and display routines must each perform\n ## erasure. This results in redundant erasures whenever an update and\n ## frame are ready in the same pass. This happens almost every game tick\n ## at high frame rates, often enough that an avoidance optimization\n ## would gain a few FPS.\n sprite_group.clear(screen, eraser_image)\n sprite_group.update(USE_PREDICTION)\n handle_collisions()\n game_ticks += 1\n if game_ticks >= clock.ticks_per_second:\n set_caption()\n game_ticks = 0","def run_game(self):\n while True:\n self._check_events()\n if self.stats.game_active:\n self.ship.update_movement()\n self._update_bullets()\n self.special_bullet.update()\n self._update_stars()\n \n self._update_screen()","def algo_mover(self):\n self.tick_count = 0 ## reset to start clock on delayed state change\n\n ### Move 1 ring ###\n de, aux, vers = self.instructions.pop(0)\n\n de = self.rods[de]\n aux = self.rods[aux]\n vers = self.rods[vers]\n\n ring = de.pop_ring()\n vers.add_ring(ring)\n\n ### Update the states after -- moved this to main update\n #self.state_updater()","def update():\n # Initialization (only runs on start/restart)\n player1 = Player()\n player2 = Player()\n\n walls, start = parse_level(LEVEL)\n\n player1.idx = 1\n player1.key_up = \"w\"\n player1.key_down = \"s\"\n player1.key_left = \"a\"\n player1.key_right = \"d\"\n player1.key_small = \"f\"\n player1.key_shoot = \"c\"\n\n player2.idx = 2\n player2.key_up = \"i\"\n player2.key_down = \"k\"\n player2.key_left = \"j\"\n player2.key_right = \"l\"\n player2.key_small = \"h\"\n player2.key_shoot = \"n\"\n\n reset_players = True\n # Main update loop\n while True:\n if reset_players:\n reset_players = False\n player1.centerx = start[0][0]\n player1.centery = start[0][1]\n player2.centerx = start[1][0]\n player2.centery = start[1][1]\n shots.clear()\n\n update_player(player1, delta())\n update_player(player2, delta())\n\n to_remove = []\n for shot in shots:\n if not update_shot(shot, delta()):\n to_remove.append(shot)\n for shot in to_remove:\n shots.remove(shot)\n\n draw_player(player1)\n draw_player(player2)\n for shot in shots:\n draw_shot(shot)\n\n for shot in shots:\n for other in shots:\n if shot.shooter_idx != other.shooter_idx:\n _, depth = overlap_data(shot, other)\n if depth > 0:\n to_remove.append(shot)\n for player in (player1, player2):\n _, depth = overlap_data(player, shot)\n if depth > 0 and player.idx != shot.shooter_idx:\n print(f\"{player.idx} ded by {shot.shooter_idx}\")\n reset_players = True\n for shot in to_remove:\n shots.remove(shot)\n\n for wall in walls:\n window = pg.display.get_surface()\n pg.draw.rect(window, pg.Color(100, 100, 100), wall)\n for player in (player1, player2):\n player.velocity, wall_vel, overlap = solve_rect_overlap(player,\n wall,\n player.velocity,\n mass_b=0,\n bounce=0.1)\n\n # Main loop ends here, put your code above this line\n yield","def apply_status(\n player1: Player, player2: Player, rules: dict, message: List[str]\n) -> Tuple[Player, Player, dict, List[str]]:\n if player1.status_effects:\n status_effects = copy.copy(player1.status_effects)\n offset = 0\n for i, status_effect in enumerate(status_effects):\n # Apply the status effect\n player1, player2, rules = getattr(\n combat_effects, \"apply_\" + status_effect[0]\n )(self=player1, target=player2, rules=rules, left=True)\n message.append(f\"Applied effects of {status_effect[0]} to {player1.name}\")\n\n # Decrease the duration of this status effect, which is a list like this:\n # ['name_of_status', duration], so we index to 1 to get duration\n status_effect[1] -= 1\n\n # Remove status effect if duration is 0\n if status_effect[1] == 0:\n print(f\"\\n{i} {offset} Deleting {status_effect[0]} from entry {i-offset}\"\n f\" in {player1.status_effects}\")\n del player1.status_effects[i - offset]\n offset += 1\n\n if player2.status_effects:\n status_effects = copy.copy(player2.status_effects)\n offset = 0\n for i, status_effect in enumerate(status_effects):\n # Apply the status effect\n player2, player1, rules = getattr(\n combat_effects, \"apply_\" + status_effect[0]\n )(self=player2, target=player1, rules=rules, left=False)\n message.append(f\"Applied effects of {status_effect[0]} to {player2.name}\")\n\n # Decrease the duration of this status effect, which is a list like this:\n # ['name_of_status', duration], so we index to 1 to get duration\n status_effect[1] -= 1\n\n # Remove status effect if duration is 0\n if status_effect[1] == 0:\n print(f\"{i} Deleting {status_effect[0]} from first entry in\"\n f\" {player2.status_effects}, offset={offset}\")\n del player2.status_effects[i - offset]\n offset += 1\n\n return player1, player2, rules, message","def status(self) -> NoReturn:\n\n curr_status= self.percent_done()\n while(curr_status < 100):\n\n update_status(name=self.name, status=curr_status)\n time.sleep(0.5)\n\n curr_status = self.percent_done()\n\n update_status(name=self.name, status=curr_status)","def setPlayerStates(self, updates):\r\n for upd in updates:\r\n print \"UPD player %s\" % upd['player']\r\n player = self.players[upd['player']]\r\n player.setStatus(upd['status'], upd['jump'], upd['charge'])\r\n\r\n player.health = upd['health']\r\n if player == self.myPlayer:\r\n #self.healthbar.setValue(self.myPlayer.health)\r\n pass","async def countdown_status(bot: commands.Bot) -> None:\n while is_in_advent():\n _, time_left = time_left_to_aoc_midnight()\n\n aligned_seconds = int(math.ceil(time_left.seconds / COUNTDOWN_STEP)) * COUNTDOWN_STEP\n hours, minutes = aligned_seconds // 3600, aligned_seconds // 60 % 60\n\n if aligned_seconds == 0:\n playing = f\"right now!\"\n elif aligned_seconds == COUNTDOWN_STEP:\n playing = f\"in less than {minutes} minutes\"\n elif hours == 0:\n playing = f\"in {minutes} minutes\"\n elif hours == 23:\n playing = f\"since {60 - minutes} minutes ago\"\n else:\n playing = f\"in {hours} hours and {minutes} minutes\"\n\n # Status will look like \"Playing in 5 hours and 30 minutes\"\n await bot.change_presence(activity=discord.Game(playing))\n\n # Sleep until next aligned time or a full step if already aligned\n delay = time_left.seconds % COUNTDOWN_STEP or COUNTDOWN_STEP\n await asyncio.sleep(delay)","def game_updated(self):\n # <<-- Creer-Merge: game-updated -->> - Code you add between this comment and the end comment will be preserved between Creer re-runs.\n game = self.game\n\n for x in range(game.board_width):\n for y in range(game.board_height):\n self.checkers_map[x][y] = None\n\n self.force_checker = None\n self.cant_move = False\n for checker in game.checkers:\n self.checkers_map[checker.x][checker.y] = checker\n if checker.owner is self.player and checker is game.checker_moved:\n if game.checker_moved_jumped:\n self.force_checker = checker\n else:\n self.cant_move = True\n # <<-- /Creer-Merge: game-updated -->>","def _countdown(self):\n self._game.deleteBall()\n self._game.draw()\n # reset paddle speed\n self._game.updatePaddle(self.input)\n if ZERO_SECS <= self.time < ONE_SEC:\n self._mssg = (GLabel(text='3', x=GAME_WIDTH/2, y=GAME_HEIGHT/2,\n font_size=COUNTDOWN_FONT_SIZE))\n if ONE_SEC <= self.time < TWO_SECS:\n self._mssg = (GLabel(text='2', x=GAME_WIDTH/2, y=GAME_HEIGHT/2,\n font_size=COUNTDOWN_FONT_SIZE))\n if TWO_SECS <= self.time < THREE_SECS:\n self._mssg = (GLabel(text='1', x=GAME_WIDTH/2, y=GAME_HEIGHT/2,\n font_size=COUNTDOWN_FONT_SIZE))\n if self.time >= THREE_SECS:\n self._mssg = None\n self._game.serveBall()\n self._state = STATE_ACTIVE\n self._points_mssg = (GLabel(text='Points: 0', x=POINTS_X, y=POINTS_Y, font_size=24))","def update(self):\n self.platform_list.update()\n self.exit_sprite.update()\n self.bagGroup.update()\n self.enemy_list.update()","def clear_game_moves(self):\r\n self.prev_message = None\r\n self.play_moves = []","def _run_one_game(self):\n sum_reward = 0\n done = False\n state = torch.tensor(self.env.reset(), device=device).view(1, -1)\n losses = list()\n\n while not done:\n\n # Choose action in function of observation and play it\n action = self._select_action(state)\n next_state, reward, done, _ = self.env.step(action.item())\n\n sum_reward += reward\n next_state = torch.tensor(next_state, device=device).view(1, -1)\n reward = torch.tensor([reward], device=device)\n done = torch.tensor([done], device=device)\n \n # Add transition to memory\n self._add_to_memory(state, action, next_state, reward, done)\n\n # Compute loss\n loss = self._optimize_model()\n losses += [loss]\n \n # Prepare next state\n state = next_state\n\n # Wait time_to_sleep second so the user can view the state\n sleep(self.time_to_sleep)\n \n\n return sum_reward, mean(losses)","def revert_state(self):\n if self.previous_states > 0: # checks for empty\n self.update_status(self.previous_states.pop())","def correctPending(self):\n if self.lastPainted:\n self.doPaint(self.lastPainted[0], self.lastPainted[1], self.colors['idle'], \"gray75\")\n self.lastPainted = None","def update(self):\n if self.black + self.white == self.SIZE*self.SIZE:\n if self.black > self.white:\n self.gc.black_wins = True\n elif self.white > self.black:\n self.gc.white_wins = True\n else:\n self.gc.tie = True\n self.gc.black_num = self.black\n self.gc.white_num = self.white","def reset(self):\n self.disable()\n self.shoot_again = False\n self.balls_added_live = 0","def update(self, game):\n self.lastrect = self.rect\n # no need to redraw if nothing was updated\n self.lastmove += 1\n if not self.is_static:\n self.physics.passiveMovement(self)","def changes(screen):\r\n global inventory\r\n screen.blit(bg, (0, 0))\r\n Sprites.draw(screen)\r\n Sprites.update()\r\n ammo.draw(screen)\r\n ammo.update()\r\n prt.check_trying_using()\r\n if inventory.count('score {}'.format(id(score_0))) == 0:\r\n score_0.pick(inventory, player, Sprites, score)\r\n if inventory.count('score {}'.format(id(score_1))) == 0:\r\n score_1.pick(inventory, player, Sprites, score)\r\n if inventory.count('boost {}'.format(id(sp))) == 0:\r\n sp.boost(inventory, player, Sprites)\r\n borders(WIDTH, HEIGHT)\r\n see_score(score)\r\n key_0.pick(inventory, player, Sprites)\r\n pygame.display.flip()","def GAME_LOOP():\n pass","def manual_update(self):\n for cb, status in zip(self._manual_cbs, self.status_objs):\n cb(status)","def run_game(self):\n #create ufos\n self.creat_fleet_ufos()\n \n while True:\n \n self._check_events()\n self.ship.update()\n #self.ufos.update()\n self.missiles.update()\n self._update_screen()\n self.delete_missiles()","def progress_game(self):\r\n\r\n if self.actions == len(self.players):\r\n # Reveal the 3 first cards\r\n output_text = \"Dealing the flop...\"\r\n\r\n self.new_output.emit(output_text)\r\n self.community_cards.flop()\r\n\r\n if self.actions == 2 * len(self.players):\r\n # Reveal a 4th card\r\n output_text = \"Dealing the turn...\"\r\n\r\n self.new_output.emit(output_text)\r\n self.community_cards.turn()\r\n\r\n if self.actions == 3 * len(self.players):\r\n # Reveal a 5th card\r\n output_text = \"Dealing the river...\"\r\n\r\n self.new_output.emit(output_text)\r\n self.community_cards.river()\r\n\r\n if self.actions == 4 * len(self.players):\r\n self.showdown()","def update(self):\n super().update()\n time_since_start = self.time_since_start() \n curr_mod = time_since_start%self.game.time_cycle_secs\n grade = abs(curr_mod - self.game.time_cycle_secs/2) / (self.game.time_cycle_secs/2)\n color_value = grade*(255-self.game.max_darkness) + self.game.max_darkness\n for sprite in self.all_sprites:\n sprite.color = (color_value, color_value, color_value)","def game_updated(self):\n\n # replace with your game updated logic\n self.update_board()","def events(self):\n for event in pygame.event.get():\n if event.type == pygame.QUIT:\n self.running = False\n self.sleep_time = 0\n return\n\n if event.type == pygame.MOUSEBUTTONUP:\n pos = pygame.mouse.get_pos()\n\n if self.button.collidepoint(pos):\n if self.state == \"solving\":\n self.state = \"stopping\"\n\n if self.state == \"solved\":\n self.state = \"waiting\"\n self.puzzle_state = \"solving\"\n self.button_text = \"Solve!\"\n self.board = self.original_board.copy()\n\n elif self.state == \"waiting\":\n self.state = \"solving\"\n self.button_text = \"Stop!\"\n self.button_color = BUTTON_COLOR_STOP\n\n isSolved = self.solve()\n\n self.button_color = BUTTON_COLOR_SOLVE\n if isSolved:\n self.state = \"solved\"\n self.button_text = \"Clear\"\n self.puzzle_state = \"solved\"\n else:\n if self.state == \"stopping\":\n self.state = \"waiting\"\n self.button_text = \"Solve!\"\n self.puzzle_state = \"solving\"\n else:\n self.state = \"solved\"\n self.button_text = \"Clear\"\n self.puzzle_state = \"failed\"","def apply_box_score_events(self):\n box_score_events = self.game_status.clear_event_buffer()\n for e in box_score_events:\n self.players.update(e)","def run(self):\r\n \r\n if not self.gameOver:\r\n screen.fill(COLOR3)\r\n self.board.drawBoard()\r\n self.handleEvents()\r\n for piece in self.board.pieces.values():\r\n piece.update()\r\n else:\r\n self.resetGame()\r\n pygame.display.update()","def _StatusUpdateThreadMain(self):\n while self._status_update_active:\n self._UpdateStatus()\n time.sleep(self._status_update_interval)","def updateInt():\n global running_status\n running_status = False\n adc.running_status = False\n app.logger.warning(\"Updating\")\n if os.path.isdir('./temp/'):\n shutil.rmtree('./temp')\n git.Repo.clone_from('https://github.com/kgallimo/flask.git', './temp')\n for f in os.listdir('./temp/'):\n if os.path.isfile(f) and f is not '.gitignore':\n app.logger.info(\"Moving \" + str(f))\n shutil.move(os.path.join('./temp/', f), os.path.join('./', f))\n elif os.path.isdir(f) and f is not '.git':\n app.logger.info(\"In directory: \" + f)\n for rf in os.listdir('./temp/' + f):\n app.logger.info('./temp/' + str(f) + str(rf))\n if os.path.isfile('./temp/' + f + '/' + rf):\n app.logger.info(\"Moving \" + str(rf))\n shutil.move(os.path.join('./temp/' + f, rf), os.path.join('./' + f, rf))\n shutil.rmtree('./temp')\n running_status = True\n adc.running_status = True","def Gameloop():","def erase(self):\n\tself.state={}\n\tself.display(update_board=0)","def reset_game(var, wrapper, message):\n wrapper.send(messages[\"fstop_success\"].format(wrapper.source))\n if var.PHASE != \"join\":\n stop_game(var, log=False)\n else:\n pl = [p for p in get_players() if not p.is_fake]\n reset_modes_timers(var)\n reset()\n if pl:\n wrapper.send(messages[\"fstop_ping\"].format(pl))","def run_game(self):\n while True:\n self._check_events()\n if self.stats.game_active:\n self.sideways_ship.update()\n self._update_bullets()\n self._update_aliens()\n self._update_screen()","def update_pygame():\n global elapsed\n sprite_group.update(False)\n handle_collisions()\n elapsed += pygame_clock.get_time()\n if elapsed >= 1000:\n set_caption()\n elapsed -= 1000","def run(self):\n\t\t\n\t\twhile self.update():\n\t\t\tpass","def _loop(self):\n while True:\n if GameLoop.getInstance()._cancelation_token==True:\n break\n self._update_signal.notify_all()\n sleep(1/60)","def warmup():\n print camera.CoolerOFF()\n camera.status.update()","def logic(self, state):\n\n self.pos += self.vel\n\n to_remove = set()\n for script in self.scripts:\n try:\n next(script)\n except StopIteration:\n to_remove.add(script)\n self.scripts.difference_update(to_remove)\n\n self.state.debug.rectangle(self.rect, self._random_color)\n self.state.debug.vector(self.vel * 10, self.center, self._random_color)","def update(self):\n events = pygame.event.get()\n self.plane_update()\n self.bullet_update(events)\n self.background_update()\n self.enemy_update(events)","def update(self):\n if(self.game_on is True and\n (self.player_turn is True or self.computer_turn is True)):\n self.board.display()\n if(self.board.tiles.count == self.SPOT * self.SPOT or\n self.no_more_move()):\n self.player_turn = False\n self.computer_turn = False\n if(self.no_more_move()):\n print(\"No legal move for both!\")\n print(\"Game Over!\")\n if(len(self.board.tiles.blacks) ==\n len(self.board.tiles.whites)):\n self.tie = True\n elif(len(self.board.tiles.blacks) >\n len(self.board.tiles.whites)):\n self.black_wins = True\n elif(len(self.board.tiles.whites) >\n len(self.board.tiles.blacks)):\n self.white_wins = True\n self.winner(len(self.board.tiles.blacks),\n len(self.board.tiles.whites))\n elif(self.game_on is False):\n return\n elif(self.player_turn is False and self.computer_turn is False):\n self.make_record()","def reset_game(self):\n self.ships_left = self.settings.ship_limit\n self.fleets_left = self.settings.fleet_waves\n self.target_miss = self.settings.target_max_miss\n self.reset_level()","def update(self):\n\n # Update guess tracker\n for i in range(atoms):\n\n ident = 'tracker' + str(i + 1)\n\n if i < len(game.guesslist):\n color = scheme.red\n else:\n color = scheme.white\n\n self.ids[ident].color = color\n\n # Update score\n self.ids.score.text = str(game.score)\n\n # Check for end game conditions! Make button (in)visible.\n if len(game.guesslist) == atoms:\n self.ids.end_button.disabled = False\n self.ids.end_button.opacity = 1\n else:\n self.ids.end_button.disabled = True\n self.ids.end_button.opacity = 0","def update(self):\n for player in self.players:\n player.update()\n player.last_seen = player.current_cell\n\n self.in_cell()\n for player in self.players:\n if player.current_cell != player.last_seen:\n self.player_paths.add(player.last_seen)\n #If the player has left a cell and moved into another, the vacated cell is\n #added to the list of cells that have been hit\n if player.current_cell in self.player_paths:\n self.players.remove(player)\n player.alive = False\n if len(self.players) == 1:\n self.end_game(self.players[0].name,self.players[0].color)","def refresh_status() -> None:\n ...","def run_game(self):\n while True:\n self._check_events()\n\n if self.stats.game_active:\n\n self.ship.update()\n self._update_bullets()\n self._update_aliens()\n self.bullets.update()\n # Watch for keyboard and mouse events (an event is an action that the user performs while playing the game ).\n \n self._update_screen()","def run_game(self):\n while True:\n self._check_event()\n self._update_screen()","def __reset(self):\n self.game_moves_history = []\n self.player_id = None","def run(self):\n while True:\n if self.game_over: \n return \n\n self.handle_events() \n if self.paused:\n continue\n\n self.update_generation()\n self.draw_grid()\n\n self.cap_frame_rate()","def update(self, delta_time):\n\n # Call draw() on all your sprite lists below\n game = self.game\n\n if game.exit:\n arcade.close_window()\n \n if not game.is_running:\n return\n\n # if level has changed redraw walls\n if self.game.level != self.last_level:\n self.reset_level()\n self.last_level = self.game.level\n\n if not game.update_game(delta_time):\n return","def goBackInTime(self):\n if (len(self.history) == 0):\n return\n notBusy, notVisible = self.history.pop()\n for cell in notVisible:\n for item in cell[0] + cell[1]:\n self.canvas.delete(item)\n for x, y in notBusy:\n self.gridBusy[x][y] = 0\n self.onBoard -= 1\n self.refreshScore()","def update():\n global current_level\n # Initialization (only runs on start/restart)\n player = Player()\n\n walls, goals, start = parse_level(levels[current_level])\n player.centerx = start[0]\n player.centery = start[1]\n\n # Main update loop\n while True:\n update_player(player, delta())\n draw_player(player)\n\n for wall in walls:\n window = pg.display.get_surface()\n pg.draw.rect(window, pg.Color(100, 100, 100), wall)\n\n player_vel, wall_vel, overlap = solve_rect_overlap(player,\n wall,\n player.velocity,\n mass_b=0,\n bounce=0.1)\n player.velocity = player_vel\n\n for goal in goals:\n window = pg.display.get_surface()\n pg.draw.rect(window, pg.Color(20, 100, 20), goal)\n\n normal, depth = overlap_data(player, goal)\n if depth > 0:\n current_level = (current_level + 1) % len(levels)\n restart()\n\n draw_text(f\"Level: {current_level + 1}\", (0, 0))\n\n # Main loop ends here, put your code above this line\n yield","def clean(self):\n self.iiter = 0\n print(colored('Finished patch %s' % self.image_name, 'yellow'))\n torch.cuda.empty_cache()\n self.loss_min = None\n self.history = u.History(self.args.epochs)","def restartGame(self):\n\t\tself.state = [[0 for x in range(3)] for y in range(3)]\n\t\tself.turn = self.whoGoesFirst()\n\t\tself.win = 0","def update(self):\n self.tick()\n\n self.ball.update(self)\n for c in self.balls:\n print(\"updated ball\")\n c.update(self)\n for c in self.balls:\n for z in self.blocks:\n print(\"updated ball/block\")\n collideWithBlock(z,c)\n for c in self.balls:\n for d in self.balls:\n if not c == d:\n print(\"updated ball/ball\")\n liquidInfluence(c, d)","def update_status(self):\n num_nbrs = len(self.neighbors)\n if not 2 <= num_nbrs <= 3:\n self.status = 0\n elif num_nbrs == 3:\n self.status = 1","def update(self):\n self.screen.fill(blackColor)\n self.model.blocks.draw(self.screen)\n self.model.players.draw(self.screen)\n self.model.buttons.draw(self.screen)\n self.model.Coins.draw(self.screen)\n p1Score = myfont.render(\"Player 1 Score:\"+str(self.model.player1.score), 1, whiteColor)\n self.screen.blit(p1Score,(100,15))\n if self.model.playernum==2:\n p2Score = myfont.render(\"Player 2 Score:\"+str(self.model.player2.score), 1,whiteColor)\n self.screen.blit(p2Score,(1200,15))\n timerLimit = myfont.render(\"Time Limit:\" +str(self.model.time), 1, whiteColor)\n self.screen.blit(timerLimit, (700, 15)) \n pygame.display.update()","def callback_game_loop(self) -> None:\n self._goal_generate()\n self._update()\n self.reset()\n\n while self._player != self._goal:\n self._update()\n action = self._action_callback(\n self._player.np,\n self._goal.np,\n *self._action_callback_args,\n )\n if action == \"QUIT\":\n break\n self._player_erase()\n self.FUNCMAP[action]()\n self._update()\n\n if self._display:\n time.sleep(0.1)\n try:\n if chr(cv2.waitKey(5)) in self.KEYMAP[\"QUIT\"]:\n break\n except ValueError:\n pass\n\n if self._display:\n print(f\"Steps taken: {self._routes[self._current_route_key]}\")\n\n if self._display:\n cv2.waitKey(0)","def run_game(self):\n\t\twhile True:\n\t\t\tself._check_events()\n\t\t\t\n\t\t\tif self.stats.game_active:\n\t\t\t\tself.pigeon.update()\n\t\t\t\tself._update_droppings()\n\t\t\t\tself._update_autos()\n\n\t\t\tself._update_screen()","def loop(self):\n while not rospy.is_shutdown():\n\n rospy.logdebug(\"Loop\")\n state = self.move_base.get_state()\n\n self.counter +=1\n if(self.counter>6 or state==3):\n rospy.logdebug(\"-------------------------\")\n rospy.logdebug(\"Recalculate Frontriers ! \")\n rospy.logdebug(\"-------------------------\")\n\n self.counter = 0\n frontiers_num = self.update()\n\n #break condition\n if frontiers_num==0 :\n rospy.logdebug(\"---------------------------------------\")\n rospy.logdebug(\"---------------------------------------\")\n rospy.logdebug(\"NO FRONTIERS FOUND EXPLORATION COMPLETE\")\n rospy.logdebug(\"---------------------------------------\")\n rospy.logdebug(\"---------------------------------------\")\n break\n\n\n\n rate.sleep()","def update_to_state(self, game_state):\n pass"],"string":"[\n \"def reset(self):\\r\\n self.player_hand.reset()\\r\\n self.dealer_hand.reset()\\r\\n self.player_hand.add(self.deck.deal())\\r\\n self.player_hand.add(self.deck.deal())\\r\\n self.dealer_hand.add(self.deck.deal())\\r\\n self.dealer_hand.add(self.deck.deal())\\r\\n # Checking for edge cases where player/dealer (or both) have two aces\\r\\n if self.player_hand.total == 22 and self.dealer_hand.total == 22:\\r\\n self.status_color = 'red'\\r\\n self.game_status = \\\"TIE Game... Press 'r' to start game\\\"\\r\\n self.in_progress = False\\r\\n elif self.player_hand.total == 22:\\r\\n self.status_color = 'red'\\r\\n self.game_status = \\\"Dealer WINS... Press 'r' to start game\\\"\\r\\n self.dealer_wins += 1\\r\\n self.in_progress = False\\r\\n elif self.dealer_hand.total == 22:\\r\\n self.status_color = 'red'\\r\\n self.game_status = \\\"Player WINS... Press 'r' to start game\\\"\\r\\n self.player_wins += 1\\r\\n self.in_progress = False\\r\\n else:\\r\\n self.game_status = 'In Progress...'\\r\\n self.status_color = 'green'\\r\\n self.in_progress = True\\r\\n self.refresh_canvas()\",\n \"def reset(self):\\n self.game_status = game_status.GameStatus(copy.deepcopy(self.initial_rosters),\\n self.game_status.game_date)\\n self._current_event_ndx = 0\",\n \"def run_logic(self):\\n if not self.game_over:\\n # Move all the sprites\\n self.all_sprites_list.update()\",\n \"def reset_continued(self): \\n self._recent_goal_continued = False\\n self._update_action = False\\n self._update_action_without_pause = False\",\n \"def refresh_statuses(self):\\n if self.skill_tree_displaying:\\n return\\n _, self.buff_rects, self.debuff_rects = player_panel_renderer.draw_status(self.player_dict['status']['buffs'],\\n self.player_dict['status']['debuffs'],\\n refresh=True)\",\n \"def update_all_states(self):\\n \\n for l in range(0,4):\\n temp_s = \\\"/loop/{}/mode\\\".format(l+1) # stupid using loop 1 to 4\\n temp_m = self.loop_modes[self.loop_states[l]]\\n self.osc_client.send_message(temp_s,temp_m)\\n print(\\\"sent_message {} {}\\\".format(temp_s,temp_m))\\n self.set_loop_led(l)\\n \\n for l in range(0,4):\\n for s in range(0,8):\\n temp_s = self.osc_slice_string.format(l+1,s)\\n temp_m = self.slice_modes[self.slice_states[l][s] ]\\n self.osc_client.send_message(temp_s,temp_m)\\n print(\\\"sent message {} {}\\\".format(temp_s, temp_m))\\n self.set_slice_led(l,s)\\n return\",\n \"def run_game(self):\\n while True:\\n self._check_events() # check event listener\\n \\n if self.stats.game_active:\\n self.ship.update() # update position\\n # self.bullets.update() # will update each sprite in the group\\n self._update_bullets() \\n self._update_aliens()\\n\\n# self.laser.update()\\n self._update_screen() # refresh screen\",\n \"def reset_status(self):\\r\\n self.ship_left = self.ai_settings.ship_limit\\r\\n self.score = 0\\r\\n self.level = 1\",\n \"def _to_client_update_state(self):\\n start_ticks = pygame.time.get_ticks()\\n\\n clock = pygame.time.Clock()\\n while not self._exit_request:\\n if self._paused:\\n data = {}\\n data[\\\"message_type\\\"] = \\\"state\\\"\\n data[\\\"state\\\"] = self._state\\n data[\\\"session_index\\\"] = self._current_session_index\\n data[\\\"timer\\\"] = int(self._counter_target - self._counter + 1.0)\\n\\n _, writable, exceptional = select([], self._to_client_connections, self._to_client_connections, 0)\\n for connection in writable:\\n try:\\n send(connection, data)\\n except:\\n print(\\\"Connection closed\\\")\\n connection.close()\\n self._to_client_connections.remove(connection)\\n \\n for connection in exceptional:\\n connection.close()\\n self._to_client_connections.remove(connection)\\n\\n start_ticks = pygame.time.get_ticks()\\n clock.tick(10)\\n continue\\n\\n seconds = (pygame.time.get_ticks() - start_ticks)/1000.0\\n\\n if self._counter > self._counter_target:\\n self._current_session_index += 1\\n\\n if self._current_session_index >= len(cfg.SESSION):\\n self._exit_request = True\\n break\\n\\n self._counter_target = cfg.SECONDS_PER_SESSION[self._current_session_index]\\n self._counter = 0.0\\n start_ticks = pygame.time.get_ticks()\\n\\n elif seconds >= self._counter:\\n self._counter += 1.0\\n\\n data = {}\\n data[\\\"message_type\\\"] = \\\"state\\\"\\n data[\\\"state\\\"] = self._state\\n data[\\\"session_index\\\"] = self._current_session_index\\n data[\\\"timer\\\"] = int(self._counter_target - self._counter + 1.0)\\n\\n # Record state of the game\\n self._csv_writer.writerow([time(), json.dumps(data)])\\n\\n _, writable, exceptional = select([], self._to_client_connections, self._to_client_connections, 0)\\n for connection in writable:\\n try:\\n send(connection, data)\\n except:\\n print(\\\"Connection closed\\\")\\n connection.close()\\n self._to_client_connections.remove(connection)\\n \\n for connection in exceptional:\\n connection.close()\\n self._to_client_connections.remove(connection)\\n \\n clock.tick(60)\\n\\n while self._to_client_connections:\\n _, writable, exceptional = select([], self._to_client_connections, self._to_client_connections)\\n\\n for connection in writable:\\n data = {}\\n data[\\\"message_type\\\"] = \\\"command\\\"\\n data[\\\"message\\\"] = \\\"CLOSE\\\"\\n\\n try:\\n send(connection, data)\\n except BrokenPipeError:\\n print(\\\"Connection closed\\\")\\n\\n connection.close()\\n self._to_client_connections.remove(connection)\\n \\n for connection in exceptional:\\n connection.close()\\n self._to_client_connections.remove(connection)\\n \\n clock.tick(60)\",\n \"def round_reset(self):\\n\\t\\tfor p in self.players: p.reset_state()\\n\\t\\t#self.player = player(self.player.name, self.player.cards)\\n\\t\\tself.small_blind.money -= self.blind // 2\\n\\t\\tself.small_blind.stake += self.blind // 2\\n\\t\\tself.big_blind.money -= self.blind\\n\\t\\tself.big_blind.stake += self.blind\\n\\t\\tself.last_bet_by = self.big_blind\\n\\t\\tself.bank = self.blind\\n\\t\\tself.bank_part = self.blind\\n\\t\\tself.table_cards = []\\n\\t\\tself.stage = stages.nocards\",\n \"def update(delta_time):\\n for event in coda.event.listing():\\n if coda.event.quit_game(event):\\n coda.stop()\\n if coda.event.mouse_l_button_down(event):\\n if MY.restart_button.collides_with_point(coda.event.mouse_position()):\\n coda.state.change(0)\",\n \"def update(self):\\n self.active = False\\n self.top.update(self.rgb,self.cmyk,self.hsv)\\n self.bot.update(self.rgb,self.cmyk,self.hsv)\\n self.active = True\",\n \"def update_status_bars():\\n for status_bar_name in init.game_state.status_bars.keys():\\n gradual_status_bar_fluctuation(status_bar_name)\",\n \"def update(self):\\r\\n if not self.tr.game_over and self.tr.turn_tracker:\\r\\n self.computer_play()\",\n \"def reset_game():\\n global x_pos, o_pos, frames, count\\n\\n count = 0\\n x_pos = []\\n o_pos = []\\n result.set(\\\"Your Turn!\\\")\\n for x in frames:\\n for y in x.winfo_children():\\n y.config(text=\\\" \\\", state='normal')\",\n \"def reset_game(self):\\n self.bHasWon = False\\n self.game_over = False\\n self.game_active = False\\n self.player_points = 0\\n self.enemy_points = 0\\n self.remainingBalls = 0\",\n \"def clearMyStatus(self):\\n self.maxBattery = 0\\n self.currentPower = 0\\n self.thrust = 0.0\\n self.rotation = 0.0\\n self.radar = 0\\n self.jamming = 0\\n self.repair = 0\\n self.mass = 0.0\\n self.accel = 0.0\\n self.maxAssault = 0\\n self.assaultStrength = 0\",\n \"async def status_update_loop(self):\\n self.status_message_update_waiter = sleep(UPDATE_INTERVAL, KOKORO)\\n \\n while self.state == CHANNEL_MOVE_STATE_NONE:\\n set_value = await self.status_message_update_waiter\\n # sleep sets by `None`\\n if set_value is not None:\\n break\\n \\n self.status_message_update_waiter = sleep(UPDATE_INTERVAL, KOKORO)\\n await self.update_status_message()\\n continue\\n \\n await self.update_status_message()\\n await self.send_done_notification()\\n return\",\n \"def update_game(game, episode, buttons,run_status):\\n\\n game_round = game.round\\n if game_round == 'newround':\\n newround(game)\\n print(game_round)\\n game.round = 'preflop'\\n print(game.round)\\n\\n\\n return 'go'\\n elif game_round == 'preflop':\\n check = preflop(game, episode, buttons)\\n if check == True:\\n game.round = 'flop'\\n return 'go'\\n elif check == False:\\n game.round = 'showdown'\\n print(game.round)\\n return 'go'\\n elif check == 'no input':\\n game.round = 'preflop'\\n return 'stop'\\n return 'stop'\\n elif game_round == 'flop':\\n check = flop(game, episode, buttons, run_status)\\n if check == True:\\n game.round = 'turn'\\n return 'go'\\n elif check == False:\\n game.round = 'showdown'\\n return 'go'\\n elif check == 'no input':\\n game.round = 'flop'\\n return 'stop'\\n return 'stop'\\n pass\\n elif game_round == 'turn':\\n check = turn(game, episode, buttons, run_status)\\n if check == True:\\n game.round = 'river'\\n return 'go'\\n elif check == False:\\n game.round = 'showdown'\\n return 'go'\\n elif check == 'no input':\\n game.round = 'turn'\\n return 'stop'\\n return 'stop'\\n elif game_round == 'river':\\n check = turn(game, episode, buttons, run_status)\\n if check == True:\\n game.round = 'showdown'\\n return 'go'\\n elif check == False:\\n game.round = 'showdown'\\n return 'go'\\n elif check == 'no input':\\n game.round = 'river'\\n return 'stop'\\n return 'stop'\\n elif game_round == 'showdown':\\n showdown(game, episode)\\n #game.player1.wager = 100\\n #game.player2.wager = 50\\n # game.update_tablepot()\\n game.round = 'newround'\\n return 'go'\\n pass\",\n \"def main_loop(self):\\n while self.game_manager.game_state != GameState.Quit:\\n\\n self.handle_events()\\n self.handle_ui_response()\\n #in menu\\n if self.game_manager.game_state == GameState.Menu: \\n self.display.clear()\\n\\n #in game\\n elif self.game_manager.game_state == GameState.Running:\\n self.game_manager.move_players()\\n\\n #after game\\n elif self.game_manager.game_state == GameState.Finished:\\n if self.game_manager.winner == None:\\n self.game_manager.player1.decay()\\n self.game_manager.player2.decay() \\n else:\\n self.game_manager.loser.decay()\\n self.game_manager.loser.draw()\\n\\n #perform game manager actions\\n self.game_manager.act()\\n #do all the rendering stuff\\n self.render_scene()\\n #control FPS\\n self.clock.tick(self.FPS)\",\n \"def run_game(self):\\n\\t\\twhile True:\\n\\t\\t\\tself._check_event()\\n\\t\\t\\tself.ship.update()\\n\\t\\t\\tself._update_bullets()\\n\\t\\t\\tself._update_aliens()\\n\\t\\t\\tself._update_screen()\",\n \"def process_game_logic(self):\\n self.dmod = -1\\n self.smod = -1\\n if self.state == self.STATE_SETUP:\\n if self.current_game < self.config['General']['games_per_session']:\\n self.current_game += 1\\n self.state = self.STATE_GAMENO\\n self.game_title = \\\"Game: %d of %d\\\" % (self.current_game, self.config['General']['games_per_session'])\\n self.game_title = pygl2d.font.RenderText(self.game_title, (255, 255, 0), self.f36)\\n self.game_title_rect = self.game_title.get_rect()\\n self.game_title_rect.center = (self.SCREEN_WIDTH / 2, self.SCREEN_HEIGHT / 16 * 7)\\n self.gameevents.add(\\\"display_game\\\", self.current_game)\\n else:\\n self.state = self.STATE_DONE\\n self.ret = 0\\n self.lc.stop()\\n elif self.state == self.STATE_SETUP_IFF:\\n self.mine_list.generate_foes()\\n self.gameevents.add(\\\"display_foes\\\", \\\" \\\".join(self.mine_list.foe_letters), \\\"player\\\")\\n self.foe_top = pygl2d.font.RenderText(\\\"The Type-2 mines for this session are:\\\", (255, 255, 0), self.f24)\\n self.foe_top_rect = self.foe_top.get_rect()\\n self.foe_top_rect.center = (self.SCREEN_WIDTH / 2, 270 * self.aspect_ratio)\\n self.foe_middle = pygl2d.font.RenderText(\\\", \\\".join(self.mine_list.foe_letters), (255, 255, 255), self.f96)\\n self.foe_middle_rect = self.foe_middle.get_rect()\\n self.foe_middle_rect.center = (self.SCREEN_WIDTH / 2, self.SCREEN_HEIGHT / 2)\\n self.foe_midbot = pygl2d.font.RenderText(\\\"Try to memorize them before proceeding\\\", (255, 255, 0), self.f24)\\n self.foe_midbot_rect = self.foe_midbot.get_rect()\\n self.foe_midbot_rect.center = (self.SCREEN_WIDTH / 2, 500 * self.aspect_ratio)\\n self.foe_bottom = pygl2d.font.RenderText(\\\"Press return to begin\\\", (255, 255, 0), self.f24)\\n self.foe_bottom_rect = self.foe_bottom.get_rect()\\n self.foe_bottom_rect.center = (self.SCREEN_WIDTH / 2, 600 * self.aspect_ratio)\\n self.state = self.STATE_IFF\\n elif self.state == self.STATE_PREPARE:\\n self.gameevents.add(\\\"game\\\", \\\"ready\\\", type='EVENT_SYSTEM')\\n self.setup_world()\\n self.state = self.STATE_PLAY\\n self.gameevents.add(\\\"game\\\", \\\"start\\\", type='EVENT_SYSTEM')\\n elif self.state == self.STATE_PLAY:\\n self.ship.compute()\\n if not self.ship.jumped:\\n\\n overlay = np.zeros((int(self.world.bottom-self.world.top),int(self.world.right-self.world.left),3),np.uint8)\\n\\n\\n cv2.line(overlay,(int(self.ship.position.x-self.world.left),int(self.ship.position.y-self.world.top)),(int(self.ship.oldPosx-self.world.left),int(self.ship.oldPosy-self.world.top)),(255,255,255),self.config['Playback']['line_width'])\\n\\n cv2.addWeighted(overlay,self.config['Playback']['intensity']/100.0,self.img,1.0,0,self.img)\\n\\n distance = self.ship.get_distance_to_point(self.WORLD_WIDTH / 2, self.WORLD_HEIGHT / 2)\\n flight_max_inc = self.config['Score']['flight_max_increment']\\n dmod = 1 - (distance - self.smallhex.radius * 1.125) / (self.WORLD_WIDTH / 2)\\n if dmod > 1.0: dmod = 1.0\\n if dmod < 0.0: dmod = 0.0\\n smod = max([abs(self.ship.velocity.x), abs(self.ship.velocity.y)]) / self.ship.max_vel\\n self.dmod = dmod\\n self.smod = smod\\n for missile in self.missile_list:\\n missile.compute()\\n if self.fortress_exists == True:\\n self.fortress.compute()\\n for shell in self.shell_list:\\n shell.compute()\\n if self.config['Hexagon']['hex_shrink']:\\n self.bighex.compute()\\n if self.mine_exists:\\n if self.mine_list.flag == False and self.mine_list.timer.elapsed() > self.mine_list.spawn_time:\\n self.gameevents.add(\\\"spawn\\\", \\\"mine\\\")\\n elif self.mine_list.flag and self.mine_list.timer.elapsed() > self.mine_list.timeout:\\n self.gameevents.add(\\\"timeout\\\", \\\"mine\\\")\\n self.mine_list.compute()\\n self.check_bounds()\\n #test collisions to generate game events\\n self.test_collisions()\\n if self.flighttimer.elapsed() > self.config['Score']['update_timer']:\\n self.flighttimer.reset()\\n def pointspace (a0, a1, a2, b0, b1, b2): return math.exp(a1 ** (a0 * a2)) * math.exp(b1 ** (b0 * b2))\\n points = flight_max_inc * pointspace(self.dmod, 2, 1, self.smod, 2, 1.75) / pointspace(1, 2, 1, 1, 2, 1.75)\\n self.gameevents.add(\\\"score+\\\", \\\"flight\\\", points)\\n self.flight2 += flight_max_inc * pointspace(self.dmod, 2, .45, self.smod, 2, 1) / pointspace(1, 2, .45, 1, 2, 1)\\n if (self.ship.velocity.x ** 2 + self.ship.velocity.y ** 2) ** 0.5 < self.config['Score']['speed_threshold']:\\n self.gameevents.add(\\\"score+\\\", \\\"vlcty\\\", self.config['Score']['VLCTY_increment'])\\n #self.gameevents.add(\\\"score+\\\", \\\"flight\\\", self.config['Score']['VLCTY_increment'])\\n else:\\n self.gameevents.add(\\\"score-\\\", \\\"vlcty\\\", self.config['Score']['VLCTY_increment'])\\n #self.gameevents.add(\\\"score-\\\", \\\"flight\\\", self.config['Score']['VLCTY_increment'])\\n if self.bighex.collide(self.ship):\\n self.gameevents.add(\\\"score+\\\", \\\"cntrl\\\", self.config['Score']['CNTRL_increment'])\\n #self.gameevents.add(\\\"score+\\\", \\\"flight\\\", self.config['Score']['CNTRL_increment'])\\n else:\\n self.gameevents.add(\\\"score+\\\", \\\"cntrl\\\", self.config['Score']['CNTRL_increment'] / 2)\\n #self.gameevents.add(\\\"score+\\\", \\\"flight\\\", self.config['Score']['CNTRL_increment']/2)\\n if self.bonus_exists:\\n if self.config['General']['bonus_system'] == \\\"AX-CPT\\\":\\n self.bonus.axcpt_update()\\n else:\\n if self.bonus.visible == False and self.bonus.timer.elapsed() > self.config['Bonus']['symbol_down_time']:\\n self.gameevents.add(\\\"activate\\\", \\\"bonus\\\")\\n elif self.bonus.visible == True and self.bonus.timer.elapsed() >= self.config['Bonus']['symbol_up_time']:\\n self.gameevents.add(\\\"deactivate\\\", \\\"bonus\\\", self.bonus.current_symbol)\\n #update scores\\n self.score.pnts = self.score.__getattribute__(\\\"pnts\\\")\\n self.score.vlcty = self.score.__getattribute__(\\\"vlcty\\\")\\n self.score.cntrl = self.score.__getattribute__(\\\"cntrl\\\")\\n self.score.speed = self.score.__getattribute__(\\\"speed\\\")\\n self.score.flight = self.score.__getattribute__(\\\"flight\\\")\\n self.score.fortress = self.score.__getattribute__(\\\"fortress\\\")\\n self.score.mines = self.score.__getattribute__(\\\"mines\\\")\\n self.score.bonus = self.score.__getattribute__(\\\"bonus\\\")\\n\\n if self.gametimer.elapsed() > self.config['General']['game_time']:\\n self.gameevents.add(\\\"game\\\", \\\"over\\\", type='EVENT_SYSTEM')\\n self.state = self.STATE_SCORES\\n self.img = 255-self.img\\n now = datetime.datetime.now()\\n cv2.imwrite('../Recordings/' + str(now.year) + \\\"_\\\"+str(now.month)+\\\"_\\\" + str(now.day) + \\\"_\\\" + str(now.hour) + \\\"_\\\" + str(now.minute)+\\\"_\\\" + 'lines.jpg',(self.img),[int(cv2.IMWRITE_JPEG_QUALITY), 100])\",\n \"def run_game(self):\\n # redraw the screen during each pass thought the loop and Set the background color from settings.py.\\n\\n while True:\\n self._check_events()\\n self.ship.update(self.time_delta)\\n self.bullets.update(self.time_delta)\\n self._update_bullets()\\n self._update_screen()\",\n \"def update_screen(ai_settings,grid, screen, buttons, screen_status, button_status, card_database_filter, user,action, player2):\\n screen.fill((250,250,250))\\n # Theme filter\\n if ai_settings.theme_indicator == 'Lith Harbor':\\n screen.blit(pygame.image.load('static/bg_images/bg_02.png'), (0,0))\\n elif ai_settings.theme_indicator == 'Leafre':\\n screen.blit(pygame.image.load('static/bg_images/bg_05.jpg'), (0,0))\\n elif ai_settings.theme_indicator == 'Pantheon':\\n screen.blit(pygame.image.load('static/bg_images/bg_06.png'), (0,0))\\n elif ai_settings.theme_indicator == 'Ellinia':\\n screen.blit(pygame.image.load('static/bg_images/bg_04.jpeg'), (0,0))\\n\\n if button_status.lobby_screen_game_start == True:\\n if screen_status.lobby_screen_display == True and screen_status.battle_screen_display == False:\\n screen_status.lobby_screen_display = False\\n screen_status.battle_screen_display = True\\n\\n if screen_status.welcome_screen_display:\\n welcome_screen_update(ai_settings,screen, buttons, screen_status, button_status)\\n\\n if screen_status.lobby_screen_display:\\n lobby_screen_update(ai_settings,grid, screen, buttons, screen_status, button_status, card_database_filter, user,action, player2)\\n\\n if screen_status.prepare_screen_display:\\n prepare_screen_update(ai_settings,grid, screen, buttons, screen_status, button_status, card_database_filter, user, player2)\\n\\n if screen_status.build_deck_screen_display:\\n build_deck_screen_update(ai_settings, grid, screen, buttons, screen_status, button_status, card_database_filter, user)\\n\\n if screen_status.battle_screen_display:\\n battle_screen_update(ai_settings,grid, screen, buttons, screen_status, button_status, card_database_filter, user, player2)\\n\\n # Display zoom in affect at the end to cover previous draw when zoom in\\n card_zoom_update(ai_settings, screen, buttons,screen_status, button_status, card_database_filter, user, player2)\\n\\n #Rules display\\n rules_display(ai_settings, screen, buttons,screen_status, button_status, card_database_filter, user, player2)\\n\\n #Text input box display\\n text_input_box_display(ai_settings, screen, buttons,screen_status, button_status, card_database_filter, user, player2)\\n\\n # music volume\\n if ai_settings.music_indicator == True:\\n pygame.mixer.music.set_volume(1.0)\\n else:\\n pygame.mixer.music.set_volume(0)\\n\\n pygame.display.flip()\",\n \"def update(self):\\n if self.account and OPTION.COMET in self.account.options:\\n if self.get_conn().get_browser() not in IFRAME_BROWSERS:\\n self.game_request.write(OUTPUT_END_TAG)\\n self.seconds_played += 1\\n self.inactivity += 1\\n\\n if FLAG.INGESTED in self.flags:\\n return\\n\\n pass\",\n \"def update(self):\\n if pygame.time.get_ticks() - self.start_time > const.LEVEL_WAITING:\\n self.player.update()\\n self.platform_list.update()\\n self.platform_grass_list.update()\\n self.platform_stone_list.update()\\n self.enemy_list.update()\\n self.bullet_list.update()\\n self.active_sprite.update()\\n self.enemy_bubble_list.update()\\n self.fruit_list.update()\\n for bullet in self.bullet_list:\\n if bullet.rect.x > const.SCREEN_WIDTH + 10 or bullet.rect.x < -10:\\n self.bullet_list.remove(bullet)\\n self.active_sprite.remove(bullet)\\n\\n\\n for guy in self.enemy_list:\\n enemy_hit_list = pygame.sprite.spritecollide(guy, self.bullet_list, False, pygame.sprite.collide_circle)\\n for hit in enemy_hit_list:\\n bub_enemy= enemy.Enemy_bubble(guy)\\n self.enemy_list.remove(guy)\\n\\n self.bullet_list.remove(hit)\\n self.active_sprite.add(bub_enemy)\\n self.active_sprite.remove(hit)\\n self.active_sprite.remove(guy)\\n\\n self.enemy_bubble_list.add(bub_enemy)\\n\\n\\n if len(self.enemy_list) == 0 and len(self.enemy_bubble_list) == 0 and self.close_time == 0:\\n self.close_time=pygame.time.get_ticks()\\n\\n if self.close_time > 0 and pygame.time.get_ticks()-self.close_time > 2000:\\n self.close = True\",\n \"def on_update(self):\\n \\n # update physics engine\\n \\n \\n # use code from pick up coins lab to pick up coins\\n # you don't need all of the code from that lab(no gameover or reset)\",\n \"def GAMEOVER_LOOP():\\n pass\",\n \"def breakout_loop(self):\\n while self.playing:\\n self.handle_events()\\n self.update()\\n if self.game_over:\\n self.current_menu = self.fail_menu\\n self.playing = False\\n self.reset()\\n self.draw()\",\n \"def run_game(self):\\n while True:\\n self._check_events()\\n self._update_rain()\\n self._update_screen()\",\n \"def run_game(self):\\n while True:\\n self._check_events()\\n\\n if self.stats.game_active:\\n self.ship.update()\\n self._update_bullet()\\n self._update_aliens()\\n \\n self._update_screen()\",\n \"def updateComplete(self):\\n self.livesScreen()\\n if self.getWave().getLives() == 0:\\n self.deathScreen()\\n else:\\n self.winScreen()\",\n \"def update(self):\\n self.wall_list.update()\\n self.enemy_list.update()\\n self.sludge.update()\\n self.consumeable.update()\\n self.can_climb.update()\",\n \"def reset_stage_move_counters(self):\\n self.total_xyz_move_counter = [[0, 0, 0], [0, 0, 0], [0, 0]]\\n self.failed_xyz_move_counter = [0, 0, 0]\\n self.slow_xy_move_counter = 0\\n self.slow_xy_move_warnings.clear()\\n self.failed_x_move_warnings.clear()\\n self.failed_y_move_warnings.clear()\\n self.failed_z_move_warnings.clear()\",\n \"def update_state_game_variables(self):\\n self.model.numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8]\\n self.model.player_mark = \\\"\\\"\\n self.model.player_move = 0\\n self.model.boards = [\\\"board\\\"] * 9\\n self.update_score_board()\",\n \"def update(self):\\n\\t\\t# If being controlled by COM\\n\\t\\tif self.controled_by_com :\\n\\t\\t\\t# Substract 1 from the update counter\\n\\t\\t\\tself.update_counter -= 1\\n\\t\\t\\t# If the update counter reaches zero\\n\\t\\t\\tif self.update_counter == 0. :\\n\\t\\t\\t\\t# then ask for an action \\n\\t\\t\\t\\tif self.intermediate_phase is False :\\n\\t\\t\\t\\t\\tself.action_required = True \\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t# if during a change\\n\\t\\t\\t\\t# then make the change\\n\\t\\t\\t\\tif self.intermediate_phase is True : \\n\\t\\t\\t\\t\\tself.action_required = False\\n\\t\\t\\t\\t\\tself._color_changer() #Make the change in the Simulator\\n\\t\\telse :\\n\\t\\t\\tpass\",\n \"def refresh_all_players(all_players):\\n for player in all_players:\\n player.locked_actions = player.available_actions\\n player.available_actions = []\\n player.hand = CardGroup()\\n player.is_down = False\\n player.buy_count = 0\\n #update screens here to show the locking.\",\n \"def reset_game(self):\\n self._buttons_active = False\\n self._laser_label.clear()\\n self.add_items_labels()\\n self.add_question_marks()\\n QtCore.QTimer.singleShot(conf.second_display_duration,\\n self.enter_phase_two)\",\n \"def reset(self):\\n self.players = [Player(), Player(), Player(), Player()]\\n self.hist = []\\n self.round = 1\\n self.current_player = 0\\n self.first_winner_was = -1\\n self.current_dice = -1\\n self.observation_pending = False\\n self.current_move_pieces = []\\n self.current_enemys = []\\n self.current_start_attempts = 0\\n self.game_winners = []\",\n \"def update_main_game_loop(self):\\n delta_time = self.delta_time()\\n\\n if delta_time >= 1.0 / self.target_fps:\\n self.update_keys(delta_time)\\n for game_object in [g for g in self.game_objects if g.enabled]:\\n game_object.update(delta_time)\\n # end for\\n self.time_node.setAttr('unwarpedTime', self.time_node.getAttr('unwarpedTime') + delta_time * 24)\\n self.time_node.setAttr('outTime', self.time_node.getAttr('outTime') + delta_time * 24)\\n pm.refresh(f=True)\\n else:\\n pm.refresh(f=True)\\n # end if\",\n \"def update_gameclock():\\n global game_ticks\\n ## GOTCHA: Both Ball.update() and Ball.predict() modify sprite\\n ## position, so the update and display routines must each perform\\n ## erasure. This results in redundant erasures whenever an update and\\n ## frame are ready in the same pass. This happens almost every game tick\\n ## at high frame rates, often enough that an avoidance optimization\\n ## would gain a few FPS.\\n sprite_group.clear(screen, eraser_image)\\n sprite_group.update(USE_PREDICTION)\\n handle_collisions()\\n game_ticks += 1\\n if game_ticks >= clock.ticks_per_second:\\n set_caption()\\n game_ticks = 0\",\n \"def run_game(self):\\n while True:\\n self._check_events()\\n if self.stats.game_active:\\n self.ship.update_movement()\\n self._update_bullets()\\n self.special_bullet.update()\\n self._update_stars()\\n \\n self._update_screen()\",\n \"def algo_mover(self):\\n self.tick_count = 0 ## reset to start clock on delayed state change\\n\\n ### Move 1 ring ###\\n de, aux, vers = self.instructions.pop(0)\\n\\n de = self.rods[de]\\n aux = self.rods[aux]\\n vers = self.rods[vers]\\n\\n ring = de.pop_ring()\\n vers.add_ring(ring)\\n\\n ### Update the states after -- moved this to main update\\n #self.state_updater()\",\n \"def update():\\n # Initialization (only runs on start/restart)\\n player1 = Player()\\n player2 = Player()\\n\\n walls, start = parse_level(LEVEL)\\n\\n player1.idx = 1\\n player1.key_up = \\\"w\\\"\\n player1.key_down = \\\"s\\\"\\n player1.key_left = \\\"a\\\"\\n player1.key_right = \\\"d\\\"\\n player1.key_small = \\\"f\\\"\\n player1.key_shoot = \\\"c\\\"\\n\\n player2.idx = 2\\n player2.key_up = \\\"i\\\"\\n player2.key_down = \\\"k\\\"\\n player2.key_left = \\\"j\\\"\\n player2.key_right = \\\"l\\\"\\n player2.key_small = \\\"h\\\"\\n player2.key_shoot = \\\"n\\\"\\n\\n reset_players = True\\n # Main update loop\\n while True:\\n if reset_players:\\n reset_players = False\\n player1.centerx = start[0][0]\\n player1.centery = start[0][1]\\n player2.centerx = start[1][0]\\n player2.centery = start[1][1]\\n shots.clear()\\n\\n update_player(player1, delta())\\n update_player(player2, delta())\\n\\n to_remove = []\\n for shot in shots:\\n if not update_shot(shot, delta()):\\n to_remove.append(shot)\\n for shot in to_remove:\\n shots.remove(shot)\\n\\n draw_player(player1)\\n draw_player(player2)\\n for shot in shots:\\n draw_shot(shot)\\n\\n for shot in shots:\\n for other in shots:\\n if shot.shooter_idx != other.shooter_idx:\\n _, depth = overlap_data(shot, other)\\n if depth > 0:\\n to_remove.append(shot)\\n for player in (player1, player2):\\n _, depth = overlap_data(player, shot)\\n if depth > 0 and player.idx != shot.shooter_idx:\\n print(f\\\"{player.idx} ded by {shot.shooter_idx}\\\")\\n reset_players = True\\n for shot in to_remove:\\n shots.remove(shot)\\n\\n for wall in walls:\\n window = pg.display.get_surface()\\n pg.draw.rect(window, pg.Color(100, 100, 100), wall)\\n for player in (player1, player2):\\n player.velocity, wall_vel, overlap = solve_rect_overlap(player,\\n wall,\\n player.velocity,\\n mass_b=0,\\n bounce=0.1)\\n\\n # Main loop ends here, put your code above this line\\n yield\",\n \"def apply_status(\\n player1: Player, player2: Player, rules: dict, message: List[str]\\n) -> Tuple[Player, Player, dict, List[str]]:\\n if player1.status_effects:\\n status_effects = copy.copy(player1.status_effects)\\n offset = 0\\n for i, status_effect in enumerate(status_effects):\\n # Apply the status effect\\n player1, player2, rules = getattr(\\n combat_effects, \\\"apply_\\\" + status_effect[0]\\n )(self=player1, target=player2, rules=rules, left=True)\\n message.append(f\\\"Applied effects of {status_effect[0]} to {player1.name}\\\")\\n\\n # Decrease the duration of this status effect, which is a list like this:\\n # ['name_of_status', duration], so we index to 1 to get duration\\n status_effect[1] -= 1\\n\\n # Remove status effect if duration is 0\\n if status_effect[1] == 0:\\n print(f\\\"\\\\n{i} {offset} Deleting {status_effect[0]} from entry {i-offset}\\\"\\n f\\\" in {player1.status_effects}\\\")\\n del player1.status_effects[i - offset]\\n offset += 1\\n\\n if player2.status_effects:\\n status_effects = copy.copy(player2.status_effects)\\n offset = 0\\n for i, status_effect in enumerate(status_effects):\\n # Apply the status effect\\n player2, player1, rules = getattr(\\n combat_effects, \\\"apply_\\\" + status_effect[0]\\n )(self=player2, target=player1, rules=rules, left=False)\\n message.append(f\\\"Applied effects of {status_effect[0]} to {player2.name}\\\")\\n\\n # Decrease the duration of this status effect, which is a list like this:\\n # ['name_of_status', duration], so we index to 1 to get duration\\n status_effect[1] -= 1\\n\\n # Remove status effect if duration is 0\\n if status_effect[1] == 0:\\n print(f\\\"{i} Deleting {status_effect[0]} from first entry in\\\"\\n f\\\" {player2.status_effects}, offset={offset}\\\")\\n del player2.status_effects[i - offset]\\n offset += 1\\n\\n return player1, player2, rules, message\",\n \"def status(self) -> NoReturn:\\n\\n curr_status= self.percent_done()\\n while(curr_status < 100):\\n\\n update_status(name=self.name, status=curr_status)\\n time.sleep(0.5)\\n\\n curr_status = self.percent_done()\\n\\n update_status(name=self.name, status=curr_status)\",\n \"def setPlayerStates(self, updates):\\r\\n for upd in updates:\\r\\n print \\\"UPD player %s\\\" % upd['player']\\r\\n player = self.players[upd['player']]\\r\\n player.setStatus(upd['status'], upd['jump'], upd['charge'])\\r\\n\\r\\n player.health = upd['health']\\r\\n if player == self.myPlayer:\\r\\n #self.healthbar.setValue(self.myPlayer.health)\\r\\n pass\",\n \"async def countdown_status(bot: commands.Bot) -> None:\\n while is_in_advent():\\n _, time_left = time_left_to_aoc_midnight()\\n\\n aligned_seconds = int(math.ceil(time_left.seconds / COUNTDOWN_STEP)) * COUNTDOWN_STEP\\n hours, minutes = aligned_seconds // 3600, aligned_seconds // 60 % 60\\n\\n if aligned_seconds == 0:\\n playing = f\\\"right now!\\\"\\n elif aligned_seconds == COUNTDOWN_STEP:\\n playing = f\\\"in less than {minutes} minutes\\\"\\n elif hours == 0:\\n playing = f\\\"in {minutes} minutes\\\"\\n elif hours == 23:\\n playing = f\\\"since {60 - minutes} minutes ago\\\"\\n else:\\n playing = f\\\"in {hours} hours and {minutes} minutes\\\"\\n\\n # Status will look like \\\"Playing in 5 hours and 30 minutes\\\"\\n await bot.change_presence(activity=discord.Game(playing))\\n\\n # Sleep until next aligned time or a full step if already aligned\\n delay = time_left.seconds % COUNTDOWN_STEP or COUNTDOWN_STEP\\n await asyncio.sleep(delay)\",\n \"def game_updated(self):\\n # <<-- Creer-Merge: game-updated -->> - Code you add between this comment and the end comment will be preserved between Creer re-runs.\\n game = self.game\\n\\n for x in range(game.board_width):\\n for y in range(game.board_height):\\n self.checkers_map[x][y] = None\\n\\n self.force_checker = None\\n self.cant_move = False\\n for checker in game.checkers:\\n self.checkers_map[checker.x][checker.y] = checker\\n if checker.owner is self.player and checker is game.checker_moved:\\n if game.checker_moved_jumped:\\n self.force_checker = checker\\n else:\\n self.cant_move = True\\n # <<-- /Creer-Merge: game-updated -->>\",\n \"def _countdown(self):\\n self._game.deleteBall()\\n self._game.draw()\\n # reset paddle speed\\n self._game.updatePaddle(self.input)\\n if ZERO_SECS <= self.time < ONE_SEC:\\n self._mssg = (GLabel(text='3', x=GAME_WIDTH/2, y=GAME_HEIGHT/2,\\n font_size=COUNTDOWN_FONT_SIZE))\\n if ONE_SEC <= self.time < TWO_SECS:\\n self._mssg = (GLabel(text='2', x=GAME_WIDTH/2, y=GAME_HEIGHT/2,\\n font_size=COUNTDOWN_FONT_SIZE))\\n if TWO_SECS <= self.time < THREE_SECS:\\n self._mssg = (GLabel(text='1', x=GAME_WIDTH/2, y=GAME_HEIGHT/2,\\n font_size=COUNTDOWN_FONT_SIZE))\\n if self.time >= THREE_SECS:\\n self._mssg = None\\n self._game.serveBall()\\n self._state = STATE_ACTIVE\\n self._points_mssg = (GLabel(text='Points: 0', x=POINTS_X, y=POINTS_Y, font_size=24))\",\n \"def update(self):\\n self.platform_list.update()\\n self.exit_sprite.update()\\n self.bagGroup.update()\\n self.enemy_list.update()\",\n \"def clear_game_moves(self):\\r\\n self.prev_message = None\\r\\n self.play_moves = []\",\n \"def _run_one_game(self):\\n sum_reward = 0\\n done = False\\n state = torch.tensor(self.env.reset(), device=device).view(1, -1)\\n losses = list()\\n\\n while not done:\\n\\n # Choose action in function of observation and play it\\n action = self._select_action(state)\\n next_state, reward, done, _ = self.env.step(action.item())\\n\\n sum_reward += reward\\n next_state = torch.tensor(next_state, device=device).view(1, -1)\\n reward = torch.tensor([reward], device=device)\\n done = torch.tensor([done], device=device)\\n \\n # Add transition to memory\\n self._add_to_memory(state, action, next_state, reward, done)\\n\\n # Compute loss\\n loss = self._optimize_model()\\n losses += [loss]\\n \\n # Prepare next state\\n state = next_state\\n\\n # Wait time_to_sleep second so the user can view the state\\n sleep(self.time_to_sleep)\\n \\n\\n return sum_reward, mean(losses)\",\n \"def revert_state(self):\\n if self.previous_states > 0: # checks for empty\\n self.update_status(self.previous_states.pop())\",\n \"def correctPending(self):\\n if self.lastPainted:\\n self.doPaint(self.lastPainted[0], self.lastPainted[1], self.colors['idle'], \\\"gray75\\\")\\n self.lastPainted = None\",\n \"def update(self):\\n if self.black + self.white == self.SIZE*self.SIZE:\\n if self.black > self.white:\\n self.gc.black_wins = True\\n elif self.white > self.black:\\n self.gc.white_wins = True\\n else:\\n self.gc.tie = True\\n self.gc.black_num = self.black\\n self.gc.white_num = self.white\",\n \"def reset(self):\\n self.disable()\\n self.shoot_again = False\\n self.balls_added_live = 0\",\n \"def update(self, game):\\n self.lastrect = self.rect\\n # no need to redraw if nothing was updated\\n self.lastmove += 1\\n if not self.is_static:\\n self.physics.passiveMovement(self)\",\n \"def changes(screen):\\r\\n global inventory\\r\\n screen.blit(bg, (0, 0))\\r\\n Sprites.draw(screen)\\r\\n Sprites.update()\\r\\n ammo.draw(screen)\\r\\n ammo.update()\\r\\n prt.check_trying_using()\\r\\n if inventory.count('score {}'.format(id(score_0))) == 0:\\r\\n score_0.pick(inventory, player, Sprites, score)\\r\\n if inventory.count('score {}'.format(id(score_1))) == 0:\\r\\n score_1.pick(inventory, player, Sprites, score)\\r\\n if inventory.count('boost {}'.format(id(sp))) == 0:\\r\\n sp.boost(inventory, player, Sprites)\\r\\n borders(WIDTH, HEIGHT)\\r\\n see_score(score)\\r\\n key_0.pick(inventory, player, Sprites)\\r\\n pygame.display.flip()\",\n \"def GAME_LOOP():\\n pass\",\n \"def manual_update(self):\\n for cb, status in zip(self._manual_cbs, self.status_objs):\\n cb(status)\",\n \"def run_game(self):\\n #create ufos\\n self.creat_fleet_ufos()\\n \\n while True:\\n \\n self._check_events()\\n self.ship.update()\\n #self.ufos.update()\\n self.missiles.update()\\n self._update_screen()\\n self.delete_missiles()\",\n \"def progress_game(self):\\r\\n\\r\\n if self.actions == len(self.players):\\r\\n # Reveal the 3 first cards\\r\\n output_text = \\\"Dealing the flop...\\\"\\r\\n\\r\\n self.new_output.emit(output_text)\\r\\n self.community_cards.flop()\\r\\n\\r\\n if self.actions == 2 * len(self.players):\\r\\n # Reveal a 4th card\\r\\n output_text = \\\"Dealing the turn...\\\"\\r\\n\\r\\n self.new_output.emit(output_text)\\r\\n self.community_cards.turn()\\r\\n\\r\\n if self.actions == 3 * len(self.players):\\r\\n # Reveal a 5th card\\r\\n output_text = \\\"Dealing the river...\\\"\\r\\n\\r\\n self.new_output.emit(output_text)\\r\\n self.community_cards.river()\\r\\n\\r\\n if self.actions == 4 * len(self.players):\\r\\n self.showdown()\",\n \"def update(self):\\n super().update()\\n time_since_start = self.time_since_start() \\n curr_mod = time_since_start%self.game.time_cycle_secs\\n grade = abs(curr_mod - self.game.time_cycle_secs/2) / (self.game.time_cycle_secs/2)\\n color_value = grade*(255-self.game.max_darkness) + self.game.max_darkness\\n for sprite in self.all_sprites:\\n sprite.color = (color_value, color_value, color_value)\",\n \"def game_updated(self):\\n\\n # replace with your game updated logic\\n self.update_board()\",\n \"def events(self):\\n for event in pygame.event.get():\\n if event.type == pygame.QUIT:\\n self.running = False\\n self.sleep_time = 0\\n return\\n\\n if event.type == pygame.MOUSEBUTTONUP:\\n pos = pygame.mouse.get_pos()\\n\\n if self.button.collidepoint(pos):\\n if self.state == \\\"solving\\\":\\n self.state = \\\"stopping\\\"\\n\\n if self.state == \\\"solved\\\":\\n self.state = \\\"waiting\\\"\\n self.puzzle_state = \\\"solving\\\"\\n self.button_text = \\\"Solve!\\\"\\n self.board = self.original_board.copy()\\n\\n elif self.state == \\\"waiting\\\":\\n self.state = \\\"solving\\\"\\n self.button_text = \\\"Stop!\\\"\\n self.button_color = BUTTON_COLOR_STOP\\n\\n isSolved = self.solve()\\n\\n self.button_color = BUTTON_COLOR_SOLVE\\n if isSolved:\\n self.state = \\\"solved\\\"\\n self.button_text = \\\"Clear\\\"\\n self.puzzle_state = \\\"solved\\\"\\n else:\\n if self.state == \\\"stopping\\\":\\n self.state = \\\"waiting\\\"\\n self.button_text = \\\"Solve!\\\"\\n self.puzzle_state = \\\"solving\\\"\\n else:\\n self.state = \\\"solved\\\"\\n self.button_text = \\\"Clear\\\"\\n self.puzzle_state = \\\"failed\\\"\",\n \"def apply_box_score_events(self):\\n box_score_events = self.game_status.clear_event_buffer()\\n for e in box_score_events:\\n self.players.update(e)\",\n \"def run(self):\\r\\n \\r\\n if not self.gameOver:\\r\\n screen.fill(COLOR3)\\r\\n self.board.drawBoard()\\r\\n self.handleEvents()\\r\\n for piece in self.board.pieces.values():\\r\\n piece.update()\\r\\n else:\\r\\n self.resetGame()\\r\\n pygame.display.update()\",\n \"def _StatusUpdateThreadMain(self):\\n while self._status_update_active:\\n self._UpdateStatus()\\n time.sleep(self._status_update_interval)\",\n \"def updateInt():\\n global running_status\\n running_status = False\\n adc.running_status = False\\n app.logger.warning(\\\"Updating\\\")\\n if os.path.isdir('./temp/'):\\n shutil.rmtree('./temp')\\n git.Repo.clone_from('https://github.com/kgallimo/flask.git', './temp')\\n for f in os.listdir('./temp/'):\\n if os.path.isfile(f) and f is not '.gitignore':\\n app.logger.info(\\\"Moving \\\" + str(f))\\n shutil.move(os.path.join('./temp/', f), os.path.join('./', f))\\n elif os.path.isdir(f) and f is not '.git':\\n app.logger.info(\\\"In directory: \\\" + f)\\n for rf in os.listdir('./temp/' + f):\\n app.logger.info('./temp/' + str(f) + str(rf))\\n if os.path.isfile('./temp/' + f + '/' + rf):\\n app.logger.info(\\\"Moving \\\" + str(rf))\\n shutil.move(os.path.join('./temp/' + f, rf), os.path.join('./' + f, rf))\\n shutil.rmtree('./temp')\\n running_status = True\\n adc.running_status = True\",\n \"def Gameloop():\",\n \"def erase(self):\\n\\tself.state={}\\n\\tself.display(update_board=0)\",\n \"def reset_game(var, wrapper, message):\\n wrapper.send(messages[\\\"fstop_success\\\"].format(wrapper.source))\\n if var.PHASE != \\\"join\\\":\\n stop_game(var, log=False)\\n else:\\n pl = [p for p in get_players() if not p.is_fake]\\n reset_modes_timers(var)\\n reset()\\n if pl:\\n wrapper.send(messages[\\\"fstop_ping\\\"].format(pl))\",\n \"def run_game(self):\\n while True:\\n self._check_events()\\n if self.stats.game_active:\\n self.sideways_ship.update()\\n self._update_bullets()\\n self._update_aliens()\\n self._update_screen()\",\n \"def update_pygame():\\n global elapsed\\n sprite_group.update(False)\\n handle_collisions()\\n elapsed += pygame_clock.get_time()\\n if elapsed >= 1000:\\n set_caption()\\n elapsed -= 1000\",\n \"def run(self):\\n\\t\\t\\n\\t\\twhile self.update():\\n\\t\\t\\tpass\",\n \"def _loop(self):\\n while True:\\n if GameLoop.getInstance()._cancelation_token==True:\\n break\\n self._update_signal.notify_all()\\n sleep(1/60)\",\n \"def warmup():\\n print camera.CoolerOFF()\\n camera.status.update()\",\n \"def logic(self, state):\\n\\n self.pos += self.vel\\n\\n to_remove = set()\\n for script in self.scripts:\\n try:\\n next(script)\\n except StopIteration:\\n to_remove.add(script)\\n self.scripts.difference_update(to_remove)\\n\\n self.state.debug.rectangle(self.rect, self._random_color)\\n self.state.debug.vector(self.vel * 10, self.center, self._random_color)\",\n \"def update(self):\\n events = pygame.event.get()\\n self.plane_update()\\n self.bullet_update(events)\\n self.background_update()\\n self.enemy_update(events)\",\n \"def update(self):\\n if(self.game_on is True and\\n (self.player_turn is True or self.computer_turn is True)):\\n self.board.display()\\n if(self.board.tiles.count == self.SPOT * self.SPOT or\\n self.no_more_move()):\\n self.player_turn = False\\n self.computer_turn = False\\n if(self.no_more_move()):\\n print(\\\"No legal move for both!\\\")\\n print(\\\"Game Over!\\\")\\n if(len(self.board.tiles.blacks) ==\\n len(self.board.tiles.whites)):\\n self.tie = True\\n elif(len(self.board.tiles.blacks) >\\n len(self.board.tiles.whites)):\\n self.black_wins = True\\n elif(len(self.board.tiles.whites) >\\n len(self.board.tiles.blacks)):\\n self.white_wins = True\\n self.winner(len(self.board.tiles.blacks),\\n len(self.board.tiles.whites))\\n elif(self.game_on is False):\\n return\\n elif(self.player_turn is False and self.computer_turn is False):\\n self.make_record()\",\n \"def reset_game(self):\\n self.ships_left = self.settings.ship_limit\\n self.fleets_left = self.settings.fleet_waves\\n self.target_miss = self.settings.target_max_miss\\n self.reset_level()\",\n \"def update(self):\\n\\n # Update guess tracker\\n for i in range(atoms):\\n\\n ident = 'tracker' + str(i + 1)\\n\\n if i < len(game.guesslist):\\n color = scheme.red\\n else:\\n color = scheme.white\\n\\n self.ids[ident].color = color\\n\\n # Update score\\n self.ids.score.text = str(game.score)\\n\\n # Check for end game conditions! Make button (in)visible.\\n if len(game.guesslist) == atoms:\\n self.ids.end_button.disabled = False\\n self.ids.end_button.opacity = 1\\n else:\\n self.ids.end_button.disabled = True\\n self.ids.end_button.opacity = 0\",\n \"def update(self):\\n for player in self.players:\\n player.update()\\n player.last_seen = player.current_cell\\n\\n self.in_cell()\\n for player in self.players:\\n if player.current_cell != player.last_seen:\\n self.player_paths.add(player.last_seen)\\n #If the player has left a cell and moved into another, the vacated cell is\\n #added to the list of cells that have been hit\\n if player.current_cell in self.player_paths:\\n self.players.remove(player)\\n player.alive = False\\n if len(self.players) == 1:\\n self.end_game(self.players[0].name,self.players[0].color)\",\n \"def refresh_status() -> None:\\n ...\",\n \"def run_game(self):\\n while True:\\n self._check_events()\\n\\n if self.stats.game_active:\\n\\n self.ship.update()\\n self._update_bullets()\\n self._update_aliens()\\n self.bullets.update()\\n # Watch for keyboard and mouse events (an event is an action that the user performs while playing the game ).\\n \\n self._update_screen()\",\n \"def run_game(self):\\n while True:\\n self._check_event()\\n self._update_screen()\",\n \"def __reset(self):\\n self.game_moves_history = []\\n self.player_id = None\",\n \"def run(self):\\n while True:\\n if self.game_over: \\n return \\n\\n self.handle_events() \\n if self.paused:\\n continue\\n\\n self.update_generation()\\n self.draw_grid()\\n\\n self.cap_frame_rate()\",\n \"def update(self, delta_time):\\n\\n # Call draw() on all your sprite lists below\\n game = self.game\\n\\n if game.exit:\\n arcade.close_window()\\n \\n if not game.is_running:\\n return\\n\\n # if level has changed redraw walls\\n if self.game.level != self.last_level:\\n self.reset_level()\\n self.last_level = self.game.level\\n\\n if not game.update_game(delta_time):\\n return\",\n \"def goBackInTime(self):\\n if (len(self.history) == 0):\\n return\\n notBusy, notVisible = self.history.pop()\\n for cell in notVisible:\\n for item in cell[0] + cell[1]:\\n self.canvas.delete(item)\\n for x, y in notBusy:\\n self.gridBusy[x][y] = 0\\n self.onBoard -= 1\\n self.refreshScore()\",\n \"def update():\\n global current_level\\n # Initialization (only runs on start/restart)\\n player = Player()\\n\\n walls, goals, start = parse_level(levels[current_level])\\n player.centerx = start[0]\\n player.centery = start[1]\\n\\n # Main update loop\\n while True:\\n update_player(player, delta())\\n draw_player(player)\\n\\n for wall in walls:\\n window = pg.display.get_surface()\\n pg.draw.rect(window, pg.Color(100, 100, 100), wall)\\n\\n player_vel, wall_vel, overlap = solve_rect_overlap(player,\\n wall,\\n player.velocity,\\n mass_b=0,\\n bounce=0.1)\\n player.velocity = player_vel\\n\\n for goal in goals:\\n window = pg.display.get_surface()\\n pg.draw.rect(window, pg.Color(20, 100, 20), goal)\\n\\n normal, depth = overlap_data(player, goal)\\n if depth > 0:\\n current_level = (current_level + 1) % len(levels)\\n restart()\\n\\n draw_text(f\\\"Level: {current_level + 1}\\\", (0, 0))\\n\\n # Main loop ends here, put your code above this line\\n yield\",\n \"def clean(self):\\n self.iiter = 0\\n print(colored('Finished patch %s' % self.image_name, 'yellow'))\\n torch.cuda.empty_cache()\\n self.loss_min = None\\n self.history = u.History(self.args.epochs)\",\n \"def restartGame(self):\\n\\t\\tself.state = [[0 for x in range(3)] for y in range(3)]\\n\\t\\tself.turn = self.whoGoesFirst()\\n\\t\\tself.win = 0\",\n \"def update(self):\\n self.tick()\\n\\n self.ball.update(self)\\n for c in self.balls:\\n print(\\\"updated ball\\\")\\n c.update(self)\\n for c in self.balls:\\n for z in self.blocks:\\n print(\\\"updated ball/block\\\")\\n collideWithBlock(z,c)\\n for c in self.balls:\\n for d in self.balls:\\n if not c == d:\\n print(\\\"updated ball/ball\\\")\\n liquidInfluence(c, d)\",\n \"def update_status(self):\\n num_nbrs = len(self.neighbors)\\n if not 2 <= num_nbrs <= 3:\\n self.status = 0\\n elif num_nbrs == 3:\\n self.status = 1\",\n \"def update(self):\\n self.screen.fill(blackColor)\\n self.model.blocks.draw(self.screen)\\n self.model.players.draw(self.screen)\\n self.model.buttons.draw(self.screen)\\n self.model.Coins.draw(self.screen)\\n p1Score = myfont.render(\\\"Player 1 Score:\\\"+str(self.model.player1.score), 1, whiteColor)\\n self.screen.blit(p1Score,(100,15))\\n if self.model.playernum==2:\\n p2Score = myfont.render(\\\"Player 2 Score:\\\"+str(self.model.player2.score), 1,whiteColor)\\n self.screen.blit(p2Score,(1200,15))\\n timerLimit = myfont.render(\\\"Time Limit:\\\" +str(self.model.time), 1, whiteColor)\\n self.screen.blit(timerLimit, (700, 15)) \\n pygame.display.update()\",\n \"def callback_game_loop(self) -> None:\\n self._goal_generate()\\n self._update()\\n self.reset()\\n\\n while self._player != self._goal:\\n self._update()\\n action = self._action_callback(\\n self._player.np,\\n self._goal.np,\\n *self._action_callback_args,\\n )\\n if action == \\\"QUIT\\\":\\n break\\n self._player_erase()\\n self.FUNCMAP[action]()\\n self._update()\\n\\n if self._display:\\n time.sleep(0.1)\\n try:\\n if chr(cv2.waitKey(5)) in self.KEYMAP[\\\"QUIT\\\"]:\\n break\\n except ValueError:\\n pass\\n\\n if self._display:\\n print(f\\\"Steps taken: {self._routes[self._current_route_key]}\\\")\\n\\n if self._display:\\n cv2.waitKey(0)\",\n \"def run_game(self):\\n\\t\\twhile True:\\n\\t\\t\\tself._check_events()\\n\\t\\t\\t\\n\\t\\t\\tif self.stats.game_active:\\n\\t\\t\\t\\tself.pigeon.update()\\n\\t\\t\\t\\tself._update_droppings()\\n\\t\\t\\t\\tself._update_autos()\\n\\n\\t\\t\\tself._update_screen()\",\n \"def loop(self):\\n while not rospy.is_shutdown():\\n\\n rospy.logdebug(\\\"Loop\\\")\\n state = self.move_base.get_state()\\n\\n self.counter +=1\\n if(self.counter>6 or state==3):\\n rospy.logdebug(\\\"-------------------------\\\")\\n rospy.logdebug(\\\"Recalculate Frontriers ! \\\")\\n rospy.logdebug(\\\"-------------------------\\\")\\n\\n self.counter = 0\\n frontiers_num = self.update()\\n\\n #break condition\\n if frontiers_num==0 :\\n rospy.logdebug(\\\"---------------------------------------\\\")\\n rospy.logdebug(\\\"---------------------------------------\\\")\\n rospy.logdebug(\\\"NO FRONTIERS FOUND EXPLORATION COMPLETE\\\")\\n rospy.logdebug(\\\"---------------------------------------\\\")\\n rospy.logdebug(\\\"---------------------------------------\\\")\\n break\\n\\n\\n\\n rate.sleep()\",\n \"def update_to_state(self, game_state):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61955214","0.61330974","0.6041856","0.6010904","0.59940135","0.59497553","0.5944543","0.5941799","0.5920345","0.59200984","0.591803","0.58926064","0.58895403","0.58456695","0.5832112","0.5823152","0.5813254","0.5792448","0.57885593","0.5739146","0.56946295","0.5692687","0.5687704","0.5671722","0.5664923","0.56599253","0.56578535","0.56561667","0.5651048","0.5640779","0.56339955","0.56324416","0.5629902","0.5617903","0.5608541","0.56069654","0.55940294","0.55912197","0.55893123","0.5581906","0.55809224","0.5570453","0.5568232","0.55666435","0.556621","0.5564445","0.5559558","0.5555134","0.5548799","0.5546052","0.5546026","0.5544345","0.55440396","0.55330914","0.5521753","0.55182123","0.55161345","0.5510552","0.5508479","0.5507856","0.5502001","0.55004334","0.5489492","0.54864234","0.54853195","0.5483234","0.5482414","0.54799396","0.5477175","0.54731804","0.5471401","0.54673177","0.5465467","0.54613656","0.5461252","0.5461247","0.54499835","0.5447716","0.54475117","0.5443573","0.5443414","0.5436714","0.5431327","0.54309326","0.54262","0.542183","0.54148483","0.5412228","0.54117846","0.5409011","0.540631","0.5406039","0.5403188","0.5402844","0.53967893","0.5396711","0.5394192","0.5382763","0.53816056","0.53802365","0.5379693"],"string":"[\n \"0.61955214\",\n \"0.61330974\",\n \"0.6041856\",\n \"0.6010904\",\n \"0.59940135\",\n \"0.59497553\",\n \"0.5944543\",\n \"0.5941799\",\n \"0.5920345\",\n \"0.59200984\",\n \"0.591803\",\n \"0.58926064\",\n \"0.58895403\",\n \"0.58456695\",\n \"0.5832112\",\n \"0.5823152\",\n \"0.5813254\",\n \"0.5792448\",\n \"0.57885593\",\n \"0.5739146\",\n \"0.56946295\",\n \"0.5692687\",\n \"0.5687704\",\n \"0.5671722\",\n \"0.5664923\",\n \"0.56599253\",\n \"0.56578535\",\n \"0.56561667\",\n \"0.5651048\",\n \"0.5640779\",\n \"0.56339955\",\n \"0.56324416\",\n \"0.5629902\",\n \"0.5617903\",\n \"0.5608541\",\n \"0.56069654\",\n \"0.55940294\",\n \"0.55912197\",\n \"0.55893123\",\n \"0.5581906\",\n \"0.55809224\",\n \"0.5570453\",\n \"0.5568232\",\n \"0.55666435\",\n \"0.556621\",\n \"0.5564445\",\n \"0.5559558\",\n \"0.5555134\",\n \"0.5548799\",\n \"0.5546052\",\n \"0.5546026\",\n \"0.5544345\",\n \"0.55440396\",\n \"0.55330914\",\n \"0.5521753\",\n \"0.55182123\",\n \"0.55161345\",\n \"0.5510552\",\n \"0.5508479\",\n \"0.5507856\",\n \"0.5502001\",\n \"0.55004334\",\n \"0.5489492\",\n \"0.54864234\",\n \"0.54853195\",\n \"0.5483234\",\n \"0.5482414\",\n \"0.54799396\",\n \"0.5477175\",\n \"0.54731804\",\n \"0.5471401\",\n \"0.54673177\",\n \"0.5465467\",\n \"0.54613656\",\n \"0.5461252\",\n \"0.5461247\",\n \"0.54499835\",\n \"0.5447716\",\n \"0.54475117\",\n \"0.5443573\",\n \"0.5443414\",\n \"0.5436714\",\n \"0.5431327\",\n \"0.54309326\",\n \"0.54262\",\n \"0.542183\",\n \"0.54148483\",\n \"0.5412228\",\n \"0.54117846\",\n \"0.5409011\",\n \"0.540631\",\n \"0.5406039\",\n \"0.5403188\",\n \"0.5402844\",\n \"0.53967893\",\n \"0.5396711\",\n \"0.5394192\",\n \"0.5382763\",\n \"0.53816056\",\n \"0.53802365\",\n \"0.5379693\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":847,"numItemsPerPage":100,"numTotalItems":95772,"offset":84700,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjAwODA1NywianRpIjoiZTE0NDA2OGItNmQyMy00NTgxLTgyZjktNDViNjFiMzUwYTBmIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYwMTE2NTcsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.KCfXD-QEwbst9QoXKaNbWgE32judmC4KRqPQJ4ZTP0f94PtcVww0_taq0DqFmgN3tJo-unJxQYalaCPGPTr4Bg","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 |
|---|---|---|---|---|---|---|
Claim iscore and sets new rate daily. | def _check_for_iscore(self) -> None:
if self._system.getIISSInfo()["nextPRepTerm"] > self._block_height_day.get() + 1800:
self._block_height_day.set(self._system.getIISSInfo()["nextPRepTerm"])
self._claim_iscore() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_current_rate(self, rate_to_set):\n pass",
"def _set_rate(self):\r\n interval = self.data.iloc[2, 0] - self.data.iloc[1, 0]\r\n self.rate = int(1 / interval)",
"def _claim_iscore(self) -> None:\n iscore_details_dict = self._system.queryIScore(self.address)\n if iscore_... | [
"0.6537691",
"0.6242626",
"0.6220372",
"0.61135656",
"0.61135656",
"0.60734284",
"0.60269517",
"0.5867458",
"0.5848384",
"0.57485807",
"0.57235295",
"0.57152945",
"0.5668259",
"0.5667469",
"0.5660507",
"0.56359756",
"0.56104755",
"0.5596382",
"0.5588775",
"0.55878633",
"0.555... | 0.5276463 | 33 |
Checks the balance of the score and transfer the unstaked amount to the address and removing the data from linked list . | def _check_unstake_result(self) -> None:
balance_score = self.icx.get_balance(self.address) - self._daily_reward.get()
if balance_score > 0:
unstake_info_list = self.getUserUnstakeInfo()
for each_info in unstake_info_list:
value_to_transfer = each_info[0]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def removeStake(self, address: str, value_LP: int):\n addr = address.lower()\n balances = self.addresses[addr] if addr in self.addresses else []\n if len(balances) > 0:\n while len(balances) > 0 and value_LP > 0:\n balance = balances[-1]\n initial_LP = ... | [
"0.6432592",
"0.5612482",
"0.55736476",
"0.5467292",
"0.5448148",
"0.5388455",
"0.5355376",
"0.5315712",
"0.528098",
"0.5231815",
"0.52249676",
"0.5186252",
"0.5156468",
"0.513889",
"0.51251215",
"0.5123362",
"0.51192874",
"0.5118209",
"0.5103814",
"0.5093112",
"0.5073614",
... | 0.5967963 | 1 |
stakes and delegates some ICX to top prep addresses and receives equivalent of sICX by the user address. | def addCollateral(self, _to: Address = None) -> None:
if self._distributing.get() == True:
self._total_stake.set(self._total_stake.get() + self._daily_reward.get())
self._distributing.set(False)
self._daily_reward.set(0)
if _to == None:
_to = self.tx.origi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setSicxAddress(self, _address: Address) -> None:\n self._sICX_address.set(_address)",
"def getSicxAddress(self) -> Address:\n return self._sICX_address.get()",
"def getAddress(user):",
"def _send_ICX(self, _to: Address, amount: int, msg: str='') -> None:\n try:\n self.icx.... | [
"0.5445231",
"0.5385196",
"0.51689297",
"0.51638705",
"0.5160624",
"0.50212485",
"0.50089616",
"0.49819303",
"0.49768826",
"0.49755865",
"0.49623156",
"0.49204937",
"0.48982558",
"0.48172063",
"0.48009193",
"0.47569516",
"0.47566313",
"0.4753309",
"0.47524184",
"0.47457212",
... | 0.0 | -1 |
Claims the iScore and distributes it to the top 100 prep addresses. | def _claim_iscore(self) -> None:
iscore_details_dict = self._system.queryIScore(self.address)
if iscore_details_dict['estimatedICX'] != 0:
amount = iscore_details_dict["estimatedICX"]
self._system.claimIScore()
self._daily_reward.set(amount)
self._rate.set... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculScore(self):\n for cell in self.notComputeRouter:\n if(cell.isCovered==True):\n self.score += 1000\n self.score += self.budget",
"def top_100_score(self,predictions,labels):\n\n # sort the array by predictions\n order = np.flipud(predictions.argsort... | [
"0.60285985",
"0.5817724",
"0.5764041",
"0.57421845",
"0.57248867",
"0.57037795",
"0.56663936",
"0.5545361",
"0.55202323",
"0.54780304",
"0.54671097",
"0.54642636",
"0.5449368",
"0.54473275",
"0.54473275",
"0.54473275",
"0.5445719",
"0.54322976",
"0.5431391",
"0.5429363",
"0.... | 0.0 | -1 |
Stakes the ICX in the network. | def _stake(self, _stake_value: int) -> None:
self._system.setStake(_stake_value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect_stim(self):\n self.stim = h.NetStim()\n self.stim.number = self.stim_number\n self.stim.start = 9\n self.ncstim = h.NetCon(self.stim, self.cells[0].synlist[0])\n self.ncstim.delay = 1\n self.ncstim.weight[0] = self.stim_w # NetCon weight is a vector.",
"def a... | [
"0.5664815",
"0.54133534",
"0.523183",
"0.51994085",
"0.5093293",
"0.5040406",
"0.5012292",
"0.5007908",
"0.5007278",
"0.49930787",
"0.49525902",
"0.48961017",
"0.4879889",
"0.4876623",
"0.48565403",
"0.48431444",
"0.48348346",
"0.48343807",
"0.4803706",
"0.47892678",
"0.4789... | 0.0 | -1 |
Delegates the ICX to top prep addresses. | def _delegations(self, evenly_distribute_value: int, remainder: int) -> None:
delegation_list = []
for each_prep in self._top_preps:
if len(delegation_list) == (TOTAL_PREPS - 1):
evenly_distribute_value = evenly_distribute_value + remainder
delegation_info: Delega... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _set_top_preps(self) -> None :\n prep_dict = self._system.getPReps(1, 20)\n prep_address_list = prep_dict['preps']\n for each_prep in prep_address_list:\n self._top_preps.put(each_prep['address'])",
"def handle_get_main_prep_list(self, _context: 'IconScoreContext', _params: d... | [
"0.593054",
"0.5150775",
"0.501744",
"0.4996949",
"0.49350217",
"0.49135786",
"0.47349587",
"0.4714322",
"0.4709175",
"0.4704338",
"0.46738154",
"0.4617613",
"0.46168512",
"0.4597718",
"0.45850587",
"0.4568212",
"0.4540159",
"0.45384282",
"0.4498532",
"0.44880185",
"0.4482453... | 0.0 | -1 |
Used only to receive sICX for unstaking. | def tokenFallback(self, _from: Address, _value: int, _data: bytes) -> None:
if self.msg.sender != self._sICX_address.get():
revert(f'The Staking contract only accepts sICX tokens.')
Logger.debug(f'({_value}) tokens received from {_from}.', TAG)
try:
d = json_loads(_data.d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sn(self):\n\t\tstring = []\n\t\tresp = [0x00]\n\t\tself.spi.transfer([0x10], [0x00], 1)\n\t\ttime.sleep(9e-3)\n\t\tfor i in range(60):\n\t\t\tself.spi.transfer([0x00], resp, 1)\n\t\t\tstring.append(chr(resp[0]))\n\t\ttime.sleep(0.1)\n\t\treturn ''.join(string).strip()",
"def receive_interrupt_request(self, _... | [
"0.5725389",
"0.5437416",
"0.52976817",
"0.52271223",
"0.5199893",
"0.5151587",
"0.51070213",
"0.50734866",
"0.50734866",
"0.506104",
"0.5022422",
"0.5011935",
"0.5001367",
"0.49909127",
"0.49771768",
"0.49767193",
"0.49695894",
"0.4956895",
"0.49366823",
"0.4934447",
"0.4916... | 0.0 | -1 |
Burns the sICX and removes delegations from the prep addresses and adds the unstaking request to the linked list. | def _unstake(self, _to: Address, _value: int) -> None:
try:
if self._distributing.get() == True:
self._total_stake.set(self._total_stake.get() + self._daily_reward.get())
self._distributing.set(False)
self._daily_reward.set(0)
self._reset_t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_remove_yield(self, affiliate_items_url_factory, affiliate_network_factory):\n network = affiliate_network_factory(name='Network')\n\n with mock.patch('chiton.rack.affiliates.bulk.create_affiliate') as create_affiliate:\n affiliate = ValidatingAffiliate()\n affiliate.val... | [
"0.49018943",
"0.48822764",
"0.48634377",
"0.4716478",
"0.46393856",
"0.46225703",
"0.46193188",
"0.46079126",
"0.45960215",
"0.45934704",
"0.45923227",
"0.45914638",
"0.4558258",
"0.45580754",
"0.45569086",
"0.45355147",
"0.4530343",
"0.45187205",
"0.45116302",
"0.45006743",
... | 0.43304968 | 40 |
Sends ICX to an address. | def _send_ICX(self, _to: Address, amount: int, msg: str='') -> None:
try:
self.icx.transfer(_to, amount)
self.FundTransfer(_to, amount, msg + f' {amount} ICX sent to {_to}.')
except BaseException as e:
revert(f'{amount} ICX not sent to {_to}. '
f'Ex... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _send_ICX(self, _to: Address, amount: int, msg: str) -> None:\n try:\n self.icx.transfer(_to, amount)\n self.FundTransfer(_to, amount, msg + f' {amount} ICX sent to {_to}.')\n except BaseException as e:\n revert(f'{amount} ICX not sent to {_to}. '\n ... | [
"0.67941105",
"0.6422302",
"0.5968883",
"0.593261",
"0.5741187",
"0.57041913",
"0.5646999",
"0.5617863",
"0.5556189",
"0.5440533",
"0.53692085",
"0.5294152",
"0.528091",
"0.52612793",
"0.52612793",
"0.5130072",
"0.5127549",
"0.51131177",
"0.51100826",
"0.51076645",
"0.5046392... | 0.68834853 | 0 |
Only for the dummy contract, to simulate claiming Iscore. | def fallback(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dummy(self):\n pass",
"def RequiredContract(self) -> _n_0_t_1:",
"def test(self):\n raise NotImplementedError",
"def contract_pepo_pbc():\n pass",
"def test_stub(self):\n pass",
"def test_abicontract_interface():\n tester_state = Chain()\n\n contract_path = path.join(CON... | [
"0.6828843",
"0.66835016",
"0.6159249",
"0.6099624",
"0.6039241",
"0.59682924",
"0.58445585",
"0.5811602",
"0.5795898",
"0.57446617",
"0.5712862",
"0.57051903",
"0.5693675",
"0.56829774",
"0.566784",
"0.5667243",
"0.56588304",
"0.5653454",
"0.56472826",
"0.56462944",
"0.56462... | 0.0 | -1 |
Register all directives, exists to avoid race conditions. Sometimes stuff like publish_parts can be ran from command line functions tests. There's also ways we could avoid this by placing it in __init__ of django_docutils.lib, but that's a bit implicit. Investigate that later. In order to make this work across django p... | def register_based_directives():
if not BASED_LIB_RST:
return
if "directives" in BASED_LIB_RST:
for dir_name, dir_cls_str in BASED_LIB_RST["directives"].items():
class_ = import_string(dir_cls_str)
directives.register_directive(dir_name, class_) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup(app):\n app.add_directive('show_tasks', ShowTasksDirective)",
"def setup(app): # noqa\n # Wee want to override the directives:\n # - 'graph' from sphinx.ext.graphviz extension.\n # - 'uml' from sphinxcontrib.plantuml\n # But Sphinx warns of the override, causing failure if warnings are ... | [
"0.56825787",
"0.55998087",
"0.556161",
"0.544905",
"0.5275472",
"0.52580863",
"0.52263993",
"0.5223901",
"0.519866",
"0.51767975",
"0.517581",
"0.5134543",
"0.5127223",
"0.50869644",
"0.50686884",
"0.5055614",
"0.5038577",
"0.5013569",
"0.5008931",
"0.50057",
"0.5004458",
... | 0.7255333 | 0 |
chunk by step count | def _chunk_bs(bs, step=2):
stop = len(bs)
start = 0
bs_to_list = []
for bstep in range(0, stop, step):
bs_to_list.insert(bstep, bs[start:bstep+step])
start = start + step
return bs_to_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def chunks(sequence, chunk_size):\r\n\r\n # YOUR CODE HERE\r",
"def get_chunks(num_items, num_steps):\n chunk_sizes = np.zeros(num_steps, dtype=int)\n chunk_sizes[:] = num_items // num_steps\n chunk_sizes[:num_items % num_steps] += 1\n\n chunk_offsets = np.roll(np.cumsum(chunk_sizes), 1)\n chun... | [
"0.7152931",
"0.71093166",
"0.6911289",
"0.6829152",
"0.6811473",
"0.67924106",
"0.6765619",
"0.67565936",
"0.6739344",
"0.6727092",
"0.6702155",
"0.66849524",
"0.66815555",
"0.6666477",
"0.66645473",
"0.6662247",
"0.6657508",
"0.66518414",
"0.66327477",
"0.6630342",
"0.66095... | 0.0 | -1 |
str/int repr to hex | def hexlify(self: str, verbose=False):
nbytes = len(_chunk_bs(self))
buf = b''
strlen = ''
for b in to_bytes(_chunk_bs(self)):
buf+=b
# for s in _from_list(_chunk_bs(self)):
# strlen+=f'{ _bit_length(s): 02d}'
if verbose:
for n in range(nbytes):
strlen += f'{_bi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def int2hex(n: int) -> str:",
"def int_to_hex(n):\r\n #return \"0x%X\" % n\r\n return hex(n)",
"def int_to_hexstr(data: int) -> str:\n return \"%0.2X\" % data",
"def int_to_hex(num):\n return hex(num)",
"def int_to_hex(a):\n return hex(a)",
"def hex(cls, x):\n return c_hex(x)",
"d... | [
"0.85594016",
"0.8040766",
"0.7699089",
"0.7664095",
"0.756457",
"0.7433254",
"0.73482215",
"0.7305403",
"0.727798",
"0.72500014",
"0.71698976",
"0.716357",
"0.71601605",
"0.7085572",
"0.70646644",
"0.7037984",
"0.69810885",
"0.6955859",
"0.6945289",
"0.6879481",
"0.6840643",... | 0.0 | -1 |
Push the item onto the heap, maintaining the heap invariant. | def heappush(heap, item):
heap.append(item)
_siftdown(heap, 0, len(heap)-1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def push(self, item: tuple):\n self.__heap.append(item)\n self.__sift_up(self.__len__() - 1)",
"def push(self, item):\n heapq.heappush(self.heap, item)",
"def push(self, item):\n self.heap.append(self.m * item)\n self._sift_up()",
"def insert(self, item):\n self.heap... | [
"0.9063282",
"0.8996565",
"0.8773676",
"0.82297313",
"0.8163153",
"0.7998835",
"0.79950887",
"0.7948598",
"0.7889434",
"0.78529996",
"0.7817438",
"0.7795371",
"0.7776321",
"0.7763033",
"0.77054644",
"0.7682576",
"0.7661818",
"0.7661818",
"0.76568264",
"0.76370543",
"0.7628241... | 0.80675966 | 5 |
Pop the smallest item off the heap, maintaining the heap invariant. | def heappop(heap):
lastelt = heap.pop()
if heap:
returnitem = heap[0]
heap[0] = lastelt
_siftup(heap, 0)
return returnitem
return lastelt | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_min(self):\r\n # Should raise an exception of size is 0...\r\n if self._size == 0: raise KeyError # Can't remove from an empty heap\r\n result = self._data[0] # remember the smallest\r\n self._data[0] = None # None is so we don't have a reference.\r\n ... | [
"0.8549087",
"0.8411378",
"0.81956744",
"0.81826556",
"0.8122067",
"0.80987185",
"0.7935053",
"0.79007554",
"0.78271985",
"0.7778041",
"0.77745444",
"0.775685",
"0.77393687",
"0.7724083",
"0.766854",
"0.76677996",
"0.7608669",
"0.7605774",
"0.75887674",
"0.75823057",
"0.75724... | 0.7422917 | 33 |
Implementation of RGCN from the `"Modeling Relational Data with Graph Convolutional Networks" | def __init__(self, num_nodes, h_dim, out_dim, num_rels,
num_bases=-1, num_hidden_layers=1, dropout=0.5, bias=False):
super(RGCN, self).__init__()
self.num_nodes = num_nodes
self.h_dim = h_dim
self.out_dim = out_dim
self.num_rels = num_rels
self.num_bases ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(\n self,\n n_in_channel=1,\n nclass=10,\n attention=True,\n activation=\"glu\",\n dropout=0.5,\n train_cnn=True,\n rnn_type=\"BGRU\",\n n_RNN_cell=128,\n n_layers_RNN=2,\n dropout_recurrent=0,\n cnn_integration=False,\... | [
"0.6725458",
"0.65787673",
"0.64724976",
"0.62752014",
"0.62358326",
"0.61777776",
"0.61175686",
"0.6113475",
"0.60882884",
"0.60320884",
"0.600548",
"0.59998",
"0.5995034",
"0.5975954",
"0.59726614",
"0.5959342",
"0.5940323",
"0.5939544",
"0.59256434",
"0.591488",
"0.5912431... | 0.74162155 | 0 |
Precomputes and stores the factorial terms up to ``n!``. | def _compute_factorial(n: int) -> None:
fact_count = len(_factorial_sequence)
# have the terms up to n! already been computed?
if n < fact_count:
return
# compute numbers iteratively from existing sequence
product = _factorial_sequence[-1]
for i in range(fact_count, n + 1):
pr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def factorial(n):\n return product(range(1, n + 1))",
"def factorial(n):\r\n temp = 1\r\n for item in range(2, n+1):\r\n temp *= item\r\n return temp",
"def factorial(n):\n\n # the code for factorial",
"def factorial_factorization(n):\n primes = sympy.primerange(2, n+1)\n factoriz... | [
"0.7415409",
"0.7358811",
"0.7357318",
"0.73475236",
"0.73066384",
"0.7260437",
"0.7232459",
"0.7230606",
"0.7225571",
"0.71934617",
"0.71773946",
"0.71698505",
"0.71696246",
"0.71455836",
"0.70917183",
"0.7090762",
"0.7074305",
"0.7074229",
"0.7064162",
"0.6995383",
"0.69483... | 0.8229444 | 0 |
Resets the currently cached list of factorial terms. | def _reset_factorial_cache() -> None:
global _factorial_sequence
_factorial_sequence = [1, 1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cache_clear(self):\n self.fold_term.cache_clear()",
"def reset(self):\n self.__sets = []\n self._computed = False",
"def reset(self):\n\n self._problem.reset()\n self._termination_criterion.reset()\n\n self._tabu_list = TabuList(self._list_size)\n\n if self.... | [
"0.6321717",
"0.62391734",
"0.6231912",
"0.6231774",
"0.615009",
"0.60553265",
"0.60204417",
"0.59892094",
"0.59822446",
"0.5975522",
"0.5887768",
"0.5880887",
"0.58590513",
"0.5852908",
"0.58527416",
"0.5850188",
"0.5849707",
"0.58328885",
"0.58244604",
"0.5810227",
"0.58006... | 0.81499666 | 0 |
Counts the number of ways to choose ``k`` objects from a group of ``n``. | def choose(n: int, k: int) -> int:
return permute(n, k) // factorial(k) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_k(n, k):\n if n == 0:\n return 1\n elif n < 0:\n return 0\n else:\n total = 0\n i = 1\n while i <= k:\n total += count_k(n - i, k)\n i += 1\n return total",
"def marbles(n: int, k: int) -> int:\n # return (n-1) Choose (k - 1)\n... | [
"0.696728",
"0.66254205",
"0.6584543",
"0.64997256",
"0.6488564",
"0.63661957",
"0.6320098",
"0.63069326",
"0.62878186",
"0.6279388",
"0.62690383",
"0.6238506",
"0.6238506",
"0.62351334",
"0.6229142",
"0.6220324",
"0.6217475",
"0.6199224",
"0.6186264",
"0.6161596",
"0.6150219... | 0.6266476 | 11 |
Counts the number of combinations that sum to a given value. | def combination_sums(total: int, terms: Sequence[int]) -> int:
if total <= 0:
raise ValueError("Argument 'total' must be a positive integer")
for term in terms:
if term <= 0:
raise ValueError("Each term in 'terms' must be a positive integer")
# initialize the combination array
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calulate_total_permutations(value):\n if len(value) == len(set(value)):\n return factorial(len(value))\n\n count_map = {}\n for char in value:\n if char in count_map:\n count_map[char] += 1\n else:\n count_map[char] = 1\n\n base_factor = factorial(len(valu... | [
"0.6943409",
"0.6418047",
"0.633947",
"0.63269424",
"0.63269424",
"0.6300757",
"0.62762356",
"0.61596483",
"0.61341727",
"0.61143696",
"0.6104481",
"0.6030774",
"0.6024498",
"0.60235465",
"0.60031515",
"0.5924365",
"0.59051305",
"0.5903383",
"0.5847164",
"0.58289903",
"0.5814... | 0.0 | -1 |
Finds the factorial of a number. | def factorial(n: int) -> int:
_compute_factorial(n)
return _factorial_sequence[n] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def factorial(number):\n result = 1\n while number:\n result *= number\n number -= 1\n return result",
"def get_factorial(number):\n if number == 1:\n return 1\n else:\n return number * get_factorial(number - 1)",
"def fact(n):\n\treturn int(factorial(n, exact=True))"... | [
"0.8016843",
"0.79547894",
"0.7926416",
"0.7816246",
"0.7811773",
"0.7799114",
"0.77133864",
"0.7668326",
"0.76484793",
"0.7634401",
"0.7630568",
"0.762524",
"0.7555803",
"0.7549835",
"0.7546689",
"0.7533298",
"0.7524768",
"0.7445579",
"0.74408174",
"0.74267644",
"0.74137694"... | 0.7252463 | 44 |
Counts the permutations of ``k`` objects from a group of ``n``. | def permute(n: int, k: int) -> int:
# no possible permutations if k > n
if n < k:
return 0
# if faster, compute n! and (n - k)! and return their quotient
fact_count = len(_factorial_sequence)
if n - fact_count <= k:
return factorial(n) // factorial(n - k)
# compute the product... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def TAoCPpermutation(n,k):\n perms = []\n for subset in itertools.combinations(range(n), k):\n A = []; B = []; C = []; min = 0; j = 0; up = 0\n for i in xrange(n):\n if(j>=k or i != subset[j]):\n B.append(i)\n up +=1\n else:\n up -=1\n j += 1\n ... | [
"0.67244786",
"0.6602117",
"0.65821195",
"0.6575043",
"0.65667427",
"0.6461524",
"0.6421544",
"0.64200276",
"0.6202763",
"0.6188401",
"0.6182074",
"0.6161341",
"0.60909414",
"0.6059227",
"0.6050304",
"0.6045108",
"0.60183555",
"0.5992609",
"0.59800917",
"0.59441495",
"0.59124... | 0.6858752 | 0 |
Returns the ligthness on a scale of 0 1 | def lightness(self):
min_component = min(self.red, self.green, self.blue)
max_component = max(self.red, self.green, self.blue)
avg = (max_component + min_component) / 2
light = avg / 255
return light | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def I(x):\n if abs(x-L/2.0) > 0.1:\n return 0\n else:\n return 1",
"def Luminosity(self):\n try:\n L = (self.E*self.Weight).sum()\n N = self.E.count()\n except:\n L = self.E.sum()\n N = self.E.count()\n return L,... | [
"0.6352984",
"0.62436646",
"0.598909",
"0.5852461",
"0.57085735",
"0.5707894",
"0.5701839",
"0.5700581",
"0.5641913",
"0.5589319",
"0.5579047",
"0.55644757",
"0.5553218",
"0.55043447",
"0.54826564",
"0.5480887",
"0.54791695",
"0.54656714",
"0.5449916",
"0.5430863",
"0.5412421... | 0.52229875 | 54 |
Returns the new colour of two added | def __add__(self, other):
red = min(255, self.red + other.red)
green = min(255, self.green + other.green)
blue = min(255, self.blue + other.blue)
return Colour(red, green, blue) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def combine_color(red, green, blue):\r\n\r\n return (red << 16) + (green << 8) + blue",
"def combine_colors(c1, c2, factor=0.5):\n c3 = QtGui.QColor()\n c3.setRed(int((factor * c1.red() + (1 - factor) * c2.red())))\n c3.setGreen(int((factor * c1.green() + (1 - factor) * c2.green())))\n c3.setB... | [
"0.72824293",
"0.718031",
"0.7179917",
"0.70171314",
"0.6788322",
"0.661035",
"0.6600029",
"0.65749484",
"0.64816475",
"0.6467034",
"0.63840234",
"0.6309512",
"0.6279438",
"0.6279166",
"0.6245517",
"0.62111986",
"0.62088406",
"0.618801",
"0.61737853",
"0.61657524",
"0.6154074... | 0.7358977 | 0 |
Function create the overall graph within the selected time window. Require two table named identity and activity to retrive the data. | def graphformation(time_lower, time_upper):
prm = param.Para()
try:
db_connection = mysql.connector.connect(
host=prm.hostname,
user=prm.username,
passwd=prm.password,
database= prm.dbname
)
db_cursor = db_connection.cursor()
except:
print("Can't Connect to database, check credentials in pa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display(self):\n \n # initialize SQL kit to access database\n s = SQL_Kit(self.userID, self.password, self.database)\n \n \n \"\"\" Total Activity by hour \"\"\"\n \n # get activity data\n all_date_times = self.activity().index\n\n all_days ... | [
"0.5929608",
"0.574596",
"0.55326647",
"0.5474472",
"0.5462424",
"0.5437014",
"0.5401054",
"0.5382752",
"0.5361706",
"0.52705204",
"0.52689993",
"0.5264251",
"0.5233626",
"0.5202995",
"0.51812655",
"0.5161609",
"0.51143515",
"0.50975466",
"0.5093021",
"0.50598747",
"0.5042939... | 0.6528744 | 0 |
Make sure we are sharing the embeddings | def set_tied(self):
self.lm_head.set_embeddings_weights(self.transformer.wte.weight) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_embeddings(self):",
"def load_embeddings(config, name, vocab, training_generator, validation_generator):\n\n # Pickle embeddings should be AGNOSTIC to the name. This is because each pickled embedding is specific to the dataset and transformer.\n # Applies down the road when/if we attempt active lea... | [
"0.6945156",
"0.61463964",
"0.60498273",
"0.60497475",
"0.600102",
"0.5945561",
"0.5919986",
"0.5854738",
"0.5815848",
"0.5764353",
"0.5683327",
"0.56654304",
"0.5660826",
"0.56377274",
"0.56158054",
"0.56053394",
"0.5600107",
"0.557418",
"0.5573172",
"0.5568942",
"0.5561353"... | 0.5177597 | 65 |
Returns a generator of the AirbyteMessages generated by reading the source with the given configuration, catalog, and state. | def read(
self, logger: AirbyteLogger, config: Mapping[str, Any], catalog: ConfiguredAirbyteCatalog, state: MutableMapping[str, Any] = None
) -> Iterable[AirbyteMessage]: | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def amsg_source_make(*args, **kwargs):\n return _uhd_swig.amsg_source_make(*args, **kwargs)",
"def loadFromCs(cs) -> Reactor:\n from armi.reactor import blueprints\n\n bp = blueprints.loadFromCs(cs)\n return factory(cs, bp)",
"def create_om_sources(self): #TODO: Prob. should make file names specifiab... | [
"0.48040932",
"0.47626972",
"0.47410765",
"0.47083217",
"0.46909904",
"0.45570529",
"0.45484966",
"0.4527919",
"0.44946748",
"0.4476982",
"0.4471172",
"0.44699246",
"0.44605175",
"0.44356242",
"0.44228485",
"0.43957162",
"0.43610972",
"0.43510348",
"0.43501917",
"0.43245143",
... | 0.71435726 | 0 |
Returns an AirbyteCatalog representing the available streams and fields in this integration. For example, given valid credentials to a Postgres database, returns an Airbyte catalog where each postgres table is a stream, and each table column is a field. | def discover(self, logger: AirbyteLogger, config: Mapping[str, Any]) -> AirbyteCatalog: | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_catalog(self):\n streams = []\n\n for report in self.reports_definition:\n # For each report in reports_definition generate a Catalog Entry\n schema_name = report['name']\n view_id = report.get('view_id', self.client.view_id)\n\n schema = {\n ... | [
"0.63259274",
"0.56996787",
"0.5594333",
"0.5563564",
"0.5491723",
"0.5298365",
"0.52703625",
"0.5256098",
"0.52359384",
"0.5234309",
"0.5234309",
"0.5234309",
"0.5226757",
"0.5211858",
"0.5205091",
"0.5180719",
"0.5156277",
"0.51447415",
"0.51197815",
"0.5114194",
"0.5089148... | 0.58156174 | 1 |
Creates profile automatically using django signals and created object "instance" | def save_user_receiver(sender, instance, created, *args, **kwargs):
print("profile created", instance)
if created:
new_profile = UserProfile.objects.get_or_create(owner=instance) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_profile(sender, instance, signal, created, **kwargs):\n \n from phylocommons.models import UserProfile\n \n if created:\n UserProfile(user = instance).save()",
"def create_profile(sender, instance, signal, created, **kwargs):\n \n from tutablr_app.models import UserProfile\n \n if c... | [
"0.867299",
"0.8570306",
"0.8451151",
"0.84137326",
"0.82464796",
"0.8227456",
"0.8212175",
"0.81878513",
"0.81221265",
"0.81221265",
"0.81221265",
"0.8096361",
"0.80837584",
"0.8083164",
"0.80154145",
"0.7915596",
"0.78678995",
"0.7815063",
"0.7811869",
"0.7810469",
"0.77151... | 0.8204448 | 7 |
Override to return the class object of the port to be tested, or None if a valid port object cannot be constructed on the specified platform. | def port_maker(self, platform):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_port_type(self):\n raise NotImplementedError",
"def port(self, **kw):\n return self.portType(**kw)",
"def test_port_get_kind(self):\n assert_equal(self.test_port.get_kind(), 'mpport')",
"def get_serial(cls, port):\n if port in cls._open_ports:\n return cls._open... | [
"0.6562559",
"0.63834244",
"0.6243232",
"0.6179789",
"0.6163945",
"0.60676473",
"0.60174555",
"0.59178525",
"0.5900225",
"0.5800537",
"0.5724092",
"0.55979264",
"0.5515977",
"0.549112",
"0.5490424",
"0.5437289",
"0.5437289",
"0.541859",
"0.5402839",
"0.53838426",
"0.53678054"... | 0.66482294 | 0 |
This routine should be used for tests that should only be run when we can create a full, valid port object. | def make_port(self, options=mock_options):
maker = self.port_maker(sys.platform)
if not maker:
return None
port = maker(options=options)
if hasattr(options, "results_directory"):
port._options.results_directory = port.results_directory()
return port | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def port_factory_method(self):\n pass",
"def test_createPort(self):\n store = Store()\n factory = DummyFactory(store=store)\n self.assertSuccessStatus(\n self._makeConfig(store),\n [\"create\", \"--strport\", \"tcp:8080\",\n \"--factory-identifier\", ... | [
"0.72466683",
"0.7154215",
"0.68323827",
"0.6829829",
"0.68140477",
"0.6730438",
"0.66361266",
"0.6598617",
"0.6575301",
"0.65724087",
"0.6564386",
"0.65223306",
"0.6477941",
"0.642298",
"0.642145",
"0.63781863",
"0.6371469",
"0.6295128",
"0.6293753",
"0.6241559",
"0.6236039"... | 0.59248734 | 51 |
Clean user reports after a certain amount of time | def clean_reports():
logger.info('Cleaning reports older than %d days' % lgr_settings.report_expiration_delay)
# set the last run in the settings data
lgr_settings.report_expiration_last_run = timezone.now()
lgr_settings.save()
nbr, __ = LGRReport.objects.filter(
created_at__lt=datetime.date... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def afterHoursAutoPurge(self, ctx: Context):",
"def clean_timelog():",
"def purge(self, width):\n print('Purge', width)\n step_name = 'Purge'\n t0 = time.time()\n t_lastlog = t0\n while True:\n if self.interrupt_measurement_called:\n self.shuto... | [
"0.6732919",
"0.6592778",
"0.6126299",
"0.6061384",
"0.60261893",
"0.5976596",
"0.58207494",
"0.57760584",
"0.5754052",
"0.5697268",
"0.5681771",
"0.5681109",
"0.5671812",
"0.56477356",
"0.5646306",
"0.55700403",
"0.55624986",
"0.55588466",
"0.5548783",
"0.5538477",
"0.552587... | 0.7127584 | 0 |
Calculate the index variant labels of the existing TLDs against the selected RZ LGR | def calculate_index_variant_labels_tlds(user_pk=None):
logger.info('Calculate the index variant labels of the existing TLDs against the default RZ LGR')
tlds_raw = download_file(settings.ICANN_TLDS)[1].read().lower()
tlds = LabelInfo.from_form('TLDs', tlds_raw).labels
rz_lgr_object: RzLgr = RzLgr.object... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def labelingLVQ(self):\n numLabels = len(np.unique(self.y))\n for i, x in enumerate(self.x):\n w = self.find_closest(x)[0]\n for nl in range(numLabels):\n if self.y[i] == nl:\n self.labels[nl, w[0], w[1]] += 1\n return self.labels",
"de... | [
"0.6098479",
"0.5809883",
"0.5792415",
"0.5639455",
"0.558691",
"0.55725765",
"0.5469845",
"0.5450689",
"0.5437865",
"0.53840214",
"0.5329258",
"0.5291685",
"0.52631277",
"0.51997197",
"0.5175804",
"0.51625544",
"0.5155564",
"0.51203215",
"0.51166624",
"0.51041543",
"0.508753... | 0.80737275 | 0 |
Increase the counter on the last leaf | def increase_counter(self):
self.values = self.values + 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def increment(self):\n if self.is_empty():\n return 0\n else:\n self.get_root().value += 1\n if self.get_left():\n self.get_left().increment()\n if self.get_right():\n self.get_right().increment()",
"def increment_depth(self)... | [
"0.70217365",
"0.6949094",
"0.68084276",
"0.6739828",
"0.6676615",
"0.66305053",
"0.6569543",
"0.65284365",
"0.64648086",
"0.6421712",
"0.6412349",
"0.6386599",
"0.6334527",
"0.6326167",
"0.6287127",
"0.62532866",
"0.62425673",
"0.6223496",
"0.6206714",
"0.61792964",
"0.61560... | 0.6186647 | 19 |
r"""Returns the \IDN? string | def instrID(self):
return self.query('*IDN?') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def id(self) -> str:\n\n return self._inst.query('*IDN?')",
"def get_id(self): # real signature unknown; restored from __doc__\n return \"\"",
"def get_identifier_string(self):\n return self.identifier",
"def identifier(self):\n return str(self._nfcid)",
"def idn(self):\n ... | [
"0.717656",
"0.71156234",
"0.68709844",
"0.6853172",
"0.6840426",
"0.676197",
"0.66740686",
"0.6663309",
"0.64954865",
"0.649054",
"0.64688015",
"0.6443778",
"0.6399165",
"0.63663024",
"0.63507825",
"0.6271779",
"0.62524694",
"0.6226763",
"0.6211105",
"0.62026966",
"0.6199872... | 0.67640144 | 5 |
Given an absolute path, return a path relative to the project root. 'subdir/foo' | def _get_relative_path(self, abs_path):
relative_path = os.path.relpath(abs_path, settings.PROJECT_ROOT)
return relative_path | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resolve_relative_path(path):\n if os.path.isabs(path):\n return path\n root_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))\n return os.path.join(root_dir, path)",
"def _abs_path(rel_path):\n return os.path.join(BASE_DIR, rel_path)",
"def absPath(path)... | [
"0.76968694",
"0.7513431",
"0.74758035",
"0.7474766",
"0.7435405",
"0.7332667",
"0.7309524",
"0.7283314",
"0.7236684",
"0.7155462",
"0.7137708",
"0.7106382",
"0.70955163",
"0.70686436",
"0.70526963",
"0.7035758",
"0.7011202",
"0.701053",
"0.70069593",
"0.6901063",
"0.68866503... | 0.7532645 | 1 |
withdraw ammount If successful return true else return false | def withdraw(self, ammount):
if self.ammount < ammount:
print(f"Current balance {self.ammount} is not sufficent to withdraw {ammount}")
return False
self.ammount -= ammount
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def withdraw(self, account_number: int, withdrawal: float) -> bool: \n if (withdrawal <= self._accounts[account_number][1]):\n self._accounts[account_number][1] -= withdrawal\n return True\n else:\n return False",
"def withdraw(self,withdrawal_money):\r\n if ... | [
"0.7129063",
"0.697466",
"0.685374",
"0.6743872",
"0.6703391",
"0.6656968",
"0.6639949",
"0.6582516",
"0.6498409",
"0.6463554",
"0.6439925",
"0.64195585",
"0.64138675",
"0.6405057",
"0.6379571",
"0.634767",
"0.63386095",
"0.63367176",
"0.6332831",
"0.632186",
"0.6317901",
"... | 0.79275125 | 0 |
Alternative SLF finite source trace | def singleEllipse(n,misalign=np.zeros(6),srcdist=89.61e3+1.5e3,az=100.,\
returnRays=False,f=None,\
plist=[[0],[0],[0]],\
ax=100.,psi=psiE):
#Establish subannulus of rays
r0 = conic.primrad(8426.,220.,8400.)
r1 = conic.primrad(8426.+ax,220.,8400.)
rays =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trace(self, trace=...):\n ...",
"def trace(self, *args, **kwargs): # real signature unknown\n pass",
"def Trace1SL(self,Pts=(0,0.5),TOF_base=0.0,debug=0):\n \n #---------------Flow case determination------------------\n CaseID_a=0 #Normal Case\n CaseID_b=0 #Normal ... | [
"0.61455244",
"0.59023607",
"0.586509",
"0.5801",
"0.5533315",
"0.5513344",
"0.5513344",
"0.54926205",
"0.54771984",
"0.5463698",
"0.5431483",
"0.53561157",
"0.5343255",
"0.52886647",
"0.5285975",
"0.52851033",
"0.5280199",
"0.52764237",
"0.5273738",
"0.5253578",
"0.5250417",... | 0.0 | -1 |
Trace an ellipsoidhyperboloid telescope in SLF geometry. plist is [pcoeff,pax,paz] | def ellipsoidPair(N,srcdist=89.61e3+1.5e3,primalign=np.zeros(6),\
secalign=np.zeros(6),rrays=False,f=None,\
plist=[[0],[0],[0]],hlist=[[0],[0],[0]]):
#Establish subannulus of rays
r1 = conic.ellipsoidRad(srcdist,1.,220.,8400.,8500.)
rays = sources.subannulus(220.,r1,100./220... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hexapodZernikeMultiLinearModel_hexapodcoordinate():\n Tfile='/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_training.cp'\n Vfile = '/home/jghao/research/decamFocus/psf_withseeing/finerGrid_coeff_matrix/zernike_coeff_finerGrid_validate.cp'\n b=p.load(open(... | [
"0.60391474",
"0.60107124",
"0.60082865",
"0.5938178",
"0.5851101",
"0.58187217",
"0.5752928",
"0.5570206",
"0.54817826",
"0.5473699",
"0.54417425",
"0.5419479",
"0.5413631",
"0.5397274",
"0.5381559",
"0.53082275",
"0.52977777",
"0.52790296",
"0.52768147",
"0.5266951",
"0.526... | 0.0 | -1 |
Trace single primary mirror from SLF finite source distance. | def singleOptic(N,misalign=np.zeros(6)):
#Define some Wolter parameters
r1 = conic.primrad(8600.,220.,8400.)
dphi = 100./220./2
#Set up subannulus
rays = sources.subannulus(220.,r1,dphi*1.25,N)
## #Set direction cosines
## srcdist = 89.61e3+(1.5e3-misalign[2])
## raydist = sqrt(srcdist**2+\... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, distance):\n self.logger.debug(\"forward \" + str(distance))",
"def mirrorPair(N,srcdist=89.61e3+1.5e3,primalign=np.zeros(6),\\\n secalign=np.zeros(6),rrays=False,f=None,\\\n plist=[[0],[0],[0]],hlist=[[0],[0],[0]]):\n #Establish subannulus of rays\n ray... | [
"0.55876553",
"0.5574651",
"0.51577866",
"0.5152266",
"0.50840724",
"0.5077566",
"0.49696693",
"0.49318606",
"0.49221513",
"0.48353785",
"0.48303902",
"0.48267508",
"0.48097965",
"0.47763124",
"0.47727197",
"0.473136",
"0.47198337",
"0.47080556",
"0.47046912",
"0.47038278",
"... | 0.0 | -1 |
Alternative SLF finite source trace | def singleOptic2(n,misalign=np.zeros(6),srcdist=89.61e3+1.5e3,az=100.,\
returnRays=False,f=None,\
plist=[[0],[0],[0]],\
ax=100.):
#Establish subannulus of rays
r0 = conic.primrad(8426.,220.,8400.)
r1 = conic.primrad(8426.+ax,220.,8400.)
rays = sources.s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def trace(self, trace=...):\n ...",
"def trace(self, *args, **kwargs): # real signature unknown\n pass",
"def Trace1SL(self,Pts=(0,0.5),TOF_base=0.0,debug=0):\n \n #---------------Flow case determination------------------\n CaseID_a=0 #Normal Case\n CaseID_b=0 #Normal ... | [
"0.61455244",
"0.59023607",
"0.586509",
"0.5801",
"0.5533315",
"0.5513344",
"0.5513344",
"0.54926205",
"0.54771984",
"0.5463698",
"0.5431483",
"0.53561157",
"0.5343255",
"0.52886647",
"0.5285975",
"0.52851033",
"0.5280199",
"0.52764237",
"0.5273738",
"0.5253578",
"0.5250417",... | 0.0 | -1 |
SLF finite source trace | def mirrorPair(N,srcdist=89.61e3+1.5e3,primalign=np.zeros(6),\
secalign=np.zeros(6),rrays=False,f=None,\
plist=[[0],[0],[0]],hlist=[[0],[0],[0]]):
#Establish subannulus of rays
rays = sources.subannulus(220.,221.,100./220.,N,zhat=-1.)
#Transform to node position
tran.transf... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Trace1SL(self,Pts=(0,0.5),TOF_base=0.0,debug=0):\n \n #---------------Flow case determination------------------\n CaseID_a=0 #Normal Case\n CaseID_b=0 #Normal Case\n if (self.Qa0>0.00001 and self.Qa1<-0.00001): CaseID_a=1\n if (self.Qb0>0.00001 and self.Qb1<-0.00001): ... | [
"0.6230355",
"0.5977909",
"0.57744026",
"0.5744352",
"0.5569156",
"0.55164635",
"0.5399088",
"0.5375165",
"0.5371074",
"0.5357935",
"0.53396106",
"0.53356117",
"0.53268087",
"0.5321898",
"0.5321898",
"0.5321898",
"0.5321898",
"0.5321898",
"0.5321898",
"0.5321898",
"0.5321898"... | 0.0 | -1 |
Trace randomly sampled rays from the TruFocus Xray source to the 1.22 m diameter entrance to the test chamber. AB from Jeff K.'s memo is 89.61 Use oversized subapertured annulus, applying translations | def sourceToChamber(N,misalign=np.zeros(6)):
#Define some Wolter parameters
r1 = conic.primrad(8600.,220.,8400.)
dphi = 100./220./2
#Set up subannulus
rays = sources.subannulus(220.,r1,dphi*1.25,N)
#Set direction cosines
srcdist = 89.61e3+(1.5e3-misalign[2])
raydist = sqrt(srcdist**2+\
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rayShooting():\r\n \r\n \r\n if nbRay==1:\r\n maxi=1\r\n mini=1\r\n peaceofAngle=angleMax\r\n #to trace one ray at angleMax\r\n else:\r\n maxi=(nbRay-1)/2\r\n mini=-maxi\r\n peaceofAngle=2*angleMax/(nbRay-1)\r\n #to trace rays at regular inter... | [
"0.6080523",
"0.59847254",
"0.5690276",
"0.55761904",
"0.5575056",
"0.5566404",
"0.5541756",
"0.55407023",
"0.55353624",
"0.54024464",
"0.5362905",
"0.535498",
"0.5332336",
"0.53296477",
"0.5328625",
"0.5296574",
"0.52668273",
"0.5250945",
"0.5230823",
"0.5207282",
"0.5190450... | 0.5207867 | 19 |
Place the Xray test mirror pair in the beam path. Assume rays are at XY plane with z mean direction Nominal position of intersection plane is 1.5 m past chamber entrance with mirror optical axis coincident with chamber optical axis. Can supply misalignment about X=0,Y=0 in intersection plane. | def placeWolterPair(rays,misalign=np.zeros(6)):
#Go to nominal intersection plane
tran.transform(rays,0,0,-1500.,0,0,0)
#Apply misalignments
tran.transform(rays,*misalign)
#Go to focus and place primary
tran.transform(rays,0,0,-8400,0,0,0)
pdb.set_trace()
surf.wolterprimary(rays,220.,840... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def singleOptic2(n,misalign=np.zeros(6),srcdist=89.61e3+1.5e3,az=100.,\\\n returnRays=False,f=None,\\\n plist=[[0],[0],[0]],\\\n ax=100.):\n #Establish subannulus of rays\n r0 = conic.primrad(8426.,220.,8400.)\n r1 = conic.primrad(8426.+ax,220.,8400.)\n r... | [
"0.565168",
"0.5393081",
"0.5283936",
"0.522322",
"0.5205699",
"0.5202616",
"0.5123086",
"0.5096728",
"0.50832695",
"0.5066934",
"0.5049444",
"0.50404763",
"0.5020318",
"0.4985988",
"0.49774337",
"0.49748105",
"0.49696785",
"0.49527",
"0.49473488",
"0.49434042",
"0.49410293",... | 0.5219079 | 4 |
Compute the alignment sensitivities for the parabola/hyperbola mirror pair in the SLF. | def nominalSensitivities():
#Scan ranges
ang = np.linspace(-5*.3e-3,5*.3e-3,100)
tx = np.linspace(-.3,.3,100)
#Mirror Pair Sensitivities
pitch2 = [mirrorPair(1000,primalign=[0,0,0,0,a,0]) for a in ang]
yaw2 = [mirrorPair(1000,primalign=[0,0,0,a,0,0]) for a in ang]
plt.figure('Pair')
plt... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prob_t_a_given_s(self, alignment_info):\n ...",
"def get_alignment_params(self, s, w):\n\n\n X1 = s.__get_X(w)\n X2 = self.__get_X(w)\n Y1 = s.__get_Y(w)\n Y2 = self.__get_Y(w)\n Z = self.__get_Z(w)\n W = sum(w)\n C1 = self.__get_C1(w, s)\n C2 = ... | [
"0.61029404",
"0.6053958",
"0.59238786",
"0.57227457",
"0.5673756",
"0.5650301",
"0.56068647",
"0.55311704",
"0.54914594",
"0.54535383",
"0.54151297",
"0.53894895",
"0.53610635",
"0.5355899",
"0.5355502",
"0.5321274",
"0.5310322",
"0.5308136",
"0.5305008",
"0.5300116",
"0.528... | 0.59526455 | 2 |
wrap pickle with context manager | def pickleload(path):
with open(path, 'rb') as file:
loaded = pickle.load(file)
return loaded | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test__pickle_unpickle(self):\n pass",
"def test_can_pickle(self):\n settings = UploadSettings(None, FakeDataServiceApi(), None, ProjectNameOrId.create_from_name('mouse'), None)\n params = ('one', 'two', 'three')\n context = UploadContext(settings, params, multiprocessing.Manager()... | [
"0.66330606",
"0.66099405",
"0.6122704",
"0.60778004",
"0.5914767",
"0.5810733",
"0.5740262",
"0.5726259",
"0.5715038",
"0.5690591",
"0.5646342",
"0.5645512",
"0.5605082",
"0.560194",
"0.55433786",
"0.5529835",
"0.55211455",
"0.5502968",
"0.5493324",
"0.5484761",
"0.547961",
... | 0.0 | -1 |
wrap pickle with context manager | def picklesave(obj, path):
with open(path, 'wb') as file:
pickle.dump(obj, file) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test__pickle_unpickle(self):\n pass",
"def test_can_pickle(self):\n settings = UploadSettings(None, FakeDataServiceApi(), None, ProjectNameOrId.create_from_name('mouse'), None)\n params = ('one', 'two', 'three')\n context = UploadContext(settings, params, multiprocessing.Manager()... | [
"0.66330606",
"0.66099405",
"0.6122704",
"0.60778004",
"0.5914767",
"0.5810733",
"0.5740262",
"0.5726259",
"0.5715038",
"0.5690591",
"0.5646342",
"0.5645512",
"0.5605082",
"0.560194",
"0.55433786",
"0.5529835",
"0.55211455",
"0.5502968",
"0.5493324",
"0.5484761",
"0.547961",
... | 0.5156162 | 70 |
inverse operation of zip | def unzip(zipped):
return zip(*zipped) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unzip(seq):\n return zip(*seq)",
"def unzip(pairs):\n return tuple(zip(*pairs))",
"def lzip(*args):\n return list(zip(*args))",
"def zip() -> List:\n pass",
"def zip(self, *lists):\n return _(zip(self._, *lists))",
"def unzip(self, x):\n if (len(x)>0):\n return list... | [
"0.71670586",
"0.70784897",
"0.70730954",
"0.68114686",
"0.66874325",
"0.6505765",
"0.644282",
"0.6410914",
"0.62485206",
"0.62342817",
"0.62151444",
"0.6032149",
"0.60291183",
"0.6010827",
"0.5977113",
"0.5951999",
"0.59314424",
"0.5911916",
"0.58797705",
"0.58797705",
"0.58... | 0.68771124 | 3 |
sort a list of lists by applying `key` to the first list | def sort_n(lists, key=None, reverse=False):
lists = [list(x) for x in lists]
if key is None:
return unzip(sorted(zip(*lists), reverse=reverse))
else:
return unzip(sorted(zip(*lists), key=lambda x: key(x[0]), reverse=reverse)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sort_list(list, key):\r\n list.sort(lambda x,y: cmp(key(x), key(y))) # Python < 2.4 hack\r\n return list",
"def sort_by(dict_list, key):\n return sorted(dict_list, key=lambda k: k[key])",
"def sort(self, key_func):\n pass",
"def sort(self, key: Callable):\n self.data.sort(key=key)",
... | [
"0.8160606",
"0.68767965",
"0.67813087",
"0.66011316",
"0.66011316",
"0.64723945",
"0.64605004",
"0.63796693",
"0.6350524",
"0.634693",
"0.63394505",
"0.63129747",
"0.6311414",
"0.6256282",
"0.62534684",
"0.6242892",
"0.6225871",
"0.61469173",
"0.61036456",
"0.60641676",
"0.6... | 0.6743405 | 3 |
Initialize your data structure here. | def __init__(self):
self.q1 = deque()
self.q2 = deque()
self.size = 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init_empty(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__(self):\n self._data = []",
"def __init__... | [
"0.7765608",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7645274",
"0.7595176",
"0.75853467",
"0.7558298",
"0.7530608",
"0.7530608",
"0.7530608",
"0.7530608",
"0.7530608",
"0.74971247",
"0.74971247",
"0.7478105",
"0.7477832",
"0.7477832",
"0.7477832",
... | 0.0 | -1 |
Push element x onto stack. | def push(self, x: int) -> None:
self.q1.append(x)
self.size += 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def push(self, x):\n self.stack.append(x)",
"def push(self, x):\n self.stack.append(x)",
"def push(self, x):\n self.stack1.append(x)",
"def push(self, x: int) -> None:\n self.stack.insert(0,x)",
"def push(self, x: int) -> None:\n self.stack.append(x)",
"def push(self, x... | [
"0.89402515",
"0.89402515",
"0.88311124",
"0.8809358",
"0.87103736",
"0.8672292",
"0.86654997",
"0.8621373",
"0.8583423",
"0.8547227",
"0.8547227",
"0.8511911",
"0.84800553",
"0.8436793",
"0.8426803",
"0.8399629",
"0.8271687",
"0.8203116",
"0.81832",
"0.8117397",
"0.8117397",... | 0.74636024 | 60 |
Removes the element on top of the stack and returns that element. | def pop(self) -> int:
self._aux()
ret = self.q1.popleft()
self.q1, self.q2 = self.q2, self.q1
self.size -= 1
return ret | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pop(self):\n item = self.stack[-1]\n self.stack = self.stack[:-1]\n return item",
"def remove(self):\n return self.stack_list.pop()",
"def pop(self):\n popped_node = self.top[0]\n self.top = self.top[1:]\n return popped_node",
"def pop(self):\n retur... | [
"0.8126255",
"0.8122096",
"0.80220246",
"0.7989189",
"0.7924986",
"0.79200727",
"0.7894859",
"0.7890167",
"0.7878725",
"0.78787017",
"0.78389287",
"0.7796697",
"0.77866924",
"0.7773294",
"0.7772558",
"0.7746193",
"0.7743744",
"0.7712175",
"0.7706974",
"0.7698884",
"0.76487166... | 0.0 | -1 |
Get the top element. | def top(self) -> int:
self._aux()
ret = self.q1[0]
self.q2.append(self.q1.popleft())
self.q1, self.q2 = self.q2, self.q1
return ret | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def top(self) -> int:\n return self.topEle",
"def top(self):\n return self[0]",
"def top(self):\n\t\tif self.is_empty():\n\t\t\traise Empty('Stack is empty')\n\t\treturn self._head._element",
"def top_ele(self):\n if not self.is_empty():\n return self.arr[self.top]\n re... | [
"0.8235124",
"0.81769097",
"0.81664395",
"0.8041673",
"0.78638077",
"0.78638077",
"0.78014153",
"0.78005594",
"0.778282",
"0.775879",
"0.7704059",
"0.7700389",
"0.7652212",
"0.7570927",
"0.75293076",
"0.747555",
"0.745659",
"0.74140024",
"0.7404542",
"0.7389149",
"0.7385158",... | 0.68403614 | 71 |
Returns whether the stack is empty. | def empty(self) -> bool:
return self.size == 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_empty(self):\n return len(self.the_stack) == 0",
"def is_empty(self):\n return len(self.stack) == 0",
"def empty(self) -> bool:\n return len(self.stack) == 0",
"def isEmpty(self):\n return len(self.stack) == 0",
"def empty(self):\n return len(self.stack) == 0",
"... | [
"0.9207258",
"0.91276956",
"0.90185934",
"0.9000551",
"0.89481044",
"0.89481044",
"0.8914844",
"0.8904091",
"0.8881541",
"0.88791907",
"0.8867761",
"0.87955654",
"0.8768181",
"0.8748518",
"0.87393755",
"0.8728073",
"0.8719241",
"0.87090814",
"0.87090814",
"0.85431594",
"0.850... | 0.0 | -1 |
set and check parameters. | def parse_args():
parser = argparse.ArgumentParser(description="crnn process")
parser.add_argument("--dir_name", type=str,
default=None, help="infer input dir")
parser.add_argument('--res_dir_name', default='./output', type=str,
help='the folder to save the re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_params(self):\n pass",
"def set_params(self):\r\n pass",
"def _set_params(self, *args, **kwargs):\n startup = False\n try:\n params = args[0]\n except IndexError:\n raise InstrumentParameterException('Set command requires a parameter dict.')\n... | [
"0.79090744",
"0.7478332",
"0.73961675",
"0.73716694",
"0.73063236",
"0.72327065",
"0.7229958",
"0.71148866",
"0.7112186",
"0.7080229",
"0.70182025",
"0.7015942",
"0.6978744",
"0.6976777",
"0.69733065",
"0.6928341",
"0.6918894",
"0.6894713",
"0.68870074",
"0.68486726",
"0.683... | 0.0 | -1 |
Return a checkpoint manager defined by the value of the `type` key in the configuration dictionary. Throws a `TypeError` if no storage manager with `type` is defined. | def build(config: Dict[str, Any]) -> StorageManager:
check_in("type", config, "Missing 'type' parameter of storage configuration")
# Make a deep copy of the config because we are removing items to
# pass to the constructor of the `StorageManager`.
config = copy.deepcopy(config)
identifier = config.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def manager_factory(manager_type):\n return {\n 'web': WebManager,\n 'github': GitHubManager,\n 'apkdownloadmirror': ApkDownloadMirrorManager,\n 'apkplz': ApkPlzManager,\n }[manager_type]",
"def _create_checkpoint_manager(\n model_name: str, task_p: InstantiableParams, job_lo... | [
"0.6401131",
"0.6069019",
"0.59213936",
"0.5719229",
"0.559669",
"0.5482336",
"0.54399186",
"0.53723955",
"0.53366035",
"0.52779186",
"0.52499807",
"0.52420837",
"0.52158326",
"0.51914054",
"0.5121875",
"0.5105557",
"0.508021",
"0.50717044",
"0.50554276",
"0.50545657",
"0.500... | 0.5737697 | 3 |
Validate that the checkpoint storage can be written to, restored from, and deleted from. Throws an exception if any of the operations fail. | def validate(config: Dict[str, Any]) -> None:
class ValidationData(Storable):
"""
Verification for reading and writing a UUID to a checkpoint. The
UUID saved must match the UUID that is loaded.
"""
def __init__(self) -> None:
self.uuid = str(uuid.uuid4())
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _validate_checkpoint(self, checkpoint):\n if checkpoint not in self.journal:\n raise ValidationError(\"Checkpoint not found in journal: {0}\".format(\n str(checkpoint)\n ))",
"def _checkIntegrity(self):\n return (\n os.path.isfile(os.path.join(sel... | [
"0.6401403",
"0.604441",
"0.60247445",
"0.6014493",
"0.5938673",
"0.58888197",
"0.5848131",
"0.58427566",
"0.58053726",
"0.5703405",
"0.5692488",
"0.5662562",
"0.55983996",
"0.55499136",
"0.55243295",
"0.55065054",
"0.5486752",
"0.54731613",
"0.5468748",
"0.54644",
"0.5440154... | 0.6228919 | 1 |
Test handling of unsupported file types. | def test_read_raw_unsupported_single(fname):
with pytest.raises(ValueError, match='Unsupported file type'):
read_raw(fname) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_filekind(self):\n assert self.filekind in self.obs_package.FILEKINDS, \\\n \"Invalid filekind \" + repr(self.filekind) + \" in \" + repr(self.filename)",
"def test_invalid_file_type(barred_tac_list_importer):\n expect_failure(barred_tac_list_importer, exc_message='Wrong suffix')",
... | [
"0.73096466",
"0.72667396",
"0.7169709",
"0.7053844",
"0.70381856",
"0.70034885",
"0.6961319",
"0.69586676",
"0.693639",
"0.6911375",
"0.6904064",
"0.69033587",
"0.6871798",
"0.6871798",
"0.68167496",
"0.6815058",
"0.68058836",
"0.6796886",
"0.67907995",
"0.67274284",
"0.6679... | 0.72083527 | 2 |
Test handling of supported file types but with bad data. | def test_read_raw_unsupported_multi(fname, tmp_path):
fname = tmp_path / fname
fname.write_text('')
with pytest.raises(RuntimeError, match='Could not read.*using any'):
read_raw(fname) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_read_raw_unsupported_single(fname):\n with pytest.raises(ValueError, match='Unsupported file type'):\n read_raw(fname)",
"def test_mimetypes(self):\n field = TypedFileField(required=False, type_whitelist=self.good_types, use_magic=False)\n\n for t in self.good_types:\n ... | [
"0.74382997",
"0.7410078",
"0.73706025",
"0.7338524",
"0.7261793",
"0.72291225",
"0.71552974",
"0.7154416",
"0.7031707",
"0.68959975",
"0.6882427",
"0.6861409",
"0.684707",
"0.6789293",
"0.6767486",
"0.6741527",
"0.6737622",
"0.67358255",
"0.6731696",
"0.67203623",
"0.6695517... | 0.63953114 | 35 |
Test handling of unsupported file types with suggested alternatives. | def test_read_raw_suggested(fname):
with pytest.raises(ValueError, match='Try reading'):
read_raw(fname) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_invalid_file_type(barred_tac_list_importer):\n expect_failure(barred_tac_list_importer, exc_message='Wrong suffix')",
"def test_available_input_formats():\n assert set([\"Mapchete\", \"raster_file\", \"vector_file\"]).issubset(\n set(available_input_formats())\n )",
"def test_general_s... | [
"0.7028738",
"0.7011318",
"0.69126594",
"0.6885521",
"0.6855406",
"0.67453164",
"0.67340046",
"0.67340046",
"0.6723626",
"0.6694643",
"0.6680965",
"0.66767067",
"0.66629815",
"0.65844667",
"0.657588",
"0.6551066",
"0.6483879",
"0.64343315",
"0.642884",
"0.6425589",
"0.6418884... | 0.0 | -1 |
Test supported file types. | def test_read_raw_supported(fname):
read_raw(fname)
read_raw(fname, verbose=False)
raw = read_raw(fname, preload=True)
assert "data loaded" in str(raw) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def SupportedFiletypes( self ):\n return ['plaintex', 'tex']",
"def SupportedFiletypes( self ):\n return ['plaintex', 'tex']",
"def check_file_type(fname):\n ext = path.splitext(fname)[1]\n return ext in allowed_extensions",
"def supportedType(request, video_types):\n return request.FI... | [
"0.75743014",
"0.75743014",
"0.7446866",
"0.7374533",
"0.72811556",
"0.7253329",
"0.7240825",
"0.7200986",
"0.71743566",
"0.71026045",
"0.7073984",
"0.6995628",
"0.69731855",
"0.69684285",
"0.68646485",
"0.6860663",
"0.68215215",
"0.6792538",
"0.6772953",
"0.6734382",
"0.6728... | 0.0 | -1 |
For a given n, return X(t) | def X_n(a, b, n, T):
def X(t):
return a * np.cos((np.pi * 2 * n * t) / T) + b * np.sin((np.pi * 2 * n * t) / T)
return X | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def I (self, n):",
"def H(n,x):\r\n H_values = [] #a list of sequential H values for different n's up to n=n.\r\n H_values.append(1) #appends H_0.\r\n H_values.append(2*x) #appends H_1.\r\n if n>1:\r\n for i in range(1,n):\r\n H_values.append((2*x*H_values[-1])-(2*i*H_values[-2]))... | [
"0.6313942",
"0.62647074",
"0.6229281",
"0.6226506",
"0.6218988",
"0.6215609",
"0.61505866",
"0.6141341",
"0.6121001",
"0.61204237",
"0.6110605",
"0.60703003",
"0.6052773",
"0.60342765",
"0.6012939",
"0.59978163",
"0.59976727",
"0.59882796",
"0.592562",
"0.5920827",
"0.590750... | 0.6888937 | 0 |
Takes plain text, returns HTML | def paintText(self, text):
return '@paint '+text * 2 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plain_to_html(plain_text):\n if plain_text is None:\n return \"\"\n\n # We remove trailing whitespace - most notably newlines - so we\n # don't end up with unexpected vertical whitespace in the output.\n html = str(plain_text).rstrip().replace(\"&\", \"&\"). \\\n replace(\"<\", \"... | [
"0.7550789",
"0.7188893",
"0.700638",
"0.6908054",
"0.68955153",
"0.6698889",
"0.6694212",
"0.6688597",
"0.6665702",
"0.66182286",
"0.661604",
"0.66057044",
"0.6555294",
"0.64987445",
"0.6463699",
"0.6456063",
"0.6424575",
"0.63640916",
"0.6352742",
"0.63313746",
"0.63157815"... | 0.0 | -1 |
Extract keywords from text content for recommender | def extract_text(self, categories, entries):
text = " ".join(
[
self.podcast.title,
self.podcast.description,
self.podcast.keywords,
self.podcast.authors,
]
+ [c.name for c in categories]
+ [e["title"... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def keyword_extraction(file_content):\n\n # [question, question....]\n for key, value in file_content.items():\n seg, hidden = ltp.seg([key])\n # ner: [[('Nh', 2, 2)]]\n ner = ltp.ner(hidden)\n # keywords: [('PERSON', \"吴轩\")], tuple_item: ('Nh', 2, 2)\n keywords = [(tag_t... | [
"0.6903335",
"0.6842439",
"0.67924124",
"0.6734254",
"0.6721905",
"0.67102164",
"0.6706387",
"0.6632763",
"0.6609244",
"0.6552113",
"0.65412855",
"0.6475794",
"0.64006937",
"0.63784295",
"0.6262502",
"0.61701745",
"0.61657244",
"0.6163229",
"0.6147644",
"0.6125211",
"0.612389... | 0.5536626 | 80 |
Parses new episodes from podcast feed. | def create_episodes_from_feed(self, entries):
guids = self.podcast.episode_set.values_list("guid", flat=True)
entries = [entry for entry in entries if entry["id"] not in guids]
episodes = [
episode
for episode in [self.create_episode_from_feed(entry) for entry in entries... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_podcast_episodes(url):\n\n def parse_pubdate(date_string):\n \"\"\"\n Change pubdate string to datetime object. Tries a bunch of\n possible formats, but if none of them is a match, it will\n return a epoch = 0 datetime object\n\n :param date_string: A string representi... | [
"0.6681258",
"0.64088464",
"0.61949426",
"0.6156933",
"0.6130738",
"0.6122721",
"0.6103838",
"0.60889024",
"0.60440505",
"0.5956099",
"0.5897863",
"0.5877394",
"0.58128",
"0.58113426",
"0.57403153",
"0.57149476",
"0.5643858",
"0.55934775",
"0.5578704",
"0.55482566",
"0.554315... | 0.7159126 | 0 |
This function runs hashlib.sha512() on a file using chunks to ensure that too much RAM is not used. | def sha512(fname, /, *, chunksize = 1048576):
# Import standard modules ...
import hashlib
# Create hash object ...
hobj = hashlib.sha512()
# Open input file as bytes ...
with open(fname, "rb") as fObj:
# Start infinite loop ...
while True:
# Read a chunk ...
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_file_sha512(fileIn):\n\n # fileIn is read in chunks to ensure it will work with (very) large files as well\n # Adapted from: http://stackoverflow.com/a/1131255/1209004\n\n blocksize = 2**20\n m = hashlib.sha512()\n with open(fileIn, \"rb\") as f:\n while True:\n buf = ... | [
"0.7312387",
"0.72841877",
"0.7193235",
"0.69665354",
"0.68670136",
"0.6723953",
"0.6630066",
"0.6559456",
"0.6534818",
"0.64672387",
"0.63602763",
"0.6274184",
"0.626974",
"0.6252934",
"0.6230989",
"0.6187304",
"0.61721843",
"0.6122351",
"0.6092596",
"0.5980338",
"0.59542215... | 0.8374994 | 0 |
r"""Updating the injection spectrum. | def update_spectrum(self, spectrum):
self.spectrum = spectrum
return | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self):\n self.probe.update()",
"def update(self):\n self.probe.update()",
"def update(self):\n self.probe.update()",
"def retarder(self):\n self.spectrum = self.spectrum",
"def analyzer(self):\n self.spectrum = self.spectrum",
"def calibration_wheel(self):\n ... | [
"0.61867964",
"0.61867964",
"0.61867964",
"0.614271",
"0.5898126",
"0.58536935",
"0.5806128",
"0.57766",
"0.5747572",
"0.57033694",
"0.56991166",
"0.5691732",
"0.5648008",
"0.56375796",
"0.56250036",
"0.56163186",
"0.56163186",
"0.5604377",
"0.55946124",
"0.55214006",
"0.5519... | 0.6875147 | 0 |
Decrypt Atbash enciphered ``ciphertext``. | def decrypt(ciphertext: str) -> Iterable:
return simplesubstitution.decrypt(KEY, ciphertext) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decrypt(ciphertext):\n # AES decrypt\n iv = ciphertext[:16]\n ciphertext = ciphertext[16:]\n aes = AES.new(aes_key, AES.MODE_CBC, iv)\n return unpad(aes.decrypt(ciphertext))",
"def AES_decrypt(ciphertext: bytes) -> Text:\n text = b64decode(ciphertext)\n cipher = AES.new(secret_key, mode,... | [
"0.78322375",
"0.7773383",
"0.76747906",
"0.7654733",
"0.7619048",
"0.7461599",
"0.73763734",
"0.73708224",
"0.73604953",
"0.7348656",
"0.7313953",
"0.7302905",
"0.72707146",
"0.72664046",
"0.7230564",
"0.72174984",
"0.7199756",
"0.7146144",
"0.7120665",
"0.7120328",
"0.71192... | 0.71859765 | 17 |
Encrypt ``plaintext`` using the Atbash cipher. | def encrypt(plaintext: str) -> Iterable:
return simplesubstitution.encrypt(KEY, plaintext) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encrypt(plaintext):\n # Pad plaintext\n plaintext = pad(plaintext)\n\n # AES encrypt\n iv = Random.new().read(BS)\n aes = AES.new(aes_key, AES.MODE_CBC, iv)\n return iv + aes.encrypt(plaintext)",
"def encrypt(self, plaintext: str) -> str:\n\n return self.run(plaintext, Cryptography.E... | [
"0.7664223",
"0.75808525",
"0.7366595",
"0.73122513",
"0.72628057",
"0.7151047",
"0.71095973",
"0.70853424",
"0.7013064",
"0.7007951",
"0.7000938",
"0.6868807",
"0.68433076",
"0.6824256",
"0.68010783",
"0.6728267",
"0.66872984",
"0.66638947",
"0.6647861",
"0.6626619",
"0.6533... | 0.70129436 | 9 |
Reading configuration file Returns | def read_config_file(self):
logging.info('INICIANDO: leitura do arquivo de configuração PC.CFG')
config = configparser.ConfigParser()
config.read('config/pc.cfg')
config.sections()
logging.info('FINALIZADO: leitura de arquivo de configuração PC.CFG')
return config.has_section('STEMMER'), config['INPUT']['LE... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_config(self, config_filename):",
"def read_configuration (self):\n\t\tself.config.read(self._configfile)",
"def read_config():\n with open(CONFIG_PATH) as config_file:\n return json.load(config_file)",
"def read_config(self):\n config = configparser.ConfigParser()\n config.re... | [
"0.82731414",
"0.82487226",
"0.7645759",
"0.76453274",
"0.75809246",
"0.7491857",
"0.7444287",
"0.7401327",
"0.7388163",
"0.7383486",
"0.7353306",
"0.7320921",
"0.72839415",
"0.7280581",
"0.7267472",
"0.72558105",
"0.72437257",
"0.7223348",
"0.7204599",
"0.7200702",
"0.719202... | 0.72244793 | 17 |
Gets a text and remove unwanted characters and stopwords | def tokenize_query(self, query_text):
tokenizer = RegexpTokenizer(r'\w+')
stop_words = set(stopwords.words('english'))
abstract = tokenizer.tokenize(query_text.upper())
final_sentence = [w for w in abstract if not w.lower() in stop_words]
return " ".join(final_sentence).upper() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_text ( self, text ) :\n text = BeautifulSoup ( text , \"lxml\" ).text # HTML decoding\n text = text.lower ( ) # lowercase text\n text = REPLACE_BY_SPACE_RE.sub ( ' ' , text ) # replace REPLACE_BY_SPACE_RE symbols by space in text\n text = BAD_SYMBOLS_RE.sub ( '' , text ) #... | [
"0.8261034",
"0.8261034",
"0.8261034",
"0.8261034",
"0.8261034",
"0.8261034",
"0.80761874",
"0.7878042",
"0.781106",
"0.7800905",
"0.7735733",
"0.7683698",
"0.7679524",
"0.7636291",
"0.7591591",
"0.7556787",
"0.75497967",
"0.75274956",
"0.7526585",
"0.7507759",
"0.7490869",
... | 0.0 | -1 |
Defining score according votes | def define_score(self, votes_string):
#2*REW + colleagues + post-doctorate associate + 2* JBW
votes = [int(x) for x in votes_string]
weights = [2,1,1,2]
score = 0
for i in range(0, 4):
if votes[i] >= 0 and votes[i] <= 2:
score += votes[i]*weights[i]
return score | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_score(self, obj):\n content_type = ContentType.objects.get_for_model(obj)\n result = self.filter(content_type=content_type,\n object_id=obj._get_pk_val()).aggregate(\n score=Sum('vote'),\n ... | [
"0.716967",
"0.6934019",
"0.6640118",
"0.66166174",
"0.6604573",
"0.654908",
"0.64828604",
"0.64662987",
"0.6440514",
"0.64305836",
"0.6388617",
"0.63805676",
"0.63544095",
"0.63482374",
"0.6321137",
"0.6302071",
"0.6254929",
"0.62451154",
"0.6213553",
"0.6203114",
"0.6122902... | 0.75115824 | 0 |
Reading xml file and getting content from QueryNumber, QueryText, Results and Records tags | def read_xml(self, xml_name):
logging.info('INICIANDO: leitura do arquivo xml de consultas')
doc = xml.dom.minidom.parse(xml_name)
query_number = doc.getElementsByTagName("QueryNumber")
query_text = doc.getElementsByTagName("QueryText")
results = doc.getElementsByTagName("Results")
records = doc.getElements... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_XML(filename):\n logger_global.info('Reading '+filename+' file...')\n init = time.time()\n \n queries = []\n queries_keys = []\n results = []\n dom_tree = parse(filename)\n query_xml = dom_tree.documentElement.getElementsByTagName(\"QUERY\")\n \n for qu in query_xml:\n ... | [
"0.7173334",
"0.6277773",
"0.6025296",
"0.58326966",
"0.5825554",
"0.57722706",
"0.55968976",
"0.55710435",
"0.5553241",
"0.5421207",
"0.5395721",
"0.53890324",
"0.53667855",
"0.53554547",
"0.5332934",
"0.53212774",
"0.53173196",
"0.529998",
"0.5299098",
"0.5297139",
"0.52959... | 0.7311271 | 0 |
Writing xml file in the query file In the resulting file, it is possible to find all the queries | def generate_query_file(self, query_file, xml_name, apply_stemmer):
if apply_stemmer:
logging.info('INICIANDO: geração de arquivo de consultas com stemmer')
else:
logging.info('INICIANDO: geração de arquivo de consultas sem stemmer')
content = self.read_xml(xml_name)
if apply_stemmer:
query_file = qu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_expected_file(self, expected_file, xml_name):\n\t\tlogging.info('Gerando arquivo de documentos esperados')\n\t\tcontent = self.read_xml(xml_name)\n\n\t\twith open(expected_file, 'w', newline='') as csvfile:\n\t\t\tfieldnames = ['QueryNumber', 'DocNumber', 'DocVotes']\n\t\t\twriter = csv.DictWriter(csv... | [
"0.6497793",
"0.62081456",
"0.62006843",
"0.6157533",
"0.6150465",
"0.615025",
"0.61167115",
"0.60717726",
"0.6031287",
"0.5999682",
"0.59621423",
"0.5887432",
"0.5863373",
"0.5846017",
"0.5824117",
"0.5806362",
"0.58015513",
"0.5782127",
"0.5765131",
"0.5738493",
"0.5731863"... | 0.68933845 | 0 |
Writing xml file in the expected file In the resulting file, it is possible to find all retrieved documents for the queries | def generate_expected_file(self, expected_file, xml_name):
logging.info('Gerando arquivo de documentos esperados')
content = self.read_xml(xml_name)
with open(expected_file, 'w', newline='') as csvfile:
fieldnames = ['QueryNumber', 'DocNumber', 'DocVotes']
writer = csv.DictWriter(csvfile, fieldnames=fieldn... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_output_file(self, xml_text, xml_file):\n xml_fo = open(xml_file, 'w')\n xml_fo.write(xml_text+'</xml>')\n xml_fo.close()\n return",
"def xmlwrite(self, doc, filename):\n pathname = os.path.join(self.session.session_dir, filename)\n f = open(pathname, \"w\")\n ... | [
"0.65399575",
"0.63661104",
"0.63374054",
"0.63239974",
"0.6219125",
"0.62150633",
"0.6206546",
"0.61252916",
"0.6086908",
"0.60831994",
"0.5984633",
"0.5983388",
"0.5897017",
"0.58935225",
"0.5852003",
"0.5838994",
"0.5825246",
"0.5819493",
"0.5794886",
"0.57939947",
"0.5779... | 0.7599953 | 0 |
Main method Reads all files and generate a file with queries and a file with expected documents to each query | def generate_files(self):
apply_stemmer, xml_file, query_file, expected_file = self.read_config_file()
self.generate_query_file(query_file, xml_file, apply_stemmer)
self.generate_expected_file(expected_file, xml_file)
logging.info('FINALIZADO: MÓDULO PROCESSADOR DE CONSULTAS') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n with read_std_files(OUT_FILE) as (qrys_file, docs_file, out_file):\n doc_count, token_count, word_map = map_docs(docs_file)\n avg_doc_len = token_count / float(doc_count)\n for doc_id, doc_tokens in tokenize(docs_file):\n doc_len = len(doc_tokens)\n doc_d... | [
"0.68237984",
"0.6357273",
"0.6356943",
"0.6325044",
"0.63006157",
"0.6190093",
"0.61827916",
"0.61622274",
"0.6130799",
"0.61200684",
"0.6096639",
"0.60336506",
"0.60316324",
"0.60244626",
"0.6006422",
"0.60005426",
"0.5965755",
"0.5961854",
"0.59602106",
"0.5943142",
"0.594... | 0.709213 | 0 |
Method to send the movement commands to the relevant RCSnail car | def send_commands_to_car(self, commands, steering_only=False):
if steering_only:
data = {'steering': commands[0]}
else:
assert len(commands) == 4, 'The input array must have all 4 parameters'
data = {
'steering': commands[0],
'braking... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def drive(self, carstate: State) -> Command:\n command = Command()\n stateList = self.stateToArray(carstate)\n # output = self.network.activate(stateList)\n\n # Set the link to find the file of the one to work with\n if not self.set:\n files = glob.glob(\"cooperation*.... | [
"0.7000707",
"0.66200346",
"0.65237993",
"0.65043175",
"0.64658767",
"0.64266723",
"0.6421654",
"0.64176905",
"0.63326794",
"0.6222958",
"0.61919874",
"0.6152388",
"0.6120059",
"0.610974",
"0.6079726",
"0.60552186",
"0.6035609",
"0.6035609",
"0.602871",
"0.6015453",
"0.597111... | 0.61257654 | 12 |
V_{pi}(s) = sum _{over a_i} {pi(a_i | s) Q(s, a_i)} | def get_value(self, state):
epsilon = self.epsilon
possible_actions = self.get_legal_actions(state)
#If there are no legal actions, return 0.0
if len(possible_actions) == 0:
return 0.0
optimal_action = possible_actions[
np.argmax([self.get_qvalue(state, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def v_o(A,vd):\n return A*vd",
"def Phi(v, p, q):\n \n return np.sum([Y(t,p,q) for t in v])",
"def psi(x, a, q):\n T = q.shape[1]\n covmat = calculate_variance(x + tile(a, [T, 1]).T)\n psi1 = covmat[0, 0] - covmat[1, 1]\n psi2 = covmat[0, 1]\n psi3 = x[0, -1]\n psi4 = x[1, -1]\n\n ... | [
"0.64910585",
"0.61752075",
"0.61417836",
"0.6118552",
"0.6099815",
"0.60564065",
"0.60209495",
"0.59644455",
"0.59644455",
"0.59644455",
"0.59408617",
"0.5937994",
"0.59097135",
"0.59003294",
"0.5872767",
"0.5872767",
"0.5872767",
"0.5872767",
"0.5865587",
"0.5857403",
"0.58... | 0.0 | -1 |
Visualizer for Deep Neural Networks. Solves an inverse problem to find a suited input that minimizes the cost function given in calcCost. | def __init__(self, calcGrad, calcCost, input):
self.calcGrad = calcGrad
self.calcCost = calcCost
self.input = np.asarray(input, dtype=np.float32)
self.inp_shape = input.shape | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, calcGrad, calcCost, input, alpha = 0.01):\n \n\tVisualizer.__init__(self, calcGrad, calcCost, input)\n\n\tself.alpha = alpha",
"def visualize(self):\n\n self.check_model()\n show(prepare(self.model, self.vectorized_data, self.vectorizer, mds='tsne'))",
"def visualize_sal... | [
"0.59802836",
"0.5900457",
"0.58743674",
"0.5754298",
"0.56696457",
"0.560777",
"0.55553436",
"0.55489355",
"0.55174387",
"0.55137515",
"0.5511292",
"0.54651713",
"0.54602545",
"0.5417337",
"0.53927183",
"0.5383849",
"0.5360551",
"0.53586024",
"0.53448915",
"0.53194773",
"0.5... | 0.0 | -1 |
Deep Visualization for Deep Neural Networks. Solves an inverse problem to find a suited input that minimizes the cost function given in calcCost. | def __init__(self, calcGrad, calcCost, input, alpha = 0.01):
Visualizer.__init__(self, calcGrad, calcCost, input)
self.alpha = alpha | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def deep_dream_of_extreme_control(FLAGS,model,input_images=[],num_iterations=10,step_size=0.1):\n if len(input_images) == 0:\n # use predefined images\n img_dir='/esat/opal/kkelchte/docker_home/pilot_data/visualization_images'\n input_images=sorted([img_dir+'/'+f for f in os.listdir(img_dir)])\n\n print... | [
"0.5776294",
"0.5655469",
"0.5644679",
"0.5526504",
"0.5513294",
"0.55041754",
"0.54516816",
"0.5432973",
"0.5399264",
"0.5386139",
"0.5346754",
"0.5345675",
"0.5330562",
"0.53183424",
"0.5296879",
"0.5293629",
"0.52837807",
"0.52808344",
"0.52775186",
"0.52714753",
"0.526823... | 0.54288465 | 8 |
Function that computes the cost value for a given x | def costFun(self, x):
tmp = x.reshape(self.inp_shape)
c = np.float64(self.calcCost(np.asarray(tmp,dtype=np.float32))) + self.alpha * np.dot(x.T, x)
return c | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def costFun(self, S, x):",
"def cost(self,x):\n Mx = self.generate_vector()\n self.prior.M.mult(x,Mx)\n return .5*Mx.inner(x)",
"def final_cost(self, x):\n return self.x_M_x(x[-1,:,:],self.R)",
"def fn(x):\n if x == 0: return 0\n if x < 0: return -inf \n ... | [
"0.8048273",
"0.7995505",
"0.7497831",
"0.74943554",
"0.72771204",
"0.72714454",
"0.724877",
"0.7232135",
"0.72299874",
"0.72011256",
"0.7193746",
"0.7113412",
"0.7009601",
"0.69141775",
"0.68879235",
"0.6861625",
"0.67966616",
"0.67966616",
"0.67889404",
"0.6746737",
"0.6742... | 0.820668 | 0 |
Function that computes the gradient of the cost function at x | def gradFun(self, x):
tmp = x.reshape(self.inp_shape)
g = np.ravel(np.asarray(self.calcGrad(np.asarray(tmp,dtype=np.float32)),dtype=np.float64)) + 2*self.alpha*x
return g | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gradient(self, x):\n pass",
"def gradient(cls, x):\n y = Sigmoid.apply(x)\n return np.multiply(y, 1 - y)",
"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 numerat... | [
"0.77842075",
"0.7665237",
"0.7622198",
"0.7532601",
"0.744385",
"0.74368525",
"0.7415534",
"0.7381988",
"0.7379216",
"0.7374011",
"0.73667705",
"0.7362312",
"0.73497534",
"0.7292546",
"0.72891796",
"0.7286683",
"0.72824043",
"0.72817236",
"0.7221008",
"0.7217221",
"0.7211500... | 0.7418975 | 6 |
Solves the inverse problem | def optimize(self, x0):
(result,f,d) = fmin_l_bfgs_b(lambda x:self.costFun(x), np.ravel(x0),lambda x: self.gradFun(x))
print("optimization completed with cost: " + str(f))
return result.reshape(self.inp_shape) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inverse(self):\n return self.solve(Matrix.I(self.nrows))",
"def inverse(self):\n self.check_square()\n\n\n N = self.rows\n\n inverse = make_matrix(N, N)\n\n # Solve on a per-column basis using Ax = b formalism\n for j in range(N):\n b = make_matrix(N, 1)\n... | [
"0.78967696",
"0.768662",
"0.7365531",
"0.7246305",
"0.7235828",
"0.71719176",
"0.7033936",
"0.69739187",
"0.69531745",
"0.6916821",
"0.6867409",
"0.6858064",
"0.6847429",
"0.68383527",
"0.6826942",
"0.68186474",
"0.6793239",
"0.6787958",
"0.67806756",
"0.67797565",
"0.677384... | 0.0 | -1 |
Subset selection for Deep Neural Networks. Solves an inverse problem to find a suited input that minimizes the cost function given in calcCost. | def __init__(self, calcGrad, calcCost, input, alpha = 0.01, gamma = 0.1):
Visualizer.__init__(self, calcGrad, calcCost, input)
self.alpha = alpha
self.gamma = gamma | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def training_batch_selection(train_set_size, input_img):\n\n input_dims = input_img.shape\n all_data_indices = np.arange(input_dims[0]*input_dims[1])\n all_data_indices = all_data_indices.reshape(input_dims[:-1])\n\n conf = get_config()\n inside = int(np.floor(conf[\"inside_part\"]))\n outside = ... | [
"0.57697535",
"0.562434",
"0.5616341",
"0.5610637",
"0.56050736",
"0.5519219",
"0.5512085",
"0.55078983",
"0.5479911",
"0.5459371",
"0.54215497",
"0.5415881",
"0.5408919",
"0.53455186",
"0.5337947",
"0.532884",
"0.5326981",
"0.5322655",
"0.5321926",
"0.52773917",
"0.5220302",... | 0.0 | -1 |
Function that computes the cost value for a given x | def costFun(self, S, x): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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 cost(self,x):\n Mx = self.generate_vector()\n self.prior.M.mult(x,Mx)\n return .5*Mx.inner(x)",
"def final_cost(self,... | [
"0.820668",
"0.7995505",
"0.7497831",
"0.74943554",
"0.72771204",
"0.72714454",
"0.724877",
"0.7232135",
"0.72299874",
"0.72011256",
"0.7193746",
"0.7113412",
"0.7009601",
"0.69141775",
"0.68879235",
"0.6861625",
"0.67966616",
"0.67966616",
"0.67889404",
"0.6746737",
"0.67426... | 0.8048273 | 1 |
Function that computes the gradient of the cost function at x | def gradFun(self, S, x): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gradient(self, x):\n pass",
"def gradient(cls, x):\n y = Sigmoid.apply(x)\n return np.multiply(y, 1 - y)",
"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 numerat... | [
"0.77842075",
"0.7665237",
"0.7622198",
"0.7532601",
"0.744385",
"0.74368525",
"0.7418975",
"0.7415534",
"0.7381988",
"0.7379216",
"0.7374011",
"0.73667705",
"0.7362312",
"0.73497534",
"0.7292546",
"0.72891796",
"0.7286683",
"0.72824043",
"0.72817236",
"0.7221008",
"0.7217221... | 0.70971864 | 37 |
Solves the inverse problem | def optimize(self, x0, n_iter = 50):
x0 = np.asarray(x0, dtype=np.float32)
opt = proximal_alg.ProximalGradSolver(self.gamma, self.alpha, lambda x: self.costFun(x,self.input), lambda x: np.sum(np.abs(x)), lambda x: self.gradFun(x, self.input), proximal_alg.prox_l1_01)
result = opt.minimize(x0, n_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inverse(self):\n return self.solve(Matrix.I(self.nrows))",
"def inverse(self):\n self.check_square()\n\n\n N = self.rows\n\n inverse = make_matrix(N, N)\n\n # Solve on a per-column basis using Ax = b formalism\n for j in range(N):\n b = make_matrix(N, 1)\n... | [
"0.78967696",
"0.768662",
"0.7365531",
"0.7246305",
"0.7235828",
"0.71719176",
"0.7033936",
"0.69739187",
"0.69531745",
"0.6916821",
"0.6867409",
"0.6858064",
"0.6847429",
"0.68383527",
"0.6826942",
"0.68186474",
"0.6793239",
"0.6787958",
"0.67806756",
"0.67797565",
"0.677384... | 0.0 | -1 |
given a song and an artist, return a uri to that song in Spotify | def get_spotify_uri(song, artist) -> str:
song = re.sub("['|\s]", '%20', song)
artist = re.sub("['|\s]", '%20', artist)
query = "https://api.spotify.com/v1/search?q=track:{}+artist:{}&type=track&offset=0&limit=20".format(
song, artist)
response = requests.get(query, headers={
"Content-... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_spotify_uri(self,song_name, artist):\n query = f\"track:{song_name} artist:{artist}\"\n result = self.sp.search(q=query,limit=1,type='track')\n\n #only use the first song\n if len(result['tracks']['items']) > 0 and result['tracks']['items'][0]['artists'][0]['name'] == artist:\n ... | [
"0.83749163",
"0.73485065",
"0.7067173",
"0.6968523",
"0.68646127",
"0.66602623",
"0.6432892",
"0.632123",
"0.62950456",
"0.61599934",
"0.61227757",
"0.60696423",
"0.606751",
"0.6037092",
"0.59806633",
"0.5964562",
"0.5937355",
"0.5896755",
"0.5891374",
"0.5862065",
"0.585202... | 0.8370671 | 1 |
Parse the trace.txt for each iteration, calculate DVFS residency state/frequencies and dump the result in csv and flush the data for next iteration. | def process_iteration_result(self, result, context):
self.infile = os.path.join(context.output_directory, 'trace.txt')
if os.path.isfile(self.infile):
self.logger.debug('Running result_processor "dvfs"')
self.outfile = os.path.join(settings.output_directory, 'dvfs.csv')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spectrum_parser():\n from tools import file_importer, file_outporter\n from random import random\n # from math import log10\n \n print(\"this is spectrum parser\")\n \n relPath = \"bob/processed/OST-24-05-2017_combined.csv\"\n outPath = \"bob/processed/OST-24-05-2017_combined_no0_spectrum.csv\"\n inpF... | [
"0.5701113",
"0.5631786",
"0.5608315",
"0.55364835",
"0.54893756",
"0.5474661",
"0.5458289",
"0.54296297",
"0.54242486",
"0.5418956",
"0.5402291",
"0.5402081",
"0.53681874",
"0.53458184",
"0.5335917",
"0.53273916",
"0.53256774",
"0.5292377",
"0.5272078",
"0.52447605",
"0.5243... | 0.6252766 | 0 |
Store state, cpu_id for each timestamp from trace.txt and flush all the values for next iterations. | def flush_parse_initialize(self):
self.current_cluster = 0
self.current_frequency_of_clusters = []
self.timestamp = []
self.currentstates_of_clusters = []
self.state_time_map = {}
self.cpuid_time_map = {}
self.cpu_freq_time_spent = {}
self.cpuids_of_cluste... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def record_trace(self):\n\n tfname = str(int(time.time())) + \".obd2_reader.trace\"\n self.tf_out = open(tfname, 'a')\n self.RecordTrace = 1\n print \"Recoding trace to:\", tfname",
"def update_records(self):\n impl.get_runtime().sync()\n self.clear_frontend()\n s... | [
"0.5487987",
"0.5408423",
"0.5171812",
"0.5149306",
"0.5137264",
"0.51059526",
"0.5044956",
"0.50032514",
"0.50026226",
"0.49774602",
"0.4974482",
"0.49592197",
"0.49436066",
"0.49434984",
"0.49397263",
"0.49303812",
"0.4918796",
"0.4905129",
"0.49025974",
"0.48947987",
"0.48... | 0.64534724 | 0 |
Update the cluster frequency and current cluster | def update_cluster_freq(self, state, cpu_id):
# For IKS devices cluster changes only possible when
# freq changes, for other it is determine by cpu_id.
if self.device.scheduler != 'iks':
self.current_cluster = self.get_cluster(cpu_id, state)
if self.get_state_name(state) == "... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def updateClusterInfo(self):\n self.nPoints = len(self.labels)\n self.n = len(np.unique(self.labels))\n self.centers = [ [0.0 for j in range(3)] for i in range(self.n)]",
"def update_cluster(self, cluster, params, *args, **kwargs):\n raise NotImplementedError",
"def add_update... | [
"0.70926946",
"0.6771409",
"0.6328401",
"0.63172925",
"0.6311955",
"0.6175837",
"0.60610443",
"0.6025551",
"0.6025551",
"0.6025551",
"0.6025551",
"0.6025551",
"0.6025551",
"0.59272796",
"0.5923734",
"0.5918287",
"0.58931756",
"0.5863579",
"0.5851121",
"0.5786061",
"0.57628703... | 0.7776443 | 0 |
Update state of each cores in every cluster. This is done for each timestamp. | def update_state(self, state, cpu_id): # pylint: disable=R0912
POWERDOWN = 2
offline_value = -1
# if state is in unknowstate, then change state of current cpu_id
# with cluster freq of current cluster.
# if state is in powerstate then change state with that power state.
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_cores(self):\n num_cores = 0\n for job in self.job_list:\n num_cores += int(job.get_core_info())\n self.cores_used = num_cores\n return",
"def cluster_state(self):\n for ip in set([status.ip for status in self.cluster_status]):\n yield self.node... | [
"0.6780373",
"0.62166446",
"0.60941476",
"0.6064973",
"0.58558685",
"0.5828296",
"0.5750417",
"0.5698166",
"0.559145",
"0.55552137",
"0.5542846",
"0.55281645",
"0.55234426",
"0.55096674",
"0.5472171",
"0.5465183",
"0.5462773",
"0.5457216",
"0.5441518",
"0.5434996",
"0.5420856... | 0.6289924 | 1 |
Determine the unique Frequency and state | def unique_freq(self):
unique_freq = []
for i in self.timestamp:
if self.state_time_map[i] not in unique_freq and self.state_time_map[i] != self.UNKNOWNSTATE:
unique_freq.append(self.state_time_map[i])
for i in self.minimum_frequency_cluster:
if i not in u... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def freq():",
"def freq(self) -> int:",
"def get_frequency(self):\r\n # print '*********in get freq'\r\n self.cntr.run('FREQ 1')\r\n f_0_ = self.cntr.get_measurements(1)\r\n self.f_0 = f_0_[0]\r\n self.cntr.run('FREQ 2')\r\n f_rep_ = self.cntr.get_measurements(1)\r\n ... | [
"0.6752879",
"0.65904456",
"0.6134581",
"0.6110019",
"0.60763687",
"0.6033786",
"0.59830177",
"0.59820443",
"0.59509546",
"0.5918082",
"0.5894775",
"0.5856046",
"0.5792838",
"0.5790568",
"0.5765567",
"0.57557666",
"0.5713634",
"0.5709292",
"0.5696585",
"0.5632066",
"0.5631045... | 0.7312302 | 0 |
Normalize the result with total execution time. | def percentage(self):
temp = self.cpu_freq_time_spent.copy()
for i in self.cpu_freq_time_spent:
total = 0
for j in self.cpu_freq_time_spent[i]:
total += self.cpu_freq_time_spent[i][j]
for j in self.cpu_freq_time_spent[i]:
if total != 0:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize(self):\n total = float(self.totalCount())\n if total != 0:\n self.divideAll(total)",
"def mean_run_time(self) -> float:\n return float(self.result_array.sum(axis=0).mean())",
"def normalize(self):\n total = self.total()\n for x in self.d:\n ... | [
"0.63369775",
"0.62145233",
"0.5956927",
"0.5839907",
"0.5755588",
"0.57369196",
"0.57129204",
"0.57077837",
"0.56347495",
"0.55887246",
"0.5531663",
"0.5496262",
"0.54943055",
"0.54918367",
"0.54862154",
"0.5455096",
"0.54451555",
"0.5443062",
"0.54175466",
"0.53954595",
"0.... | 0.0 | -1 |
generate the '''dvfs.csv''' with the state, frequency and cores | def generate_csv(self, context): # pylint: disable=R0912,R0914
temp = self.percentage()
total_state = self.unique_freq()
offline_value = -1
ghz_conversion = 1000000
mhz_conversion = 1000
with open(self.outfile, 'a+') as f:
writer = csv.writer(f, delimiter=','... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def writeRawFCD():\n global vehId, vehIdDict\n vehIdDict = {}\n vehId = 0\n day = 0\n\n def getVehId(orgId):\n \"\"\"creates new vehicle id's which consists only numerics\"\"\"\n global vehId, vehIdDict\n value = vehIdDict.get(orgId, vehId)\n if value is vehId:\n ... | [
"0.60827273",
"0.5674156",
"0.5534153",
"0.55247027",
"0.5505764",
"0.55022764",
"0.5441504",
"0.53989345",
"0.5363615",
"0.5295529",
"0.5295098",
"0.5272777",
"0.5267846",
"0.5244405",
"0.5212482",
"0.5211538",
"0.5181538",
"0.5169765",
"0.51641446",
"0.5136384",
"0.51107246... | 0.64446026 | 0 |
timer event, that is called at timer timeout | def gameLoop(self):
#f = open("C:/Users/Carsten/Desktop/test.txt","a")
#f.write(str(QtCore.QThread.currentThreadId()) + " - game on server game loop \n")
#f.close()
self.calculate_scene()
self.send_scene_informations() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_timeout(self):\n pass",
"def timer_handler():\r\n \r\n global elapsed_time\r\n elapsed_time += 1",
"def timeout(self):\n self.timeout_scan_flag=True\n self.timer.stop()\n self.status_sig.emit([\"Update_Status\",\"Timeout during acquisition\",'log'])\n self.sta... | [
"0.76686984",
"0.7486532",
"0.7313377",
"0.7291277",
"0.7181817",
"0.69615936",
"0.6915906",
"0.6821288",
"0.68168485",
"0.67896986",
"0.6762602",
"0.6755751",
"0.67511904",
"0.6695119",
"0.66732055",
"0.6667869",
"0.65977186",
"0.6574802",
"0.6542744",
"0.6540145",
"0.653772... | 0.0 | -1 |
updating the direction information, revived from the client | def update_player_direction(self,direction):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_direction(self, update_data: dict):\n if self.on_update_direction:\n self.on_update_direction(self, update_data)",
"def _directionUpdated(self, *args, **kwargs):\n # Invert direction to manipulate the 'source' pointing to\n # the center of the viewport\n x, y, z ... | [
"0.75249773",
"0.6738136",
"0.641039",
"0.62898123",
"0.625545",
"0.62209475",
"0.6207071",
"0.6116505",
"0.610406",
"0.6084203",
"0.6081595",
"0.6042297",
"0.6000609",
"0.59838057",
"0.59476405",
"0.5923903",
"0.59084034",
"0.5897013",
"0.5897013",
"0.5890528",
"0.5885742",
... | 0.7453741 | 1 |
set the inital position of the player, if a player joins the game | def set_player_start_position(self):
if self.field_size.x() == 0: return
parts = len(self.player_list)
y_list = []
for p in range(1,parts+1):
y_list.append(self.field_size.y()*p/(parts+1))
for i,p in enumerate(self.player_list):
p1 = Qt.QPoint(se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_first_player(self):\n if self.player2.won_previous:\n self.current_player = self.player2\n else: self.current_player = self.player1",
"def _drive_player_position(self) -> None:\n player = self._player\n if player:\n assert self.node\n assert pl... | [
"0.67391527",
"0.6602128",
"0.6521799",
"0.64235747",
"0.6403209",
"0.6356068",
"0.6108178",
"0.6093458",
"0.60934067",
"0.6075032",
"0.60552895",
"0.6033364",
"0.597676",
"0.59481853",
"0.58926964",
"0.58049136",
"0.5797736",
"0.5780764",
"0.577982",
"0.5772904",
"0.5766168"... | 0.6329127 | 6 |
game status is changed from hold to go , on game start | def on_game_go(self):
print("============game go")
# create dict with players - defines the players that are playing
self.on_data_to_all_clients({"game":{"hide_all_dialogs":""}})
for pl in self.player_list:
if pl.client not in self.client_pl_dict :
self.clien... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_new_gamestate(self):",
"def update_state(self):\n if not self.platforms:\n self.state = self.states['Win']\n elif self.player.y > 389:\n self.state = self.states['Lose'] \n else:\n self.state = self.states['Game']",
"def update(self):\r\n if ... | [
"0.7380898",
"0.7280429",
"0.6983609",
"0.6962316",
"0.6960264",
"0.6905935",
"0.6833638",
"0.677917",
"0.6773883",
"0.6686437",
"0.66210973",
"0.66116637",
"0.65953153",
"0.6575552",
"0.65732825",
"0.65653706",
"0.6519847",
"0.64996016",
"0.6478882",
"0.64316595",
"0.6426341... | 0.6229725 | 48 |
culculats all status changes in the game for one game loop | def calculate_scene(self):
if self.is_game_going:
for pl in self.player_list:
pl.make_step()
#obj_list = self.player_list + self.foot_list + self.border_list
obj_list = self.player_list + self.grafik_item_list
for pl in self.player_list:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset(self):\r\n self.player_hand.reset()\r\n self.dealer_hand.reset()\r\n self.player_hand.add(self.deck.deal())\r\n self.player_hand.add(self.deck.deal())\r\n self.dealer_hand.add(self.deck.deal())\r\n self.dealer_hand.add(self.deck.deal())\r\n # Checking for ... | [
"0.61955214",
"0.61330974",
"0.6041856",
"0.6010904",
"0.59940135",
"0.59497553",
"0.5944543",
"0.5941799",
"0.5920345",
"0.59200984",
"0.591803",
"0.58926064",
"0.58895403",
"0.58456695",
"0.5832112",
"0.5823152",
"0.5813254",
"0.5792448",
"0.57885593",
"0.5739146",
"0.56946... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.