0 else 1000), values, n_values);\\n \\n actions = []\\n for i in range(self.shield_options):\\n new_action = where(values == max(values))[0]\\n new_action = choice(new_action) \\n values[new_action] = -10000\\n actions.append(new_action)\\n \\n while len(actions) < self.outdim:\\n actions.append(-1)\\n \\n outbuf[:] = actions\",\n \"def forward(self, X):\\n self._X = X # For backprop later on.\\n self._z = np.dot(X, self._W) + self._b\\n a = self._act.a(self._z)\\n return a\",\n \"def forward(self, inputs):\\r\\n #print (len(inputs))\\r\\n out = self.fc1(inputs)\\r\\n out = self.fc2(out)\\r\\n self.out = out\\r\\n return out\\r\\n #raise NotImplementedError('Implement the forward method of the model')\\r\",\n \"def forward(self, state, action):\\n q_in = torch.cat([state, action], 1)\\n return self.ffn(q_in).view(-1)\",\n \"def forward(self, state):\\n x = F.relu(self.fc1(state))\\n x = self.fc2(x)\\n action = self.tanh(x)\\n\\n action = action.cpu().data.numpy() * self.action_lim\\n action = torch.FloatTensor(action)\\n\\n return action\",\n \"def forward(self, x, **kwargs):\\n pass\",\n \"def forward(self, X):\\n # Our input are 4 RGB frames of shape 160, 160 each\\n X = self.conv1(X)\\n X = self.conv2(X)\\n X = self.conv3(X)\\n\\n X_flatten = X.view(X.size(0), -1)\\n value = self.value_fc(X_flatten)\\n value = self.value(value)\\n\\n advantage = self.advantage_fc(X_flatten)\\n advantage = self.advantage(advantage)\\n\\n state_value = value + (advantage - torch.mean(advantage, dim=1, keepdim=True))\\n\\n return state_value\",\n \"def forward(self, x):\\n x, self.hidden = self.gru(x, self.hidden)\\n self.detach_hidden()\\n x = self.dropout(x)\\n x = self.out(x)\\n return x\",\n \"def forward(self, state):\\n x = self.fc1(state)\\n action = self.tanh(x)\\n\\n action = action.cpu().data.numpy() * self.action_lim\\n action = torch.FloatTensor(action)\\n\\n return action\",\n \"def forward(self, state):\\n '''\\n state = F.relu(self.conv1(state))\\n state = F.relu(self.conv2(state))\\n state = F.relu(self.conv3(state))\\n state = F.relu(self.fc1(state))\\n \\n action = F.relu(self.fc2(state))\\n \\n return action\\n '''\\n \\n x = F.relu(self.fc1(state))\\n x = F.relu(self.fc2(x))\\n x = self.fc3(x)\\n \\n return x\",\n \"def forward(self, x):\\n # Pass the input through all the layers apllying ReLU activation, but the last\\n for layer in self.fc_layers[:-1]:\\n x = F.relu(layer(x))\\n # Pass the result through the output layer apllying hyperbolic tangent function\\n x = torch.tanh(self.fc_layers[-1](x))\\n # Return the better action for the input state\\n return x\",\n \"def forward(self, state):\\n x = self.fc(state)\\n return x\",\n \"def forward(self, inputs):\\n _, state = self.core(inputs)\\n return state\",\n \"def forward(self, state, action):\\n\\n # Prepare the embeddings\\n state_embedding = self.state_embedding(state.float())\\n state_embedding = state_embedding.repeat(1, action.shape[1], 1)\\n action_embedding = self.action_embedding(action.float())\\n state_action_embedding = torch.cat((state_embedding, action_embedding),dim=2)\\n\\n # Attention\\n query = self.q_projection(state_action_embedding).permute(1,0,2)\\n key = self.k_projection(state_action_embedding).permute(1,0,2)\\n value = self.v_projection(state_action_embedding).permute(1,0,2)\\n \\n x = self.attention(query, key, value)[0].permute(1,0,2)[:,0,:]\\n\\n # Predict the next state\\n x = self.predict(x)\\n \\n return x\",\n \"def forward(self, observation):\\r\\n # Apply relu activation and feed forward\\r\\n observation = F.relu(self.fc1(observation))\\r\\n actions = self.fc2(observation)\\r\\n\\r\\n return actions\",\n \"def forward(self, x):\\n return x\",\n \"def forward(self, x):\\n\\t\\t#######################################################################\\n\\t\\t# ** START OF YOUR CODE **\\n\\t\\t#######################################################################\\n\\n\\t\\toutput = self._layers[0].forward(x)\\n\\t\\tfor i in range(1, len(self._layers)):\\n\\t\\t\\toutput = self._layers[i].forward(output)\\n\\t\\treturn output\\n\\n\\t\\t#######################################################################\\n\\t\\t# ** END OF YOUR CODE **\\n\\t\\t#######################################################################\",\n \"def forward(self, observation: Tensor) -> Tensor:\\n pass\",\n \"def forward(self, state):\\n\\n # connect layers to each other and put relu activations between them\\n for layer in self.hidden_layers:\\n state = layer(state)\\n state = F.relu(state)\\n value = self.value_layer(state)\\n return value\",\n \"def base_forward(self, x):\\r\\n pass\",\n \"def step(self, action):\\n actions = action.reshape(2, 2)\\n action = {'GoalieBrain': actions[0], 'StrikerBrain': actions[1]}\\n #action = {'GoalieBrain': [5, 5], 'StrikerBrain': [2, 2]}\\n #print(action)\\n info = self.env.step(action)\\n\\n state0 = info[self.brain_names[0]].vector_observations\\n state1 = info[self.brain_names[1]].vector_observations\\n state = np.vstack((state0, state1))\\n reward0 = info[self.brain_names[0]].rewards\\n reward1 = info[self.brain_names[1]].rewards\\n reward = reward0 + reward1\\n done0 = info[self.brain_names[0]].local_done\\n done1 = info[self.brain_names[1]].local_done\\n done = done0 + done1\\n return state, reward, done\",\n \"def forward(self, input=None):\\n if (input is not None) and (self.result is None):\\n self.result = self.act(input)\\n\\n # Pull the input from previous network layers\\n elif self.result is None:\\n in_result = []\\n\\n # Apply a separate activation to each resulting input if applicable\\n if self.G.in_activation:\\n for i, n in enumerate(self.input):\\n in_result.append( self.G.in_activation[i](n()).type(_tensor(\\\"FloatTensor\\\")) )\\n\\n else:\\n for n in self.input:\\n in_result.append( n() )\\n\\n # Concatenate input along the lat dim\\n self.result = self.act(torch.cat(in_result, in_result[0].dim() - 1))\\n\\n return self.result.view(*self.G.d_out)\",\n \"def forward(self, x):\\n self.activations[0] = np.dot(x,self.weights[0]) + self.biases[0]\\n self.zetas[0] = self.activation_f(self.activations[0])\\n for i in range(1, self.n_layers-1):\\n self.activations[i] = np.dot(self.zetas[i-1],self.weights[i]) \\\\\\n + self.biases[i]\\n self.zetas[i] = self.activation_f(self.activations[i])\\n self.activations[-1] = np.dot(self.zetas[-2],self.weights[-1]) \\\\\\n + self.biases[-1]\\n self.zetas[-1] = self.activation_out_f(self.activations[-1])\\n if self.activation_out_function == 'softmax':\\n z = np.sum(self.zetas[-1], axis=1)\\n z = np.reshape(z,(-1,1))\\n self.zetas[-1] = np.divide(self.zetas[-1],z)\\n return self.zetas[-1]\",\n \"def forward(self, x):\\n raise NotImplementedError\",\n \"def forward(self, x):\\n raise NotImplementedError\",\n \"def forward(self, x):\\n\\t\\tx = x.view(-1, self.input_size)\\n\\t\\tout = x\\n\\t\\t\\n\\t\\t# Save the model inputs, which are considered the activations of the 0'th layer.\\n\\t\\tactivations = [out]\\n\\t\\tlinearCombs = []\\n\\n\\t\\tfor layer in self.hidden_layers:\\n\\t\\t\\tlinearComb = layer(out)\\n\\t\\t\\tout = self.act(linearComb)\\n\\n\\t\\t\\t# Save the activations and linear combinations from this layer.\\n\\t\\t\\tactivations.append(out)\\n\\t\\t\\tlinearComb.retain_grad()\\n\\t\\t\\tlinearComb.requires_grad_(True)\\n\\t\\t\\tlinearCombs.append(linearComb)\\n\\n\\t\\tlogits = self.output_layer(out)\\n\\t\\t\\t\\n\\t\\tlogits.retain_grad()\\n\\t\\tlogits.requires_grad_(True)\\n\\t\\tlinearCombs.append(logits)\\n\\t\\t\\n\\t\\treturn (logits, activations, linearCombs)\",\n \"def forward(self, x_in):\\r\\n # x_out = torch.zeros_like(x_in)\\r\\n\\r\\n for layer in self.layers: #Call forward function of each layer in order\\r\\n x_out = layer.forward(x_in)\\r\\n # print(\\\"Forward pass Seq: \\\", layer, x_in, x_out)\\r\\n x_in = x_out # output of the layer is passed as input to the next layer\\r\\n self.temp = x_in\\r\\n return x_out\",\n \"def forward_pass(self, inputs):\\n self._rbf_forward(inputs)\\n self._slp_forward()\\n return self.slp_outputs\",\n \"def forward_propagate(self, input):\\n self.input_matrix[0] = input\\n act_matrix = input\\n for i in range(1, len(self.dimens)):\\n\\n #update our layer of activations\\n act_matrix = self.activation_forward(act_matrix, i)\\n\\n #save our input values for use in back propogating\\n self.input_matrix[i] = act_matrix\\n\\n #send the logistic function of all the inputs to the next layer\\n act_matrix = [logistic(act) for act in act_matrix]\\n\\n return act_matrix\",\n \"def forward(self, x):\\n x = F.relu(self.fc1(x))\\n x = F.relu(self.fc2(x))\\n x = self.fc3(x)\\n return x\",\n \"def forward(self, x):\\r\\n x = self.conv1(x)\\r\\n x = self.conv1_BN(x)\\r\\n x = F.relu(x)\\r\\n x = self.conv1_dp(x)\\r\\n x = self.Block2_1(x)\\r\\n x = self.Block2_2(x)\\r\\n x = self.Block3_1(x)\\r\\n x = self.Block3_2(x)\\r\\n x = self.Block3_3(x)\\r\\n x = self.Block3_4(x)\\r\\n x = self.Block4_1(x)\\r\\n x = self.Block4_2(x)\\r\\n x = self.Block4_3(x)\\r\\n x = self.Block4_4(x)\\r\\n x = self.Block5_1(x)\\r\\n x = self.Block5_2(x)\\r\\n x = self.MP(x)\\r\\n x = x.view(x.size(0),-1)\\r\\n x = self.fc(x)\\r\\n \\r\\n return x\",\n \"def forward(self, input):\\n\\n x = self.conv(input)\\n x = self.bn(x)\\n out = self.act(x)\\n return out\",\n \"def forward(self, x):\\n\\t\\t#######################################################################\\n\\t\\t# ** START OF YOUR CODE **\\n\\t\\t#######################################################################\\n\\n\\t\\tself._cache_current = x\\n\\t\\treturn x @ self._W + self._b\\n\\n\\t\\t#######################################################################\\n\\t\\t# ** END OF YOUR CODE **\\n\\t\\t#######################################################################\",\n \"def forward(self, input_x):\\n adv, val = self.adv_val(input_x)\\n return val + (adv - adv.mean(dim=1, keepdim=True))\",\n \"def forward(self, input_x):\\n adv, val = self.adv_val(input_x)\\n return val + (adv - adv.mean(dim=1, keepdim=True))\",\n \"def forward(self):\\n self.iteration_number += 1\\n x = self.x\\n self.x = self.alpha * self.x + self.betta\\n t = x - self.x\\n\\n return (t * t).sum()\",\n \"def forward_propagation(self):\\n pred_y = argmax(self.model.predict(train_x), axis=1)\\n\\n accuracy_func = Accuracy()\\n accuracy_func.update_state(pred_y, train_y)\\n self.accuracy = accuracy_func.result().numpy()\",\n \"def forward_propagate(self, x):\\n self.z_h = np.dot( x, self.w_ih ) + self.b_h\\n #Activations of hidden layer\\n self.a_h = self.sigmoid( self.z_h )\\n self.z_o = np.dot( self.a_h, self.w_ho ) + self.b_o\\n #yEst = activations of output layer\\n yEst = self.sigmoid( self.z_o )\\n return yEst\",\n \"def forward_propagate(self):\\n for i in range(0, len(self.output_layer)):\\n output = 0\\n\\n # Loop through each Neuron in the hidden layer\\n for neuron in self.hidden_layer:\\n output += neuron.weights[i] * neuron.output\\n\\n # Update summation for output classifier\\n self.output_layer[i] = output\",\n \"def forward(self, inputs):\\n raise NotImplementedError\",\n \"def forward(self, X):\\n # Propaga a entrada pela rede\\n self.z = np.dot(X, self.W1) # Produto escalar da entrada com a primeira matrix de pesos\\n self.z2 = self.sigmoid(self.z) # Função de ativação\\n self.z3 = np.dot(self.z2, self.W2) # Produto escalar da hidden layer com a segunda matrix de pesos\\n return self.sigmoid(self.z3) # Função de ativação na saída \",\n \"def feedForward(self):\\n # Calculate the current values of the first layer\\n self.layer1 = sigmoid(np.dot(self.input, self.weights1))\\n\\n # Calculate the sigmoid of the second layer which is the output\\n self.output = sigmoid(np.dot(self.layer1, self.weights2))\",\n \"def forward(self, x):\\n \\n x = F.relu(self.conv1_bn(self.conv1(self.conv0_bn(x))))\\n x = F.relu(self.conv2_bn(self.conv2(x)))\\n x = F.relu(self.conv3_bn(self.conv3( self.maxpool2(x))))\\n x = F.relu(self.conv4_bn(self.conv4( self.maxpool3(x))))\\n x = self.maxpool4(x) \\n x = x.view(-1, 1184)\\n x = F.relu(self.fc1(x))\\n x = self.dense1_bn(x)\\n x = F.dropout(x, training=self.training)\\n x = self.fc2(x)\\n return F.log_softmax(x)\",\n \"def propagate_forward(self, X):\\n\\n A = X\\n L = self.L - 1\\n\\n for i in range(0, L - 1):\\n Z = np.matmul(self.W[i], A) + self.b[i]\\n cache = ((A, self.W[i], self.b[i]), Z)\\n A = relu(Z)\\n self.caches[i] = cache\\n Z = np.matmul(self.W[L - 1], A) + self.b[L - 1]\\n cache = ((A, self.W[L - 1], self.b[L - 1]), Z)\\n AL = sigmoid(Z)\\n self.caches[L - 1] = cache\\n return AL\",\n \"def go_forward(net):\\n global w, back_loss, loss, l2_loss\\n start_forward_time = time.time()\\n\\n # feed in data\\n P = net(w).t()\\n\\n # calculate loss\\n Y = P.mv(X)\\n Ybar = Y.mean()\\n back_loss = (Y - Ybar).norm(1) / (J)\\n loss = back_loss / Ybar\\n l2_loss = ((Y - Ybar).norm(2) ** 2) / (J * Ybar)\\n\\n return time.time() - start_forward_time\",\n \"def forward(self, states, actions_previous=None):\\n x = states.view(states.shape[0], self.frames_n * self.state_size)\\n \\n # ACTOR\\n x_actor_mus = F.relu(self.actor_layer_1(x))\\n x_actor_mus = F.relu(self.actor_layer_2(x_actor_mus))\\n x_actor_mus = torch.tanh(self.actor_layer_3(x_actor_mus))\\n\\n distribution = torch.distributions.normal.Normal(loc=x_actor_mus, scale=self.actor_sigmas_parameters)\\n actions = actions_previous if actions_previous is not None else distribution.sample() \\n # actions = torch.clamp(actions, -1, 1) # Note: This is one approach, if necessary. Another is to use a Beta distribution\\n # instead of a Normal distribution (see below).\\n densities = torch.exp(distribution.log_prob(actions))\\n entropies = distribution.entropy()\\n \\n # CRITIC\\n x_critic = F.relu(self.critic_layer_1(x))\\n x_critic = F.relu(self.critic_layer_2(x_critic))\\n values = self.critic_layer_3(x_critic)\\n \\n return {\\n 'actions': actions,\\n 'densities': densities,\\n 'entropies': entropies, \\n 'values': values\\n }\",\n \"def forward(self, x): # pylint: disable=invalid-name\\n x = self.layer4(self.layer3(self.layer2(self.layer1(x))))\\n return x.mean((-2, -1))\",\n \"def forward(self, state, action, next_state=None):\\n dim_action, dim_state = self._true_dim_action[0], self.dim_state[0]\\n control_action = action[..., :dim_action]\\n\\n if self.model_kind == \\\"dynamics\\\":\\n optimism_vars = action[..., dim_action : dim_action + dim_state]\\n elif self.model_kind == \\\"rewards\\\":\\n optimism_vars = action[..., -1:]\\n else:\\n raise NotImplementedError(\\n \\\"Hallucinated Models can only be of dynamics or rewards.\\\"\\n )\\n optimism_vars = torch.clamp(optimism_vars, -1.0, 1.0)\\n\\n mean, tril = self.predict(state, control_action)\\n if torch.all(tril == 0.0):\\n return mean\\n\\n if optimism_vars.shape[-1] == 0:\\n return mean, tril\\n\\n self.nst_unc_scale = tril\\n return (\\n mean + self.beta * (tril @ optimism_vars.unsqueeze(-1)).squeeze(-1),\\n torch.zeros_like(tril),\\n )\",\n \"def forward(self, states):\\n raise NotImplementedError()\",\n \"def forward(self, x):\\n # x = state\\n \\n x = F.relu(self.input(x))\\n x = self.output(x)\\n \\n return x\",\n \"def forward(self, x, contextState):\\r\\n \\r\\n #concatenate input and context state\\r\\n #x = x.t()\\r\\n xAndContext = torch.cat((x, contextState), 1)\\r\\n\\r\\n #calculate next context state (hidden output for current t) with tanh(xAndContext * W1)\\r\\n contextState = torch.tanh(xAndContext.mm(self.W1))\\r\\n \\r\\n # Calculates final output\\r\\n output = contextState.mm(self.V)\\r\\n\\r\\n return (output, contextState)\",\n \"def forward(self, x):\\n n, c, t, v = x.size()\\n x1 = x.view(n, c * t, v)\\n y = None\\n for i in range(self.num_subset):\\n A1 = self.PA[i]\\n z = self.conv_d[i](torch.matmul(x1, A1).view(n, c, t, v))\\n y = z + y if y is not None else z\\n A2 = self.cen(x)\\n z2 = torch.matmul(x1, A2).view(n, c, t, v)\\n z2 = self.conv_cen(z2)\\n y += self.lamb * z2\\n y = self.bn(y)\\n y += self.down(x)\\n y = self.relu(y)\\n y = self.attention(y)\\n return y\",\n \"def _forward(self, a):\\n a = np.array(a)\\n self.weighted_layer, self.activations = [], [a]\\n for w, b in zip(self.weights, self.biases):\\n z = w.dot(a) + b\\n a = sigmoid(z)\\n self.weighted_layer.append(z)\\n self.activations.append(a)\\n\\n return a\",\n \"def forward(self, x, act_hidden, crt_hidden):\\n in_dim = x.shape[1]\\n lidar = x[:, :in_dim-4].view(x.shape[0], self.frames, -1) # TODO hard coded\\n others = x[:, in_dim-4:]\\n # action\\n a = F.relu(self.act_fea_cv1(lidar))\\n a = F.relu(self.act_fea_cv2(a))\\n a = a.view(a.shape[0], -1)\\n a = F.relu(self.act_fc1(a))\\n a = torch.cat((a, others), dim=-1)\\n a = F.relu(self.act_fc2(a))\\n act_hidden[0], act_hidden[1] = self.act_lstm(a, act_hidden)\\n mean = torch.tanh(self.actor(act_hidden[0]))\\n\\n logstd = self.logstd.expand_as(mean)\\n std = torch.exp(logstd)\\n action = torch.normal(mean, std)\\n\\n # action prob on log scale\\n logprob = self.log_normal_density(action, mean, std=std, log_std=logstd)\\n\\n # value\\n v = F.relu(self.crt_fea_cv1(lidar))\\n v = F.relu(self.crt_fea_cv2(v))\\n v = v.view(v.shape[0], -1)\\n v = F.relu(self.crt_fc1(v))\\n v = torch.cat((v, others), dim=-1)\\n v = F.relu(self.crt_fc2(v))\\n crt_hidden[0], crt_hidden[1] = self.crt_lstm(v, crt_hidden)\\n v = self.critic(v)\\n\\n return v, action, logprob, mean\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7648056","0.7441679","0.7235342","0.7074458","0.7050156","0.69769365","0.6912717","0.6907993","0.69072765","0.6904189","0.6899755","0.6880525","0.6867396","0.6824801","0.6819598","0.67802507","0.67745304","0.6761813","0.6747654","0.6747654","0.67306876","0.67249095","0.67134327","0.6688794","0.66485","0.6641784","0.65956205","0.658203","0.6575238","0.65729403","0.6566938","0.6540798","0.6538677","0.65245116","0.65022165","0.649793","0.6492027","0.6485671","0.64804494","0.64701587","0.6468531","0.6460872","0.6459993","0.64512163","0.64512163","0.64433086","0.6427071","0.64178354","0.64098865","0.63957405","0.639286","0.6385737","0.63758796","0.6375529","0.6365553","0.6362663","0.63518214","0.6346253","0.6342021","0.63417387","0.6334324","0.6323531","0.6317098","0.6296778","0.62949264","0.62911624","0.62871635","0.6277045","0.6272419","0.626762","0.626762","0.62590796","0.6255834","0.6246275","0.6234197","0.62300086","0.6225553","0.620383","0.6199399","0.61991","0.61991","0.6189103","0.6184866","0.61766875","0.6166288","0.61463654","0.6143733","0.61426806","0.6134586","0.6132924","0.61157095","0.61146396","0.6113235","0.6113077","0.61127657","0.6107415","0.61069703","0.61059296","0.6105154","0.61042464"],"string":"[\n \"0.7648056\",\n \"0.7441679\",\n \"0.7235342\",\n \"0.7074458\",\n \"0.7050156\",\n \"0.69769365\",\n \"0.6912717\",\n \"0.6907993\",\n \"0.69072765\",\n \"0.6904189\",\n \"0.6899755\",\n \"0.6880525\",\n \"0.6867396\",\n \"0.6824801\",\n \"0.6819598\",\n \"0.67802507\",\n \"0.67745304\",\n \"0.6761813\",\n \"0.6747654\",\n \"0.6747654\",\n \"0.67306876\",\n \"0.67249095\",\n \"0.67134327\",\n \"0.6688794\",\n \"0.66485\",\n \"0.6641784\",\n \"0.65956205\",\n \"0.658203\",\n \"0.6575238\",\n \"0.65729403\",\n \"0.6566938\",\n \"0.6540798\",\n \"0.6538677\",\n \"0.65245116\",\n \"0.65022165\",\n \"0.649793\",\n \"0.6492027\",\n \"0.6485671\",\n \"0.64804494\",\n \"0.64701587\",\n \"0.6468531\",\n \"0.6460872\",\n \"0.6459993\",\n \"0.64512163\",\n \"0.64512163\",\n \"0.64433086\",\n \"0.6427071\",\n \"0.64178354\",\n \"0.64098865\",\n \"0.63957405\",\n \"0.639286\",\n \"0.6385737\",\n \"0.63758796\",\n \"0.6375529\",\n \"0.6365553\",\n \"0.6362663\",\n \"0.63518214\",\n \"0.6346253\",\n \"0.6342021\",\n \"0.63417387\",\n \"0.6334324\",\n \"0.6323531\",\n \"0.6317098\",\n \"0.6296778\",\n \"0.62949264\",\n \"0.62911624\",\n \"0.62871635\",\n \"0.6277045\",\n \"0.6272419\",\n \"0.626762\",\n \"0.626762\",\n \"0.62590796\",\n \"0.6255834\",\n \"0.6246275\",\n \"0.6234197\",\n \"0.62300086\",\n \"0.6225553\",\n \"0.620383\",\n \"0.6199399\",\n \"0.61991\",\n \"0.61991\",\n \"0.6189103\",\n \"0.6184866\",\n \"0.61766875\",\n \"0.6166288\",\n \"0.61463654\",\n \"0.6143733\",\n \"0.61426806\",\n \"0.6134586\",\n \"0.6132924\",\n \"0.61157095\",\n \"0.61146396\",\n \"0.6113235\",\n \"0.6113077\",\n \"0.61127657\",\n \"0.6107415\",\n \"0.61069703\",\n \"0.61059296\",\n \"0.6105154\",\n \"0.61042464\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6286952"},"document_rank":{"kind":"string","value":"67"}}},{"rowIdx":4898,"cells":{"query":{"kind":"string","value":"Forward pass through network. Calculates the Q using the value and advantage."},"document":{"kind":"string","value":"def forward(self, input_x):\n adv, val = self.adv_val(input_x)\n return val + (adv - adv.mean(dim=1, keepdim=True))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def forward(self, state):\n x = state\n feature = self.feature_layer(x)\n action_value = self.value_layer(feature)\n advantage = self.advantage_layer(feature)\n \n q_value = action_value + (advantage - advantage.mean(dim=1, keepdim=True))\n return q_value","def advantage(self, state, Q: torch.Tensor = None):\n return Q - Q.max()\n # return Q - torch.matmul(self.π.pmf(state, action_values=Q), Q)","def forward(self, x1, x2):\n return x1 * self.Q + (1 - self.Q) * x2","def Q_net(self, state):\n\t\tif not self._prediction_made: \n\t\t\tQ = tf.matmul(tf.nn.relu( tf.matmul(state, self.weights_hidden) + self.bias_hidden ), self.weights_out) + self.bias_out \n\t\t\tself._Qval = Q\t\n\t\t\tself._prediction_made = True\n\t\treturn self._Qval","def forward(self, state, action):\n state = torch.cat(state, dim=1)\n \n for i in range(len(action)):\n action[i] /= self.max_action\n\n # Concatenate the action vector \n action = torch.cat(action, dim=1)\n x = torch.cat([state, action], dim=1)\n x = F.relu(self.fc1(x))\n x = F.relu(self.fc2(x))\n x = F.relu(self.fc3(x))\n q_value = self.q_out(x)\n\n return q_value","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones = experiences\n\n #simple implementation of a python noob to implement DDQN\n bla = torch.from_numpy(np.zeros(64)).float().to(device)\n for i in range(64):\n bla[i] = self.qnetwork_target(next_states[i]).detach()[self.qnetwork_local(next_states).detach().argmax(1)[i]]\n Q_targets_next = bla.unsqueeze(1)\n #this was my first try of ddqn in python style, but as i said i'm a noob and didn't get it working\n #Q_targets_next = [self.qnetwork_target(next_states).detach()[i] for i in self.qnetwork_local(next_states).detach().argmax(1).unsqueeze(1)]\n \n # Compute Q targets for current states \n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n\n # Get expected Q values from local model\n Q_expected = self.qnetwork_local(states).gather(1, actions)\n\n # Compute loss\n loss = F.mse_loss(Q_expected, Q_targets)\n # Minimize the loss\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)","def forward(self, x):\n q_denom = (x.unsqueeze(1) - self.clusters)**2\n q_denom = q_denom.sum(dim=2)\n q_denom /= self.alpha\n q_denom += 1.0\n q = 1.0 / q_denom\n q = q ** ((self.alpha + 1.0) / 2.0)\n q = q.t() / q.sum(dim=1) # Div shapes [20, 1024] / [1024]\n q = q.t()\n return q","def forward(self, x):\n x = self.fc0(x.view(-1, x.size(-1))).view(x.size(0), x.size(1), -1)\n x = self.pe(x)\n\n x = self.inner_layers(x) # FF, FF, FF, finalFF\n\n state_value = self.fc_s(x) # double-dqn : state\n\n advantage_values = self.fc_a(x) # double-dqn : advantage\n advantage_values = advantage_values.view(\n advantage_values.size()[:-1] + (self.action_size, self.n_atoms))\n\n dist_weights = state_value.unsqueeze(\n dim=-2) + advantage_values - advantage_values.mean(dim=-2, keepdim=True)\n\n return dist_weights","def q1_forward(self, state: torch.Tensor) -> torch.Tensor:\n return self.q_networks[0](state)","def Q(self, states, neural_net_to_use, no_grad = False):\r\n\r\n states = torch.from_numpy(states)\r\n states = states.float()\r\n\r\n if no_grad:\r\n with torch.no_grad():\r\n output = neural_net_to_use(states)\r\n return output\r\n\r\n output = neural_net_to_use(states)\r\n return output","def learn(self):\n ## obtain sample batch using priority based sampling.\n states, actions, rewards, next_states, dones, weights, sample_inds = self.buffer.sample_batch(BETA)\n \n ## obtain the discounted sum of rewards from reward list\n ## also obtain final gamma multiplier\n reduced_rewards, gamma_multipliers = self.reduce_rewards(rewards)\n \n ## convert to tensors\n states = np_to_tensor(states)\n actions = np_to_tensor(actions)\n reduced_rewards = np_to_tensor(reduced_rewards)\n gamma_multipliers = np_to_tensor(gamma_multipliers)\n next_states = np_to_tensor(next_states)\n dones = np_to_tensor(dones)\n weights = np_to_tensor(np.array(weights))\n \n #### Updating Qnet\n \n ## actions from the target actor network\n greedy_actions = self.actor_target(next_states)\n ## compute temporal difference\n targets = reduced_rewards + torch.mul( torch.mul(gamma_multipliers , self.QNetwork_target(next_states, greedy_actions)) , (1-dones).unsqueeze(1))\n Q_sa = self.QNetwork_local(states, actions)\n \n td_error = targets - Q_sa\n \n ## update the priorities using temporal differences\n self.buffer.update_priority(sample_inds,\n (td_error).detach().abs().squeeze().cpu().data.numpy()+REPLAY_EPS)\n \n ## compute the loss, importance sampling weights are used\n loss = ((td_error).pow(2)*weights).mean()\n \n self.QNet_optim.zero_grad()\n loss.backward()\n self.QNet_optim.step()\n \n ### Updating Actor\n pred_actions = self.actor_local(states)\n actor_loss = - self.QNetwork_local(states, pred_actions).mean()\n \n self.actor_optim.zero_grad()\n actor_loss.backward()\n self.actor_optim.step()\n \n #### Polyak Updates\n self.soft_update(self.QNetwork_local, self.QNetwork_target, TAU)\n self.soft_update(self.actor_local, self.actor_target, TAU)","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n Q_Value = 0 #initializing q value\n\n feat_Extractor = self.featExtractor\n\n weight = self.weights #To get the weight to control exploration and exploitation\n\n features = feat_Extractor.getFeatures(state,action) #to get all the features associated with (state,action) pair\n\n for each_feature in features:\n #refer to README_Reinforcement.txt for the formula at line 11\n temp_Qvalue = weight[each_feature] * features[each_feature] #Q(state,action) = w * featureVector where * is the dotProduct operator\n Q_Value = Q_Value + temp_Qvalue\n\n return Q_Value #Returns final qvalue\n #util.raiseNotDefined()","def test_propagate(self):\n # Get network components\n data = array([[0], [1]])\n cdata = LabeledCData(data, labels=array([0, 1]))\n encoder = BinaryEncoding(cdata)\n unitary = ProductAnsatz(1)\n measure = Measurement(1, [0])\n qnn = Network([encoder, unitary, measure], \"1q-qvm\")\n\n # Propagate the zeroth data point\n out = qnn.propagate(0, shots=10)\n\n print(out)","def updateQ_value(self, value):\n self.Q_value = (self.Q_value * self.nVisits + value) / (self.nVisits + 1)","def forward(self, x):\n dims = list(range(1, len(x.shape)))\n mean = x.mean(dim=dims, keepdim=True)\n var = torch.pow(x - mean, 2).mean(dim=dims, keepdim=True)\n return self.apply_gain_and_bias((x - mean) / (var + EPS).sqrt())","def forward(self, state):\n x = F.relu(self.input(state))\n for layer in self.layers:\n x = F.relu(layer(x))\n if self.duel:\n # Value function estimator\n val = F.relu(self.val_fc_input(x))\n val = self.val_fc_output(val)\n # Advantage function estimator\n adv = F.relu(self.adv_fc_input(x))\n adv = self.adv_fc_output(adv)\n # Subtract mean so that V and A are uniquely identifiable for a given Q\n return val + adv - adv.mean(1).unsqueeze(1).expand(state.size(0), self.action_size)\n else:\n return self.output(x)","def forwardPolicyNet(self, state):\n with torch.no_grad():\n q_values = self.policy_net(state)\n return q_values","def getQValue(self, state, action):\n #print \"getQValue in ApproximateQAgent\"\n\n \"*** YOUR CODE HERE ***\"\n weights = self.getWeights()\n features = self.featExtractor.getFeatures(state, action, self)\n\n value = 0\n\n #print \"FEATURES: \", features\n #print \"WEIGHTS: \", weights\n\n for feature in features:\n value += features[feature]*weights[feature]\n return value\n #util.raiseNotDefined()","def getQValue(self, state, action):\n \"\"\"Description:\n [Enter a description of what you did here.]\n Use first equation in slide 71 of MDP to compute q-value depond on weights and current features.\n \n !! But I think what I did is not work for IdentityExtractor. Because feature of IdentityExtrator always return 1,\n it did not change even a ghost is closing.\n \"\"\"\n \"\"\" YOUR CODE HERE \"\"\"\n # if weight is empty, then weight will need to initial to 1 for all features\n # According to which Extractor user choose, weight counter will have equal number of keys.\n if len(self.weight) == 0:\n feat = self.featExtractor.getFeatures(state, action)\n self.weight.incrementAll(feat.keys(), 1)\n \n qValue = self.weight * self.featExtractor.getFeatures(state,action)\n return qValue\n \"\"\" END CODE \"\"\"","def preval_forward(self, data_shot, label_shot, data_query):\n embedding_query = self.encoder(data_query)\n embedding_shot = self.encoder(data_shot)\n logits = self.base_learner(embedding_shot)\n #loss = self.FL(logits, label_shot) + self.CD(logits,label_shot) + self.LS(logits,label_shot)\n loss = self.CD(logits,label_shot)\n grad = torch.autograd.grad(loss, self.base_learner.parameters())\n fast_weights = list(map(lambda p: p[1] - 0.01 * p[0], zip(grad, self.base_learner.parameters())))\n logits_q = self.base_learner(embedding_query, fast_weights)\n\n for _ in range(1, 100):\n logits = self.base_learner(embedding_shot, fast_weights)\n #loss = self.FL(logits, label_shot) + self.CD(logits,label_shot) + self.LS(logits,label_shot)\n loss = self.CD(logits,label_shot)\n grad = torch.autograd.grad(loss, fast_weights)\n fast_weights = list(map(lambda p: p[1] - 0.01 * p[0], zip(grad, fast_weights)))\n logits_q = self.base_learner(embedding_query, fast_weights) \n return logits_q","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones = experiences\n\n # Double DQN. Uses local network for action selection and target network for value estimation\n # see: https://arxiv.org/pdf/1509.06461.pdf\n Q_actions_next = self.dqn_local(next_states).detach().argmax(1).unsqueeze(1)\n Q_targets_next = self.dqn_target(next_states).gather(1, Q_actions_next)\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n # Standard DQN\n # Get max predicted Q values (for next states) from target model\n # Q_targets_next = self.dqn_target(next_states).detach().max(1)[0].unsqueeze(1)\n # Compute Q targets for current states\n # Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n\n # Get expected Q values from local model\n Q_expected = self.dqn_local(states).gather(1, actions)\n\n # Compute loss\n loss = F.mse_loss(Q_expected, Q_targets)\n # Minimize the loss\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.dqn_local, self.dqn_target, TAU)","def forward(self, state_t):\n # Use your network to compute qvalues for given state\n conved_features = self.conv_layers(state_t)\n A = self.head_A(conved_features)\n V = self.head_V(conved_features).repeat(1, self.n_actions)\n mean_A = torch.mean(A, dim=-1, keepdim=True).repeat(1, self.n_actions)\n qvalues = A + V - mean_A\n\n assert qvalues.requires_grad, \"qvalues must be a torch tensor with grad\"\n assert len(\n qvalues.shape) == 2 and qvalues.shape[0] == state_t.shape[0] and qvalues.shape[1] == self.n_actions\n\n return qvalues","def forward(self, value, query, lens):\n relevant_scores = self.relevant_score(value, query, lens)\n e_relevant_scores = torch.exp(relevant_scores)\n weights = e_relevant_scores / e_relevant_scores.sum(-1, keepdim=True)\n attention = (weights.unsqueeze(-1) * value).sum(1)\n return attention","def forward(self):\n R = self.LP.cost.R\n A = self.LP.dyn.A\n B = self.LP.dyn.B\n\n x = self.LP.x0\n self.x[0] = x\n for i in range(self.LP.N):\n u = - np.linalg.inv(R+B.T.dot(self.V[i+1]).dot(B)).dot(.5*B.T.dot(self.W[i+1]) \\\n + B.T.dot(self.V[i+1]).dot(A).dot(x))\n if self.LP.dyn.u_dim == 1:\n self.u[i] = float(u)\n else:\n self.u[i] = u\n self.J_star[i] = float(x.T.dot(self.V[i]).dot(x) + self.W[i].T.dot(x)) #up to constant\n\n if i == 0:\n self.J[i] = self.LP.cost.loss(x, u, i)\n else:\n self.J[i] = self.J[i-1] + self.LP.cost.loss(x, u, i)\n x = self.LP.dyn.next_state(x, u)\n self.x[i+1] = x\n\n self.J[self.LP.N] = self.J[self.LP.N-1] + self.LP.cost.loss(x, 0, self.LP.N)\n\n self.J_star[self.LP.N] = float(x.T.dot(self.V[self.LP.N]).dot(x) \\\n + self.W[self.LP.N].T.dot(x)) #up to constant","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones = experiences\n\n # Get max predicted Q values (for next states) from target model\n Q_targets_next = self.qnetwork_target(\n next_states).detach().max(1)[0].unsqueeze(1)\n \n # Compute Q targets for current states \n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n\n # Get expected Q values from local model\n Q_expected = self.qnetwork_local(states).gather(1, actions)\n\n # Compute loss\n loss = F.mse_loss(Q_expected, Q_targets)\n\n # Minimize the loss\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, self.tau) \n\n return","def learn(self, experiences, gamma):\n self.optimizer.zero_grad()\n\n states, actions, rewards, next_states, dones = experiences\n\n best_actions = self.qnetwork_local(next_states).detach().argmax(1).unsqueeze(1)\n q_values_target = self.qnetwork_target(next_states).detach()\n q_expected = rewards + (gamma * q_values_target.gather(1, best_actions)) * (1 - dones)\n q_current = self.qnetwork_local(states).gather(1, actions)\n\n loss = F.mse_loss(q_expected, q_current)\n\n loss.backward()\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, dqn_agent.TAU)","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n qvalue = 0.0\n for feature_name, value in self.featExtractor.getFeatures(state, action).iteritems():\n qvalue += value * self.weights[feature_name]\n return qvalue","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n qvalue = 0.0\n for feature_name, value in self.featExtractor.getFeatures(state, action).iteritems():\n qvalue += value * self.weights[feature_name]\n return qvalue","def ipdTft(length,gamma,epsilon,alpha = .8):\r\n #possible previous states (what each did in the last iteration)\r\n states = [(\"*\",\"*\"),(\"C\",\"D\"), (\"C\",\"C\"), (\"D\",\"C\"), (\"D\",\"D\")]\r\n #actions: Defect or Cooperate\r\n actions = [\"D\",\"C\"]\r\n #payoff matrix (as dict)\r\n payoff = {(\"C\",\"D\"): (-3,0), (\"C\",\"C\"): (-1,-1), \r\n (\"D\",\"C\"): (0,-3), (\"D\",\"D\"): (-2,-2)}\r\n #initialize learners \r\n\r\n #q1 = qLearn(states,actions,gamma,alpha,epsilon)\r\n #q1 = QLearnCont(ipd_feats,10,actions,gamma,alpha,epsilon,kernel = 'linear')\r\n #q1 = DQN(ipd_feats,10,actions,.99,.5,.1,learn_type = 'linear')\r\n q1 = DQN(ipd_feats,10,actions,.99,.5,.1,shape = (10,10,1))\r\n #initialize list of rewards\r\n rewards = []\r\n #iterate through length states and run the game\r\n prevState = (\"*\",\"*\")\r\n for i in range(length):\r\n #get actions\r\n print(\"Iteration %i:\" %i)\r\n print(\"Previous State:\", prevState)\r\n qa1 = q1.chooseAction(prevState)\r\n qa2 = tft(prevState[0])\r\n print(\"Player 1 Action:\",qa1)\r\n print(\"Player 2 Action:\",qa2)\r\n \r\n #find payoff\r\n newState = (qa1,qa2)\r\n reward = payoff[newState]\r\n rewards.append(reward[0])\r\n print(\"Player 1 Reward:\", reward[0])\r\n print(\"Player 2 Rewards:\", reward[1])\r\n print(\"Current average reward for Player 1:\",np.mean(rewards))\r\n #assign reward and update Q params\r\n q1.qUpdate(prevState,qa1,reward[0],newState)\r\n \r\n prevState = newState\r\n #print(q1.Q)\r\n return(rewards,q1)","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones, weights, indexes = experiences\n\n q_expected, q_targets = self.get_target_and_expected(states, \n actions, \n rewards, \n next_states, \n dones, \n gamma)\n\n #print('q_expected.shape', q_expected.shape)\n #print('q_targets.shape', q_targets.shape)\n \n # Compute loss\n ##### deltas = F.mse_loss(q_expected, q_targets)\n deltas = q_expected - q_targets\n #print('loss.shape', loss.data.cpu().numpy().shape)\n #print('loss', loss)\n \n _sampling_weights = (torch.Tensor(weights)\n .view((-1, 1)))\n \n # mean square error\n loss = torch.mean((deltas * _sampling_weights)**2)\n\n # importance sampling weights used to correct bias introduced \n # by prioritisation experience replay\n # See Annealing the bias https://arxiv.org/abs/1511.05952\n #with torch.no_grad():\n # weight = sum(np.multiply(weights, loss.data.cpu().numpy()))\n # print('weight', weight)\n # loss *= weight\n # print('weights.shape', weights.shape)\n # print('loss type', type(loss))\n # print('loss shape', loss.size())\n # loss *= weights\n # Minimize the loss\n # call zero_grad before calling backward() \n # o.w. gradients are accumulated from multiple passes\n self.optimizer.zero_grad()\n # backward computes dloss/dx for every parameter x\n loss.backward()\n # updates parameters\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU) \n \n # ------------------- update priorities ------------------- # \n priorities = abs(deltas.detach()).numpy()\n #priorities = abs(q_expected.detach() - q_targets.detach()).numpy()\n self.memory.update_priorities(priorities, indexes)","def update(self, state, action, nextState, reward):\n \"\"\"Description:\n Use Q-Learning algoritm in slide 58 of MDP\n \"\"\"\n \"\"\" YOUR CODE HERE \"\"\"\n maxQns = self.getValue(nextState) # get max q-value of next state\n if maxQns == None:\n maxQns = 0\n Qsa = self.getQValue(state, action) #self.qValues[(state, action)]\n difference = reward + self.discountRate * maxQns - Qsa\n self.qValues[(state, action)] += self.alpha * difference\n \n self.vitCount[(state, action)] += 1\n \"\"\" END CODE \"\"\"","def learn(self):\n \n # target parameter update\n # target parameter update\n if self.learn_step_counter % self.nu_iter == 0:\n self.target_net.load_state_dict(self.eval_net.state_dict())\n #testing the preformace of the network\n if self.learn_step_counter == 0:\n print('As referece this first test on dev data. Is maded with the Q networks, initialized randomly : ' )\n else:\n print(\"\\n Lets copy the Q-value Net in to Q-target net!. And test the performace on the dev data: \")\n \n current_bleu = self.dev_network()\n print(\"Current Bleu score is: \", current_bleu)\n \n self.learn_step_counter += 1\n\n \n long_Batch = self.sample_size*3\n # Sampling the higgest rewards values\n b_memory_big = self.memory[np.argsort(-self.memory[:-self.max_output_length, self.state_size+1])][:long_Batch]\n \n sample_index = np.random.choice(long_Batch, self.sample_size)\n b_memory = b_memory_big[sample_index, :]\n\n b_s = torch.FloatTensor(b_memory[:, :self.state_size])\n b_a = torch.LongTensor(b_memory[:, self.state_size:self.state_size+1].astype(int))\n b_r = torch.FloatTensor(b_memory[:, self.state_size+1:self.state_size+2])\n b_s_ = torch.FloatTensor(b_memory[:, self.state_size+2: self.state_size+2 + self.state_size])\n\n b_is_eos = torch.FloatTensor(b_memory[:, self.size_memory1-1:]).view(self.sample_size, 1)\n #print(b_a, b_a.size)\n #print(b_is_eos)\n #Activate the eval_net\n unfreeze_model(self.eval_net)\n \n # q_eval w.r.t the action in experience\n q_eval = self.eval_net(b_s).gather(1, b_a) # shape (batch, 1)\n q_next = self.target_net(b_s_).detach() # detach from graph, don't backpropagate\n #taking the most likely action.\n b_a_ = torch.LongTensor(q_next.max(1)[1].view(self.sample_size, 1).long())\n #b_a_ = q_next.max(1)[0].view(self.sample_size, 1).long() # shape (batch, 1)\n q_eval_next = self.eval_net(b_s_).gather(1, b_a_) # shape (batch, 1)\n \n #If eos q_target = reward. \n q_target = b_r + self.gamma * b_is_eos* q_eval_next.view(self.sample_size, 1) # shape (batch, 1)\n #version 0\n #q_target = b_r + self.gamma * q_next.max(1)[0].view(self.sample_size, 1) # shape (batch, 1)\n \n loss = self.loss_func(q_eval, q_target)\n \n self.tb_writer.add_scalar(\"learn/learn_batch_loss\",\n loss.data, self.learn_step_counter)\n\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n #desctivate the eval_net\n freeze_model(self.eval_net)","def forward(self, x):\n # tracking shapes\n B, C, H, W = x.size()\n K = self.K\n HW_prime = H * W\n\n # get qkv's\n f = self.f(x).view(B, C // K, H * W) # B x (C/K) x (HW)\n g = self.g(x) # B x (C/K) x H x W\n h = self.h(x) # B x (C/2) x H x W\n if self.down_sample:\n g = F.max_pool2d(g, [2, 2]) # B x (C/K) x (H/2) x (W/2)\n h = F.max_pool2d(h, [2, 2]) # B x (C/2) x (H/2) x (W/2)\n HW_prime = HW_prime // 4 # update (HW)'<-(HW) // 4\n\n g = g.view(B, C // K, HW_prime) # B x (C/K) x (HW)'\n h = h.view(B, C // 2, HW_prime) # B x (C/2) x (HW)'\n\n beta = self._dot_product_softmax(f, g) # B x (HW) x (HW)'\n s = torch.einsum('ijk,ilk->ijl', h, beta).view(B, C // 2, H, W) # B x (C/2) x H x W\n return self.gamma * self.v(s) + x # B x C x H x W","def learn(self, experiences, gamma):\n \n states, actions, rewards, next_states, dones = experiences\n\n # Get max predicted Q values (for next states) from target model\n Q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\n # Compute Q targets for current states \n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n\n # Get expected Q values from local model\n Q_expected = self.qnetwork_local(states).gather(1, actions)\n\n # Compute loss\n loss = F.mse_loss(Q_expected, Q_targets)\n # Minimize the loss\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)","def test_forward_values():\n rnn = GeneratorRNN(1)\n inputs = Variable(torch.zeros(1,1,3))\n hidden = rnn.init_hidden()\n e,pi,mu,sigma,rho,_ = rnn(inputs, hidden)\n\n assert (e >= 0).all()\n assert (e <= 1).all()\n\n diff = torch.abs(1-torch.sum(pi))\n assert (diff < 0.00001).all()\n\n assert (sigma > 0).all()\n\n assert (rho > -1).all()\n assert (rho < 1).all()\n\n rnn = GeneratorRNN(3)\n inputs = Variable(torch.zeros(10,1,3))\n hidden = rnn.init_hidden()\n e,pi,mu,sigma,rho,_ = rnn(inputs, hidden)\n\n pi_sum = torch.sum(pi,dim=2)\n diff = torch.abs(1-pi_sum)\n assert (diff < 0.00001).all()","def computeQValueFromValues(self, state, action):\r\n #\r\n weightedVfvsSum = 0\r\n reward = 0\r\n # to get possible next state(s)\r\n for nextState, prob in self.mdp.getTransitionStatesAndProbs(state, action):\r\n reward += self.mdp.getReward(state, action, nextState) * prob\r\n #print \":computeQValueFromValues: nextState is: \", nextState, \" | self.values[nextState] is: \", self.values[nextState]\r\n weightedVfvsSum += prob * self.getValue(nextState)\r\n #\r\n return ( reward + ( self.discount * weightedVfvsSum) ) # making the actual qvalue\r","def learn(self):\n if self.learn_step_counter % self.target_q_update_step == 0:\n self.target_net.load_state_dict(self.eval_net.state_dict()) #update target_net's parameters\n logging.info(\"updtate target q\")\n self.learn_step_counter += 1\n\n rgbs,depths, rgbs_1, depths_1,questions,actions,rewards,terminals = self.memory.sample()\n\n rgbs_var = Variable(torch.FloatTensor(rgbs).cuda())\n depths_var = Variable(torch.FloatTensor(depths).cuda())\n rgbs_1_var = Variable(torch.FloatTensor(rgbs_1).cuda())\n depths_1_var = Variable(torch.FloatTensor(depths_1).cuda())\n questions_var = Variable(torch.LongTensor(questions).cuda())\n actions_var = Variable(torch.LongTensor(actions).cuda())\n rewards_var = Variable(torch.FloatTensor(rewards).cuda())\n terminals_var = Variable(torch.FloatTensor(terminals).cuda())\n\n q_eval_matrix = self.eval_net(rgbs_var,depths_var,questions_var)\n q_eval_matrix = q_eval_matrix.view(-1,9*28*28)\n actions_var = actions_var.view(-1,1)\n q_eval = torch.gather(q_eval_matrix, 1, actions_var) \n q_eval = q_eval.squeeze(1)\n\n q_next_matrix = self.target_net(rgbs_1_var,depths_1_var,questions_var).detach() #don't backward\n q_next_matrix = q_next_matrix.view(-1,9*28*28)\n q_next = torch.max(q_next_matrix,1)[0]\n\n one_var = Variable(torch.ones_like(terminals_var))\n\n q_target = rewards_var + (one_var- terminals_var)*self.discount * q_next\n \n loss = self.loss_func(q_eval, q_target)\n\n\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n self.task_total_loss += loss.item()\n self.task_total_q += q_target.mean()\n self.update_count += 1","def preval_forward(self, data_shot, label_shot, data_query):\n embedding_query = self.encoder(data_query)\n embedding_shot = self.encoder(data_shot)\n logits = self.base_learner(embedding_shot)\n loss = F.cross_entropy(logits, label_shot)\n grad = torch.autograd.grad(loss, self.base_learner.parameters())\n fast_weights = list(map(lambda p: p[1] - 0.01 * p[0], zip(grad, self.base_learner.parameters())))\n logits_q = self.base_learner(embedding_query, fast_weights)\n\n for _ in range(1, 100):\n logits = self.base_learner(embedding_shot, fast_weights)\n loss = F.cross_entropy(logits, label_shot)\n grad = torch.autograd.grad(loss, fast_weights)\n fast_weights = list(map(lambda p: p[1] - 0.01 * p[0], zip(grad, fast_weights)))\n logits_q = self.base_learner(embedding_query, fast_weights) \n return logits_q","def getQvalue(self, state, action):\n featureVector = self.getFeatures(state, action)\n qValue = 0\n for k in featureVector.keys():\n qValue = qValue + self.weights[k] * featureVector[k]\n\n return qValue","def update(self, state, action, nextState, reward):\n \"\"\"Description:\n Use second equation in slide 71 of MDP\n Adjest weight of active features depend on tranistion \n \"\"\"\n \"\"\" YOUR CODE HERE \"\"\"\n feat = self.featExtractor.getFeatures(state, action)\n\n # if weight is empty, then weight will need to initial to 1 for all features\n # According to which Extractor user choose, weight counter will have equal number of keys.\n if len(self.weight) == 0:\n feat = self.featExtractor.getFeatures(state, action)\n self.weight.incrementAll(feat.keys(), 1)\n \n maxQns = self.getValue(nextState)\n if maxQns == None:\n maxQns = 0\n Qsa = self.getQValue(state, action)\n difference = ( reward + self.discountRate * maxQns ) - Qsa\n \n for key in self.weight.keys():\n self.weight[key] += (self.alpha * difference * feat[key])\n \n \n \"\"\" END CODE \"\"\"","def computeQValueFromValues(self, state, action):\n #get the Transition function and nextStates\n state_prob_pair=self.mdp.getTransitionStatesAndProbs(state,action)\n #initialize the value to zero\n actual_value=0\n #iterate over probabilities (transition functions) and next states\n for pair in state_prob_pair:\n #compute qvalue\n actual_value+=pair[1]*(self.mdp.getReward(state,action,pair[0])+self.discount*self.values[pair[0]])\n #print \"The Q value is \",actual_value\n return actual_value","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones, idxs, weights = experiences\n \n\n # Get max predicted Q values (for next states) from target model\n Q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\n # Compute Q targets for current states \n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n\n # Get expected Q values from local model\n Q_expected = self.qnetwork_local(states).gather(1, actions)\n\n # Compute loss MSE\n loss = (Q_expected - Q_targets.detach()).pow(2)\n # Add weights to loss\n loss = loss * weights\n # Add noise to loss to arrive at prior weights\n prios = loss + 1e-6\n # Take mean\n loss = loss.mean()\n\n # Minimize the loss\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # Update buffer priorities\n self.memory.update_priorities(zip(idxs, prios.data.cpu().numpy()))\n\n\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)","def learn(self, state, action, reward, next_state):\r\n\r\n \"\"\"Please Fill Your Code Here.\r\n \"\"\"\r\n self.Q[state][action] = self.Q[state][action] + self.alpha * (reward + self.gamma * max(self.Q[next_state]) - self.Q[state][action])\r\n\r\n return 0","def learn(self):\n batch = self.agent.replay_buffer.sample(self.batch_size)\n states = torch.tensor([x.state for x in batch], dtype=torch.float32).to(self.agent.device) # shape == (batch_size, 3, 6, 7)\n actions = [x.action for x in batch]\n rewards = torch.tensor([x.reward for x in batch], dtype=torch.float32).to(self.agent.device)\n next_states = torch.tensor([x.next_state for x in batch], dtype=torch.float32).to(self.agent.device)\n dones = [x.done for x in batch]\n\n self.optimizer.zero_grad()\n\n\n q_vals = self.agent.policy_net(states)[range(len(actions)), actions] # Q vals for actions taken\n q_next_vals = self.agent.target_net(next_states).detach() # we don't care about grad wrt target net\n q_next_vals[dones] = 0.0 # terminal states have no future expected value\n q_targets = rewards + self.gamma * torch.max(q_next_vals, dim=1)[0]\n\n # all_q_vals = self.agent.policy_net(states)\n # print()\n # print('actions')\n # print(actions)\n # print()\n # print('original all q vals')\n # print(self.agent.policy_net(states)) \n # print(self.agent.policy_net(states).shape)\n # print()\n # print('QVALS:', q_vals)\n # print(q_vals.shape)\n # print('\\n\\n')\n # print('QTARGETS:', q_targets)\n # print(q_targets.shape)\n\n # breakpoint()\n\n loss = self.loss_fn(q_targets, q_vals).to(self.agent.device)\n loss.backward()\n \n # for layer in self.agent.policy_net.named_parameters():\n \n # # print(f'layer: {layer[0]}')\n # # print(f'grad:', layer[1].grad)\n\n # # print('loss', loss)\n # # print('q_vals grad:', q_vals.grad)\n # # print('states:', )\n\n self.optimizer.step()\n\n self.agent.learning_iters += 1\n if self.agent.learning_iters % self.target_update_freq == 0:\n self.agent.update_target_net()\n # logger.info('Updated target net')","def forward(self):\n self.value = np.dot(self.x_node.value, self.w_node.value) + self.b_node.value","def forward(self,\n x: Tensor) \\\n -> Tensor:\n\n x = self.convs[0](x)\n res = x\n for i in range(self.num_rates):\n x = torch.tanh(self.filter_convs[i](\n x)) * torch.sigmoid(self.gate_convs[i](x))\n x = self.convs[i+1](x)\n res = res + x\n return res","def forward(self, x):\n x = self.efficient_net(x)\n return x","def computeQValueFromValues(self, state, action):\n \"*** YOUR CODE HERE ***\"\n qValue = 0\n transitions = self.mdp.getTransitionStatesAndProbs(state, action)\n #print('Transitions: ' + str(transitions))\n for t in transitions:\n nextState, prob = t\n reward = self.mdp.getReward(state, action, nextState)\n #print('Reward: ' + str(reward))\n oneTransition = prob * (reward + self.discount * self.values[nextState])\n qValue = qValue + oneTransition\n return qValue","def learn(self, experiences, gamma):\n\n states, actions, rewards, next_states, dones = experiences\n\n Q_targets = self.get_dqg_target(next_states, rewards, gamma, dones)\n\n # Get expected Q values\n q_exp = self.qnetwork_local(states)\n\n # gets the q values along dimention 1 according to the actions, which is used as index\n # >>> t = torch.tensor([[1,2],[3,4]])\n # >>> torch.gather(t, 1, torch.tensor([[0],[1]]))\n # tensor([[ 1],\n # [ 4]])\n q_exp = q_exp.gather(1, actions)\n\n # compute loss\n loss = F.mse_loss(q_exp, Q_targets)\n\n # reset optimizer gradient\n self.optimizer.zero_grad()\n # do backpropagation\n loss.backward()\n # do optimize step\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, PARAM.TAU)","def forward(self, inp):\n return inp.dot(self.W) + self.b","def learn(self, memory: ReplayMemory, batch_size: int) -> float:\n # 从replay buffer当中采样，从经验回放集合中采样batch_size个样本，计算当前目标Q值\n indices, (state_batch, next_batch, action_batch, reward_batch, done_batch), is_weights = \\\n memory.sample(batch_size)\n # 使用行为网络计算值函数 Q_j\n values = self.__policy(state_batch).gather(1, action_batch)\n \n expected = []\n policy_Q_batch = self.__policy(next_batch).cpu().data.numpy()\n max_action_next = np.argmax(policy_Q_batch, axis=1)\n target_Q_batch = self.__target(next_batch)\n \n for i in range(batch_size):\n if done_batch[i]:\n expected.append(reward_batch[i])\n else:\n target_Q_value = target_Q_batch[i, max_action_next[i]]\n expected.append(reward_batch[i] + self.__gamma * target_Q_value)\n \n expected = torch.stack(expected)\n TD_error = torch.abs(expected - values)\n memory.update(indices, TD_error)\n \n # 根据目标函数 （Q_j - expected)^2来梯度下降\n loss = (torch.FloatTensor(is_weights).to(self.__device) * F.mse_loss(values, expected)).mean()\n\n self.__optimizer.zero_grad()\n loss.backward()\n for param in self.__policy.parameters():\n param.grad.data.clamp_(-1, 1)\n self.__optimizer.step()\n\n return loss.item()","def forward(self, prev_state, obs_t):\r\n # Use your network to compute qvalues for given state\r\n #print(state_t.shape)\r\n h = self.conv(obs_t)\r\n\r\n h = h.view(h.size(0), -1)\r\n\r\n new_state = h_new, c_new = self.lstm(h, prev_state)\r\n advantage = self.adv(h_new)\r\n value = self.val(h_new)\r\n\r\n\r\n adv_mean = torch.mean(advantage, dim=1, keepdim=True)\r\n qvalues = value + advantage - adv_mean\r\n\r\n return new_state, qvalues","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n feature_dictionary = self.featExtractor.getFeatures(state, action)\n\n QValue = 0\n for feature in feature_dictionary:\n QValue += self.weights[feature] * feature_dictionary[feature]\n return QValue","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n feature_dictionary = self.featExtractor.getFeatures(state, action)\n\n QValue = 0\n for feature in feature_dictionary:\n QValue += self.weights[feature] * feature_dictionary[feature]\n return QValue","def update_Q(self, reward):\n old_estimate = self.q_estimates[self.prev_action]\n self.q_estimates[self.prev_action] = old_estimate + 1/self.N[self.prev_action] * (reward - old_estimate)","def test_forward(self):\n # test single input\n self.model.w = np.array([[0.5, 0.25]])\n self.model.b = 0.5\n x = np.array([[0.2, 0.1]])\n out = self.model.forward(x)\n self.assertTrue(np.abs(out[0] - 0.6514) < 0.01)\n\n # test multiple inputs\n self.model.w = np.array([[0.1, 0.2]])\n self.model.b = 0.2\n x = np.array([[0.3, 0.4],\n [0.5, 0.6]])\n out = self.model.forward(x)\n should_be = np.array([0.5769,0.5915])\n self.assertTrue(np.allclose(out, should_be, atol=0.01))","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones, indices = experiences\n\n # Get max predicted Q values (for next states) from target model\n if self.dbl_dqn:\n local_best_actions = self.qnetwork_local(next_states).detach().argmax(1)\n Q_next_states = self.qnetwork_target(next_states)\n Q_targets_next = Q_next_states.gather(1, local_best_actions.unsqueeze(1))\n else:\n Q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\n\n # Compute Q targets for current states\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n\n # Get expected Q values from local model\n Q_expected = self.qnetwork_local(states).gather(1, actions)\n\n # Compute loss\n if self.priority_rpl:\n errors = abs(Q_expected - Q_targets)\n self.memory.update_priorities(indices, errors)\n importance = self.memory.get_importance(indices, self.a, self.b)\n importance = np.array(importance)\n loss = torch.mean(torch.mul(errors.float(), torch.from_numpy(importance).float().to(device)))\n else:\n loss = F.mse_loss(Q_expected, Q_targets)\n\n # Minimize the loss\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()","def back_propagate(self, reward, maxQ):\n\n error = self.alpha * (reward + self.gamma*maxQ - self.value)\n #logging.debug(\"error is now %s\" % (error))\n\n # sigmoid derivate is sigmoid(x) * (1 - sigmoid(x) )\n dsig = self.value * (1 - self.value)\n\n gradient = error * dsig\n #logging.debug(\"gradient is now: %s\" % (gradient))\n\n self.weigths = np.add( self.weights, np.multiply(gradient, self.weights) )\n # self.weights = [gradient * w + w for w in self.weights]","def train(self, Q_pred: torch.FloatTensor, Q_true: torch.FloatTensor) -> float:\n self.dqn.train(mode=True)\n self.optim.zero_grad()\n loss = self.loss_fn(Q_pred, Q_true)\n loss.backward()\n self.optim.step()\n\n return loss","def forward(self, state_t):\n # Use your network to compute qvalues for given state\n qvalues = <YOUR CODE>\n\n assert qvalues.requires_grad, \"qvalues must be a torch tensor with grad\"\n assert (\n len(qvalues.shape) == 2 and \n qvalues.shape[0] == state_t.shape[0] and \n qvalues.shape[1] == n_actions\n )\n\n return qvalues","def forward(self, x, u0=torch.Tensor()):\n x =self.vari_gpu(x)\n u0 =self.vari_gpu(u0)\n \n # input x0 and batch size \n num_batch = x.size(0)\n x0 = x.view(num_batch, -1)\n \n A_hat = self.build_A_block()\n B_hat = self.build_B_block()\n \n # Q_sqrt in QP\n Q = self.Q_sqrt.mm(self.Q_sqrt.t())\n R = self.R_sqrt.mm(self.R_sqrt.t())\n R_diag = self.build_Rdiagnol_block(R)\n Q_hat, Q_diag = self.build_Q_block(Q, Q, R, B_hat)\n Q_sqrt_hat = sqrtm(Q_hat) # computs sqrt of Q\n Q_sqrt_hat = Q_sqrt_hat.repeat(num_batch,1,1) # builds batch\n \n # p in QP p = 2 * (Q_diag*B_hat)^T * (A_hat*x0)\n A_x0 = A_hat.mm(x0.t()).t() # presents[x1;x2;...;xN] size: batch * dim(x1;x2;...;xN)\n p = 2*A_x0.mm(Q_diag.mm(B_hat))\n \n # G in QP\n G1,G2 = self.build_G_block(B_hat)\n G1 = G1.repeat(num_batch,1,1) # builds batch\n G2 = G2.repeat(num_batch,1,1) # builds batch\n \n # h in QP\n h1 = self.h1.repeat(num_batch,1) # builds batch\n h21 = self.h21.repeat(num_batch,1) # builds batch\n h21 -= A_x0 \n h22 = self.h22.repeat(num_batch,1) # builds batch\n h22 += A_x0\n h2 = torch.cat((h21,h22),1)\n \n zero = self.zero.repeat(num_batch,1)\n \n # E in QP\n E = self.E_sqrt.mm(self.E_sqrt.t())\n E_sqrt = self.E_sqrt.repeat(num_batch,1,1)\n \n # for Q(x0,u0), add equality constraint: u(0) = u0 \n if u0.nelement() != 0:\n u0 = u0.view(num_batch, -1)\n # F*z = f\n F = self.F\n f = u0*self.f\n F = F.repeat(num_batch,1,1) # builds batch\n #f = f.repeat(num_batch,1) # builds batch\n# print(Q_sqrt_hat.size(), p.size(), G1.size(),\n# h1.size(), G2.size(),h2.size(),\n# E_sqrt.size(),F.size(),f.size())\n\n self.para = [Q_sqrt_hat, p, G1, h1, G2,\n h2, E_sqrt, F, f]\n u_opt,e_opt, = self.layer(Q_sqrt_hat, p, G1, h1, G2,\n h2, E_sqrt, F, f,zero) # u_opt: batch*dim(u)\n # for V(x0), defines the QP layer without equality \n # constraints \n else:\n layer = QP_layer_no_eq(nz=self.num_u, nineq_u=\n self.num_ineq_u, nineq_x=self.num_ineq_x)\n self.para = [Q_sqrt_hat, p, G1, h1, G2,\n h2, E_sqrt] \n # gets the solution of the basic optimization problem\n u_opt,e_opt, = layer(Q_sqrt_hat, p, G1, h1, G2, h2, \n E_sqrt,zero) # u_opt: batch*dim(u)\n\n # get the optimal cost\n # a+b: sum(i:1 to N): xi^T*Q*xi + u(i-1)^T*R*u(i-1)\n # c: x0^T*Q*x0\n # d:(i:1 to N):ei^T*E*ei\n a = (u_opt.mm(Q_hat)*u_opt + p*u_opt).sum(1)\n b = (A_x0.mm(Q_diag)*A_x0).sum(1)\n c = (x0.mm(Q)*x0).sum(1)\n d = (e_opt.mm(E)*e_opt).sum(1)\n cost_opt = (a+b+c+d).unsqueeze(1) # size: batch*1\n u0_opt = u_opt.mv(self.weight) # only the fisrt action\n #print(u0,u0_opt)\n return cost_opt, u0_opt","def forward(self, x: torch.Tensor) -> torch.Tensor:\n return torch.nn.functional.linear(\n x,\n self.weight_mu + self.weight_sigma * self.weight_epsilon,\n self.bias_mu + self.bias_sigma * self.bias_epsilon,\n )","def forward(self, X):\n self._X = X # For backprop later on.\n self._z = np.dot(X, self._W) + self._b\n a = self._act.a(self._z)\n return a","def computeQValueFromValues(self, state, action):\n \"*** YOUR CODE HERE ***\"\n transition_state_probs = self.mdp.getTransitionStatesAndProbs(state, action)\n # Add each state and probability to q_value\n q_value = 0\n for state_, probability in transition_state_probs:\n state_reward = self.mdp.getReward(state, state_, action)\n q_value += probability * (state_reward + self.discount * self.values[state_])\n return q_value","def update_q_values(self, state, value):\n if self.prev_state is not None and self.learning:\n reward = self.reward(Game.game_state(state))\n self.q_values[self.represent_state(self.prev_state), self.prev_action] += self.alpha * (\n reward + self.gamma * value - self.prev_q_val)","def forward(self, state_t):\n # Use your network to compute qvalues for given state\n qvalues = self.network(state_t)\n\n assert qvalues.requires_grad, \"qvalues must be a torch tensor with grad\"\n assert len(\n qvalues.shape) == 2 and qvalues.shape[0] == state_t.shape[0] and qvalues.shape[1] == self.n_actions\n\n return qvalues","def forward(self, w_value, x_value, b_value):\n self.inputs = [w_value, x_value, b_value]\n # return np.matmul(x_value, w_value) + b_value # [Note] Matmul Order\n return x_value.dot(w_value) + b_value # [Note] Matmul Order","def forward(self, state_t):\n # Use your network to compute qvalues for given state\n conved_1 = self.conv1(state_t)\n conved_2 = self.conv2(conved_1)\n conved_3 = self.conv3(conved_2)\n qvalues = self.dense(conved_3)\n\n assert qvalues.requires_grad, \"qvalues must be a torch tensor with grad\"\n assert len(\n qvalues.shape) == 2 and qvalues.shape[0] == state_t.shape[0] and qvalues.shape[1] == n_actions\n\n return qvalues","def forward(self, state, action):\n # Pass the states into the first layer\n x = self.fc_layers[0](state)\n x = self.bn(x)\n x = F.relu(x)\n # Concatenate the first layer output with the action\n x = torch.cat((x, action), dim=1)\n # Pass the input through all the layers apllying ReLU activation, but the last\n for layer in self.fc_layers[1:-1]:\n x = F.relu(layer(x))\n # Pass the result through the output layer apllying sigmoid activation\n x = torch.sigmoid(self.fc_layers[-1](x))\n # Return the Q-Value for the input state-action\n return x","def computeQValueFromValues(self, state, action):\n\n ##util.raiseNotDefined()\n #\"*** YOUR CODE STARTS HERE ***\"\n # Code to remove --- from here\n transitions = self.mdp.getTransitionStatesAndProbabilities(state, action)\n qvalue = 0\n for (nextState, probability) in transitions:\n reward = self.mdp.getReward(state, action, nextState)\n qvalue += probability *(reward + self.discount*self.values[nextState])\n # Code to remove --- to here\n #\"*** YOUR CODE FINISHES HERE ***\"\n \n return qvalue","def training_step(self):\n self.iteration += 1\n # if not enough replay memories\n if self.iteration < self.params.min_replays:\n # skip training\n return\n # sample memories\n states_val, action_val, rewards, next_state_val, continues \\\n = (rl.tools.sample_memories(self.memory, self.params.batch_size))\n # evaluate the target q\n target_q = self.sess.run(self.graph.target_q_values, feed_dict={self.graph.states: next_state_val})\n # if using double q\n if self.params.double_q:\n online_q = self.sess.run(self.graph.online_q_values, feed_dict={self.graph.states: next_state_val})\n actions = np.argmax(online_q, axis=1)\n max_next_q_values = target_q[np.arange(actions.shape[0]), actions].reshape(-1, 1)\n else:\n max_next_q_values = np.max(target_q, axis=1, keepdims=True)\n # train the online DQN\n td_target = rewards + continues * self.params.discount_factor * max_next_q_values\n _, self.loss_val = self.sess.run([self.graph.training_op, self.graph.loss],\n feed_dict={self.graph.states: states_val, self.graph.actions: action_val,\n self.graph.td_target: td_target})\n # copy to target\n if self.params.copy_interval is None or (\n self.params.copy_interval and (self.iteration % self.params.copy_interval == 0)):\n self.sess.run(self.graph.copy_online_to_target)","def train_step(self, experiences, gamma):\n states = experiences['states']\n rewards = experiences['rewards']\n actions = experiences['actions']\n next_states = experiences['next_states']\n dones = experiences['dones']\n q_values = self.main_network(states).gather(1, actions.view(-1, 1)).squeeze()\n\n # Get max predicted Q values (for next states) from target model\n next_q_values = self.target_network(next_states).detach().max(1)[0]\n\n # Compute Q targets for current states\n expected_q_value = rewards + (gamma * next_q_values * (1 - dones))\n\n # Compute loss\n loss = F.mse_loss(q_values, expected_q_value)\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # Update the target network\n self.soft_update(self.main_network, self.target_network, TAU)","def forward(self, state):\n if self.noisy:\n lower, upper = self.x[0], self.x[-1]\n test_x = lower + torch.rand(len(self.x)) * (upper - lower)\n else:\n test_x = self.x\n\n with torch.no_grad(), gpytorch.settings.fast_pred_var():\n pred = self.gp(test_x)\n ucb = pred.mean + self.beta() * pred.stddev\n\n max_id = torch.argmax(ucb)\n next_point = test_x[[[max_id]]]\n return next_point, torch.zeros(1)","def Q(self, value):\n assert value > 0, \"Q needs to be positive and above zero (we divide by Q)\"\n self._Q = value\n self._update()","def update_policy(self, minibatch_size):\n \n steps = self.rewards.shape[0]\n batch_size = self.rewards.shape[0] * self.rewards.shape[1]\n #steps = 500\n #batch_size = 500\n #print(steps)\n #print(batch_size)\n \n # Compute advantages\n '''\n with torch.no_grad():\n if self.gae:\n advantages = torch.zeros_like(self.rewards).to(self.training_device)\n lastgaelam = 0\n for t in reversed(range(steps)):\n if t == steps - 1:\n nextnonterminal = 1.0 - self.dones[t]\n nextvalues = self.state_values[t]\n else:\n nextnonterminal = 1.0 - self.dones[t + 1]\n nextvalues = self.state_values[t + 1]\n delta = self.rewards[t] + self.gamma * nextvalues * nextnonterminal - self.state_values[t]\n advantages[t] = lastgaelam = delta + self.gamma * self.gae_lambda * nextnonterminal * lastgaelam\n returns = advantages + self.state_values\n else:\n returns = torch.zeros_like(self.rewards).to(self.training_device)\n for t in reversed(range(steps)):\n if t == steps - 1:\n nextnonterminal = 1.0 - self.dones[t]\n next_return = self.state_values[t]\n else:\n nextnonterminal = 1.0 - self.dones[t+1]\n next_return = returns[t+1]\n returns[t] = self.rewards[t] + self.gamma * nextnonterminal * next_return\n advantages = returns - self.state_values\n ''' \n returns = torch.zeros_like(self.rewards).to(self.training_device)\n for t in reversed(range(steps)):\n if t == steps - 1:\n nextnonterminal = 1.0 - self.dones[t]\n next_return = self.state_values[t]\n else:\n nextnonterminal = 1.0 - self.dones[t+1]\n next_return = returns[t+1]\n returns[t] = self.rewards[t] + self.gamma * nextnonterminal * next_return\n advantages = returns - self.state_values\n \n\n # flatten the batch\n #b_obs = self.states.reshape((-1,) + self.state_space)\n #print(self.states.shape)\n b_obs = self.states.reshape((-1,4)).detach()\n b_logprobs = self.action_probs.reshape(-1,1).detach()\n b_actions = self.actions.reshape((-1,)).detach()\n b_advantages = advantages.reshape(-1,1)\n b_returns = returns.reshape(-1,1)\n b_values = self.state_values.reshape(-1,1)\n \n # Optimize policy and value network for K epochs, run optimization in minibatches\n \n inds = np.arange(batch_size)\n for i_epoch_pi in range(self.epochs):\n np.random.shuffle(inds)\n for start in range(0, batch_size, minibatch_size):\n end = start + minibatch_size\n minibatch_ind = inds[start:end]\n mb_advantages = b_advantages[minibatch_ind]\n if self.norm_adv:\n mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)\n \n #_, newlogproba, entropy = self.get_action(b_obs[minibatch_ind], b_actions[minibatch_ind])\n newlogproba, entropy = self.evaluate(b_obs[minibatch_ind], b_actions[minibatch_ind])\n #ratio = (newlogproba - b_logprobs[minibatch_ind]).exp()\n ratio = torch.exp((newlogproba - b_logprobs[minibatch_ind].detach()))\n \n # Stats\n approx_kl = (b_logprobs[minibatch_ind] - newlogproba).mean()\n\n # Policy loss\n pg_loss1 = -mb_advantages * ratio\n pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - self.clip_epsilon, 1 + self.clip_epsilon)\n pg_loss = torch.max(pg_loss1, pg_loss2).mean()\n entropy_loss = entropy.mean()\n\n # Value loss\n _, new_values = self.policy.forward(b_obs[minibatch_ind])\n if self.clip_vloss:\n \n v_loss_unclipped = self.MseLoss(new_values,b_returns[minibatch_ind])\n #v_loss_unclipped = ((new_values - b_returns[minibatch_ind]) ** 2)\n v_clipped = b_values[minibatch_ind] + torch.clamp(new_values - b_values[minibatch_ind],\n -self.clip_epsilon, self.clip_epsilon)\n #v_loss_clipped = (v_clipped - b_returns[minibatch_ind]) ** 2\n v_loss_clipped = self.MseLoss(v_clipped,b_returns[minibatch_ind])\n v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)\n #v_loss = 0.5 * v_loss_max.mean()\n v_loss = 0.5 * v_loss_max\n else:\n #v_loss = 0.5 * ((new_values - b_returns[minibatch_ind]) ** 2).mean()\n v_loss = self.MseLoss(new_values,b_returns[minibatch_ind])\n\n loss = pg_loss + v_loss * self.vf_coeff - self.ent_coeff * entropy_loss\n\n self.optimizer.zero_grad()\n loss.backward()\n torch.nn.utils.clip_grad_norm_(self.policy.parameters(), self.max_grad_norm)\n self.optimizer.step()\n # Copy new weights into old policy:\n self.old_policy.load_state_dict(self.policy.state_dict())","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n # OUR CODE HERE\n #get the value of the state\n qVal = self.values[state]\n #iterate through the MDP transition states from the current state\n for transitionState, probability in self.mdp.getTransitionStatesAndProbs(state, action):\n #q value = discount * expected value of reward of state\n qVal += self.discount * probability * self.values[transitionState]\n return qVal\n # END OUR CODE","def update(self, state, action, nextState, reward):\n \"*** YOUR CODE HERE ***\"\n Q_Value = self.Q #calling constructor\n\n learning_rate = self.alpha #gives us the learning rate\n\n temporary_QValue = self.getQValue(state,action) #to get the Q value of the state\n\n nextState_QValue = self.getValue(nextState) #to get the Q value of the landing state when taken action a and state s\n\n discount_factor = self.discount #to get the gamma/ discount factor\n\n\n Q_Value[(state,action)] = ((1-learning_rate) * temporary_QValue) + (learning_rate * (reward + discount_factor * nextState_QValue)) #for formula go to README_Reinforcement.txt at line 8\n\n #util.raiseNotDefined()","def train_step(self):\n # Sample training batch from replay\n training_batch = self.replay.sample(self.batch_size)\n\n # Calculate target Q values for each example:\n # For non-terminal states, targetQ is estimated according to\n # targetQ = r + gamma*Q'(s',max_a Q(s',a))\n # where Q' denotes the target network.\n # For terminating states the target is computed as\n # targetQ = r\n updates = []\n for exp in training_batch:\n start,_,reward,end = exp\n if(self.dampen_states):\n # To dampen states (usually done after major patches or when the meta shifts)\n # we replace winning rewards with 0.\n reward = 0.\n state_code = end.evaluate()\n if(state_code==DraftState.DRAFT_COMPLETE or state_code in DraftState.invalid_states):\n # Action moves to terminal state\n updates.append(reward)\n else:\n # Follwing double DQN paper (https://arxiv.org/abs/1509.06461).\n # Action is chosen by online network, but the target network is used to evaluate this policy.\n # Each row in predicted_Q gives estimated Q(s',a) values for all possible actions for the input state s'.\n feed_dict = {self.ddq_net.online_ops[\"input\"]:[end.format_state()],\n self.ddq_net.online_ops[\"valid_actions\"]:[end.get_valid_actions()]}\n predicted_action = self.ddq_net.sess.run(self.ddq_net.online_ops[\"prediction\"], feed_dict=feed_dict)[0]\n\n feed_dict = {self.ddq_net.target_ops[\"input\"]:[end.format_state()]}\n predicted_Q = self.ddq_net.sess.run(self.ddq_net.target_ops[\"outQ\"], feed_dict=feed_dict)\n\n updates.append(reward + self.ddq_net.discount_factor*predicted_Q[0,predicted_action])\n\n # Update online net using target Q\n # Experience replay stores action = (champion_id, position) pairs\n # these need to be converted into the corresponding index of the input vector to the Qnet\n actions = np.array([start.get_action(*exp[1]) for exp in training_batch])\n targetQ = np.array(updates)\n feed_dict = {self.ddq_net.online_ops[\"input\"]:np.stack([exp[0].format_state() for exp in training_batch],axis=0),\n self.ddq_net.online_ops[\"actions\"]:actions,\n self.ddq_net.online_ops[\"target\"]:targetQ,\n self.ddq_net.online_ops[\"dropout_keep_prob\"]:0.5}\n _ = self.ddq_net.sess.run(self.ddq_net.online_ops[\"update\"],feed_dict=feed_dict)","def learn(self, experiences, gamma):\n states_and_prev_recurrents, actions, recurrents, rewards, next_states, dones = experiences\n\n # Get max predicted Q values (for next states) from target model\n next_states_and_recurrents = torch.cat([next_states, recurrents], dim=1)\n Q_targets_next = self.qnetwork_target(next_states_and_recurrents).detach().max(1)[0].unsqueeze(1)\n # Compute Q targets for current states\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n\n # Get expected Q values from local model\n Q_expected = self.qnetwork_local(states_and_prev_recurrents).gather(1, actions)\n\n # Compute loss\n loss_rl = F.mse_loss(Q_expected, Q_targets)\n\n states = states_and_prev_recurrents[:, :8]\n target_recurrents = map_observation_to_recurrent_state(states)\n recurrent_pred = self.qnetwork_local(states_and_prev_recurrents)[:, -5:]\n\n loss_internal_states = F.multilabel_soft_margin_loss(recurrent_pred, target_recurrents)\n\n loss = loss_rl + loss_internal_states\n\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)","def learn(self, experiences, gamma):\n states, actions, rewards, next_states = experiences\n\n # Get max predicted Q values (for next states) from target model\n next_action_targets = self.target_model(next_states)\n next_action = next_action_targets.max(1)[0].unsqueeze(-1)\n targets = rewards + (gamma * torch.Tensor(next_action))\n#\n # Get expected Q values from policy model\n action_policy = self.policy_model(states)\n policy = action_policy.gather(1, actions)\n # Compute loss\n loss = F.mse_loss(policy, targets)\n # Minimize the loss\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.policy_model, self.target_model, self.tau)","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n qvalue = 0\n features = self.featExtractor.getFeatures(state, action)\n #Each feature is in the form of dictionary {((3, 3), 'east'): 1.0}. Each key is a combination of coordinate and direction. Each value represents the old qvalue.\n for feature in features.keys():\n qvalue += features[feature] * self.weights[feature]\n return qvalue","def learn(self, state, action, reward, state_):\n self.Q.optimizer.zero_grad()\n states = T.tensor(state, dtype=T.float).to(self.Q.device)\n action = T.tensor(action).to(self.Q.device)\n reward = T.tensor(reward).to(self.Q.device)\n states_ = T.tensor(state_, dtype=T.float).to(self.Q.device)\n\n q_pred = self.Q.forward(states)[action]\n\n q_next = self.Q.forward(states_).max()\n\n q_target = reward + self.gamma*q_next\n\n loss = self.Q.loss(q_target, q_pred).to(self.Q.device)\n loss.backward()\n self.Q.optimizer.step()\n self.decrement_epsilon()","def getQValue(self, gameState, action):\n features = self.getFeatures(gameState, action)\n return features * self.weights","def computeQValueFromValues(self, state, action):\n\n # Find expected utility of making this move\n x = 0\n for t in self.mdp.getTransitionStatesAndProbs(state,action):\n x += t[1] * self.getValue(t[0])\n\n\n # Return Reward + discounted expected utility\n return self.mdp.getReward(state,None,None) + self.discount*x","def act(self, state_and_prev_recurrent, eps=0.):\n state_and_prev_recurrent = torch.from_numpy(state_and_prev_recurrent).float().unsqueeze(0).to(device)\n self.qnetwork_local.eval()\n with torch.no_grad():\n action_values = self.qnetwork_local(state_and_prev_recurrent)[:, :4]\n self.qnetwork_local.train()\n\n # Epsilon-greedy action selection\n if random.random() > eps:\n return np.argmax(action_values.cpu().data.numpy())\n else:\n return random.choice(np.arange(self.action_size))","def q_update(self):\n\n # exit if the experience buffer is not yet large enough\n if self.experience_buffer.size < self.batch_size:\n return\n \n # get the random batch\n states, action_indices, rewards, not_terminals, succ_states, succ_players, succ_legal_moves = self.experience_buffer.random_batch(self.batch_size)\n states = states.to(Globals.device)\n action_indices = action_indices.to(Globals.device)\n rewards = rewards.to(Globals.device)\n not_terminals = not_terminals.to(Globals.device)\n succ_states = succ_states.to(Globals.device)\n succ_players = succ_players.to(Globals.device)\n\n # prepare the training data\n q_values = self.target_network(succ_states)\n target = torch.empty(1, self.batch_size)\n for i in range(self.batch_size):\n if not_terminals[i] == 0:\n target[0, i] = rewards[i]\n continue\n\n if succ_players[i] == CONST.WHITE_MOVE:\n legal_q_values = q_values[0, 0:9][succ_legal_moves[i]]\n q_value, _ = legal_q_values.max(0)\n else:\n legal_q_values = q_values[0, 9:18][succ_legal_moves[i]]\n q_value, _ = legal_q_values.min(0)\n\n target[0, i] = rewards[i] + self.disc*not_terminals[i]*q_value\n\n # execute the training step of the network\n self.training_network.train_step(states, target, action_indices) # the eligibility trace is used as td target","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones = experiences\n # print('learn states.shape', states.shape)\n # print('learn next_states.shape', next_states.shape)\n \n q_expected, q_targets = self.get_target_and_expected(states, \n actions, \n rewards, \n next_states, \n dones, \n gamma)\n\n\n # Compute loss\n loss = F.mse_loss(q_expected, q_targets)\n # Minimize the loss\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)","def forward(self, x):\n # Compute the mean norm of activations per channel.\n nu2 = x.pow(2).mean(dim=[2, 3], keepdim=True)\n\n # Perform FRN.\n x = x * torch.rsqrt(nu2 + self.eps.abs())\n\n # Scale and Bias\n if self.is_scale:\n x = self.weight * x\n if self.is_bias:\n x = x + self.bias\n return x","def forward(self, x):\n n, c, t, v = x.size()\n x1 = x.view(n, c * t, v)\n y = None\n for i in range(self.num_subset):\n A1 = self.PA[i]\n z = self.conv_d[i](torch.matmul(x1, A1).view(n, c, t, v))\n y = z + y if y is not None else z\n A2 = self.cen(x)\n z2 = torch.matmul(x1, A2).view(n, c, t, v)\n z2 = self.conv_cen(z2)\n y += self.lamb * z2\n y = self.bn(y)\n y += self.down(x)\n y = self.relu(y)\n y = self.attention(y)\n return y","def update1(self, state, action, nextState, reward):\n #print \"update1 in ApproximateQAgent\"\n \"*** YOUR CODE HERE ***\"\n ##################################################################################################################################Eric Did Stuff\n actionList = nextState.getLegalActions(self.index)\n\n\n #print \"Action List\", actionList\n\n\n\n\n weights = self.getWeights()\n\n features = self.featExtractor.getFeatures(state, action, self)\n #self.myFeats = features\n if self.index == 0:\n print \"FEATURES: \",features\n value = self.computeValueFromQValues(nextState)\n qValue = self.getQValue(state,action)\n #print \"value\", value, \"qValue\", qValue\n for feature in features:\n if len(actionList) != 0:\n weights[feature] = weights[feature] + self.alpha * (reward + self.discount * value - qValue) * features[feature]\n else:\n weights[feature] = weights[feature] + self.alpha * (reward - qValue) * features[feature]\n #print \"feature\", feature, \"weights\", weights[feature]\n #print \"weights\", weights\n\n #util.raiseNotDefined()","def update_value(self, reward):\n\t\tval = self.value\n\t\tval = val + ((reward - val)/self.visited)\n\t\tself.value = val","def qlearning(env, iterations=1000, gamma=0.9, alpha=0.1):\n nS = env.nS # number of states\n nA = env.nA # number of actions\n Q_value = np.zeros((nS, nA))\n policy = np.ones((env.nS,env.nA))/env.nA\n epsilon = 1\n s_t1 = env.reset() # reset the environment and place the agent in the start square\n ############################\n # YOUR IMPLEMENTATION HERE #\n # HINT: Don't forget to decay epsilon according to GLIE\n\n curr_state = s_t1\n \n start = time.time() # to time how long convergence takes\n print(\"---Q Learning---\\nTraining Started.\")\n \n for k in range (1, iterations):\n # if (k%10000) == 0:\n # print(\"Now playing iteration: \", k)\n epsilon = 1/k\n curr_action, reward, new_state, done = take_one_step(env, policy, curr_state)\n new_action = sample_action(policy, new_state)\n Q_value[curr_state, curr_action] = Q_value[curr_state, curr_action] + alpha * (reward + gamma * (Q_value[new_state, np.argmax(Q_value[new_state])]) - Q_value[curr_state, curr_action])\n \n # epsilon-greedy policy update\n Q_list = np.argwhere(Q_value[curr_state] == np.amax(Q_value[curr_state])).flatten() # get a list of all indices where Q is maximum, (argmax(Q))\n max_Q = np.random.choice(Q_list.flatten()) # randomly pick from those indices. Picking each index is equally likely.\n for a in range (nA):\n if a == max_Q:\n policy[curr_state][a] = epsilon/nA + (1 - epsilon) # for the chosen maximal index of Q, set the policy to epsilon/m + 1 - epsilon\n else:\n policy[curr_state][a] = epsilon/nA \n \n # print(\"Q_value = {0}\".format(Q_value))\n # print(\"policy = {0}\".format(policy))\n \n if done:\n curr_state = env.reset() # reset the environment and place the agent in the start square\n curr_action = sample_action(policy, curr_state)\n else:\n curr_state = new_state\n curr_action = new_action\n \n stop = time.time()\n print(\"Training Completed.\")\n print(\"It took: {0} iterations and {1} minutes\".format(k,(stop-start)/60))\n \n ############################\n det_policy = np.argmax(Q_value, axis=1)\n return Q_value, det_policy","def computeQValueFromValues(self, state, action):\n \n \n next_states_probs = self.mdp.getTransitionStatesAndProbs(state, action)\n # liste des recompenses R(s,a,s')\n rewards = []\n # liste des probas de transitions P(s'|a,s)\n probs = []\n # liste des Vk(s')\n previous_values = []\n # occurence[0] = les next_state\n # occurence[1] = les proba de transi\n for occurence in next_states_probs:\n rewards.append(self.mdp.getReward(state, action, occurence[0]))\n probs.append(occurence[1])\n previous_values.append(self.getValue(occurence[0]))\n Q_value = 0\n # boucle qui calcule somme des ( P(s'|a,s) * [R(s,a,s') + gamma * Vk(s')] ) sur les s'\n for i in range(len(probs)):\n Q_value += probs[i] * (rewards[i] + self.discount * previous_values[i])\n \n return Q_value\n util.raiseNotDefined()","def forward(self, input_x):\n return self.net(input_x.float())","def prediccion(self):\n # Project the state ahead\n self.X = self.F @ self.X + self.B @ self.M\n self.P = self.F @ self.P @ self.F.T + self.Q\n\n return self.X","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n # print \"getQValue\"\n features = self.featExtractor.getFeatures(state, self.index)#.values()\n #weights = self.weights.values()\n #dotProduct = reduce( (lambda x, y: x*y), map( (lambda x, y: x+y), self.weights, features))\n #return dotProduct\n score = 0\n for key in features.keys():\n score += features[key]*self.weights[key]\n return score","def advantage(self, state):\n Q = self.predict(state)\n return Q - np.dot(self.π.pmf(state, Q), Q)","def quantum_net(self, q_input_features, q_weights_flat):\n\n # Reshape weights\n q_weights = q_weights_flat.reshape(self.args.q_depth, self.args.n_qubits, 3)\n\n # Start from state |+> , unbiased w.r.t. |0> and |1>\n # Amplitude encoding\n qml.QubitStateVector(q_input_features, wires=list(range(self.args.n_qubits)))\n \n # Sequence of trainable variational layers\n for k in range(self.args.q_depth):\n self.entangling_layer(self.args.n_qubits)\n self.Rot_layer(q_weights[k])\n\n # Expectation values in the Z basis\n exp_vals = [qml.expval(qml.PauliZ(position)) for position in range(self.args.target_class)]\n return tuple(exp_vals)","def getQValue(self, state, action):\n features = self.featExtractor.getFeatures(state, action)\n total = 0\n for feat in features:\n total += self.getWeights()[feat] * features[feat]\n return total"],"string":"[\n \"def forward(self, state):\\n x = state\\n feature = self.feature_layer(x)\\n action_value = self.value_layer(feature)\\n advantage = self.advantage_layer(feature)\\n \\n q_value = action_value + (advantage - advantage.mean(dim=1, keepdim=True))\\n return q_value\",\n \"def advantage(self, state, Q: torch.Tensor = None):\\n return Q - Q.max()\\n # return Q - torch.matmul(self.π.pmf(state, action_values=Q), Q)\",\n \"def forward(self, x1, x2):\\n return x1 * self.Q + (1 - self.Q) * x2\",\n \"def Q_net(self, state):\\n\\t\\tif not self._prediction_made: \\n\\t\\t\\tQ = tf.matmul(tf.nn.relu( tf.matmul(state, self.weights_hidden) + self.bias_hidden ), self.weights_out) + self.bias_out \\n\\t\\t\\tself._Qval = Q\\t\\n\\t\\t\\tself._prediction_made = True\\n\\t\\treturn self._Qval\",\n \"def forward(self, state, action):\\n state = torch.cat(state, dim=1)\\n \\n for i in range(len(action)):\\n action[i] /= self.max_action\\n\\n # Concatenate the action vector \\n action = torch.cat(action, dim=1)\\n x = torch.cat([state, action], dim=1)\\n x = F.relu(self.fc1(x))\\n x = F.relu(self.fc2(x))\\n x = F.relu(self.fc3(x))\\n q_value = self.q_out(x)\\n\\n return q_value\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones = experiences\\n\\n #simple implementation of a python noob to implement DDQN\\n bla = torch.from_numpy(np.zeros(64)).float().to(device)\\n for i in range(64):\\n bla[i] = self.qnetwork_target(next_states[i]).detach()[self.qnetwork_local(next_states).detach().argmax(1)[i]]\\n Q_targets_next = bla.unsqueeze(1)\\n #this was my first try of ddqn in python style, but as i said i'm a noob and didn't get it working\\n #Q_targets_next = [self.qnetwork_target(next_states).detach()[i] for i in self.qnetwork_local(next_states).detach().argmax(1).unsqueeze(1)]\\n \\n # Compute Q targets for current states \\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n\\n # Get expected Q values from local model\\n Q_expected = self.qnetwork_local(states).gather(1, actions)\\n\\n # Compute loss\\n loss = F.mse_loss(Q_expected, Q_targets)\\n # Minimize the loss\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)\",\n \"def forward(self, x):\\n q_denom = (x.unsqueeze(1) - self.clusters)**2\\n q_denom = q_denom.sum(dim=2)\\n q_denom /= self.alpha\\n q_denom += 1.0\\n q = 1.0 / q_denom\\n q = q ** ((self.alpha + 1.0) / 2.0)\\n q = q.t() / q.sum(dim=1) # Div shapes [20, 1024] / [1024]\\n q = q.t()\\n return q\",\n \"def forward(self, x):\\n x = self.fc0(x.view(-1, x.size(-1))).view(x.size(0), x.size(1), -1)\\n x = self.pe(x)\\n\\n x = self.inner_layers(x) # FF, FF, FF, finalFF\\n\\n state_value = self.fc_s(x) # double-dqn : state\\n\\n advantage_values = self.fc_a(x) # double-dqn : advantage\\n advantage_values = advantage_values.view(\\n advantage_values.size()[:-1] + (self.action_size, self.n_atoms))\\n\\n dist_weights = state_value.unsqueeze(\\n dim=-2) + advantage_values - advantage_values.mean(dim=-2, keepdim=True)\\n\\n return dist_weights\",\n \"def q1_forward(self, state: torch.Tensor) -> torch.Tensor:\\n return self.q_networks[0](state)\",\n \"def Q(self, states, neural_net_to_use, no_grad = False):\\r\\n\\r\\n states = torch.from_numpy(states)\\r\\n states = states.float()\\r\\n\\r\\n if no_grad:\\r\\n with torch.no_grad():\\r\\n output = neural_net_to_use(states)\\r\\n return output\\r\\n\\r\\n output = neural_net_to_use(states)\\r\\n return output\",\n \"def learn(self):\\n ## obtain sample batch using priority based sampling.\\n states, actions, rewards, next_states, dones, weights, sample_inds = self.buffer.sample_batch(BETA)\\n \\n ## obtain the discounted sum of rewards from reward list\\n ## also obtain final gamma multiplier\\n reduced_rewards, gamma_multipliers = self.reduce_rewards(rewards)\\n \\n ## convert to tensors\\n states = np_to_tensor(states)\\n actions = np_to_tensor(actions)\\n reduced_rewards = np_to_tensor(reduced_rewards)\\n gamma_multipliers = np_to_tensor(gamma_multipliers)\\n next_states = np_to_tensor(next_states)\\n dones = np_to_tensor(dones)\\n weights = np_to_tensor(np.array(weights))\\n \\n #### Updating Qnet\\n \\n ## actions from the target actor network\\n greedy_actions = self.actor_target(next_states)\\n ## compute temporal difference\\n targets = reduced_rewards + torch.mul( torch.mul(gamma_multipliers , self.QNetwork_target(next_states, greedy_actions)) , (1-dones).unsqueeze(1))\\n Q_sa = self.QNetwork_local(states, actions)\\n \\n td_error = targets - Q_sa\\n \\n ## update the priorities using temporal differences\\n self.buffer.update_priority(sample_inds,\\n (td_error).detach().abs().squeeze().cpu().data.numpy()+REPLAY_EPS)\\n \\n ## compute the loss, importance sampling weights are used\\n loss = ((td_error).pow(2)*weights).mean()\\n \\n self.QNet_optim.zero_grad()\\n loss.backward()\\n self.QNet_optim.step()\\n \\n ### Updating Actor\\n pred_actions = self.actor_local(states)\\n actor_loss = - self.QNetwork_local(states, pred_actions).mean()\\n \\n self.actor_optim.zero_grad()\\n actor_loss.backward()\\n self.actor_optim.step()\\n \\n #### Polyak Updates\\n self.soft_update(self.QNetwork_local, self.QNetwork_target, TAU)\\n self.soft_update(self.actor_local, self.actor_target, TAU)\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n Q_Value = 0 #initializing q value\\n\\n feat_Extractor = self.featExtractor\\n\\n weight = self.weights #To get the weight to control exploration and exploitation\\n\\n features = feat_Extractor.getFeatures(state,action) #to get all the features associated with (state,action) pair\\n\\n for each_feature in features:\\n #refer to README_Reinforcement.txt for the formula at line 11\\n temp_Qvalue = weight[each_feature] * features[each_feature] #Q(state,action) = w * featureVector where * is the dotProduct operator\\n Q_Value = Q_Value + temp_Qvalue\\n\\n return Q_Value #Returns final qvalue\\n #util.raiseNotDefined()\",\n \"def test_propagate(self):\\n # Get network components\\n data = array([[0], [1]])\\n cdata = LabeledCData(data, labels=array([0, 1]))\\n encoder = BinaryEncoding(cdata)\\n unitary = ProductAnsatz(1)\\n measure = Measurement(1, [0])\\n qnn = Network([encoder, unitary, measure], \\\"1q-qvm\\\")\\n\\n # Propagate the zeroth data point\\n out = qnn.propagate(0, shots=10)\\n\\n print(out)\",\n \"def updateQ_value(self, value):\\n self.Q_value = (self.Q_value * self.nVisits + value) / (self.nVisits + 1)\",\n \"def forward(self, x):\\n dims = list(range(1, len(x.shape)))\\n mean = x.mean(dim=dims, keepdim=True)\\n var = torch.pow(x - mean, 2).mean(dim=dims, keepdim=True)\\n return self.apply_gain_and_bias((x - mean) / (var + EPS).sqrt())\",\n \"def forward(self, state):\\n x = F.relu(self.input(state))\\n for layer in self.layers:\\n x = F.relu(layer(x))\\n if self.duel:\\n # Value function estimator\\n val = F.relu(self.val_fc_input(x))\\n val = self.val_fc_output(val)\\n # Advantage function estimator\\n adv = F.relu(self.adv_fc_input(x))\\n adv = self.adv_fc_output(adv)\\n # Subtract mean so that V and A are uniquely identifiable for a given Q\\n return val + adv - adv.mean(1).unsqueeze(1).expand(state.size(0), self.action_size)\\n else:\\n return self.output(x)\",\n \"def forwardPolicyNet(self, state):\\n with torch.no_grad():\\n q_values = self.policy_net(state)\\n return q_values\",\n \"def getQValue(self, state, action):\\n #print \\\"getQValue in ApproximateQAgent\\\"\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n weights = self.getWeights()\\n features = self.featExtractor.getFeatures(state, action, self)\\n\\n value = 0\\n\\n #print \\\"FEATURES: \\\", features\\n #print \\\"WEIGHTS: \\\", weights\\n\\n for feature in features:\\n value += features[feature]*weights[feature]\\n return value\\n #util.raiseNotDefined()\",\n \"def getQValue(self, state, action):\\n \\\"\\\"\\\"Description:\\n [Enter a description of what you did here.]\\n Use first equation in slide 71 of MDP to compute q-value depond on weights and current features.\\n \\n !! But I think what I did is not work for IdentityExtractor. Because feature of IdentityExtrator always return 1,\\n it did not change even a ghost is closing.\\n \\\"\\\"\\\"\\n \\\"\\\"\\\" YOUR CODE HERE \\\"\\\"\\\"\\n # if weight is empty, then weight will need to initial to 1 for all features\\n # According to which Extractor user choose, weight counter will have equal number of keys.\\n if len(self.weight) == 0:\\n feat = self.featExtractor.getFeatures(state, action)\\n self.weight.incrementAll(feat.keys(), 1)\\n \\n qValue = self.weight * self.featExtractor.getFeatures(state,action)\\n return qValue\\n \\\"\\\"\\\" END CODE \\\"\\\"\\\"\",\n \"def preval_forward(self, data_shot, label_shot, data_query):\\n embedding_query = self.encoder(data_query)\\n embedding_shot = self.encoder(data_shot)\\n logits = self.base_learner(embedding_shot)\\n #loss = self.FL(logits, label_shot) + self.CD(logits,label_shot) + self.LS(logits,label_shot)\\n loss = self.CD(logits,label_shot)\\n grad = torch.autograd.grad(loss, self.base_learner.parameters())\\n fast_weights = list(map(lambda p: p[1] - 0.01 * p[0], zip(grad, self.base_learner.parameters())))\\n logits_q = self.base_learner(embedding_query, fast_weights)\\n\\n for _ in range(1, 100):\\n logits = self.base_learner(embedding_shot, fast_weights)\\n #loss = self.FL(logits, label_shot) + self.CD(logits,label_shot) + self.LS(logits,label_shot)\\n loss = self.CD(logits,label_shot)\\n grad = torch.autograd.grad(loss, fast_weights)\\n fast_weights = list(map(lambda p: p[1] - 0.01 * p[0], zip(grad, fast_weights)))\\n logits_q = self.base_learner(embedding_query, fast_weights) \\n return logits_q\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones = experiences\\n\\n # Double DQN. Uses local network for action selection and target network for value estimation\\n # see: https://arxiv.org/pdf/1509.06461.pdf\\n Q_actions_next = self.dqn_local(next_states).detach().argmax(1).unsqueeze(1)\\n Q_targets_next = self.dqn_target(next_states).gather(1, Q_actions_next)\\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n # Standard DQN\\n # Get max predicted Q values (for next states) from target model\\n # Q_targets_next = self.dqn_target(next_states).detach().max(1)[0].unsqueeze(1)\\n # Compute Q targets for current states\\n # Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n\\n # Get expected Q values from local model\\n Q_expected = self.dqn_local(states).gather(1, actions)\\n\\n # Compute loss\\n loss = F.mse_loss(Q_expected, Q_targets)\\n # Minimize the loss\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.dqn_local, self.dqn_target, TAU)\",\n \"def forward(self, state_t):\\n # Use your network to compute qvalues for given state\\n conved_features = self.conv_layers(state_t)\\n A = self.head_A(conved_features)\\n V = self.head_V(conved_features).repeat(1, self.n_actions)\\n mean_A = torch.mean(A, dim=-1, keepdim=True).repeat(1, self.n_actions)\\n qvalues = A + V - mean_A\\n\\n assert qvalues.requires_grad, \\\"qvalues must be a torch tensor with grad\\\"\\n assert len(\\n qvalues.shape) == 2 and qvalues.shape[0] == state_t.shape[0] and qvalues.shape[1] == self.n_actions\\n\\n return qvalues\",\n \"def forward(self, value, query, lens):\\n relevant_scores = self.relevant_score(value, query, lens)\\n e_relevant_scores = torch.exp(relevant_scores)\\n weights = e_relevant_scores / e_relevant_scores.sum(-1, keepdim=True)\\n attention = (weights.unsqueeze(-1) * value).sum(1)\\n return attention\",\n \"def forward(self):\\n R = self.LP.cost.R\\n A = self.LP.dyn.A\\n B = self.LP.dyn.B\\n\\n x = self.LP.x0\\n self.x[0] = x\\n for i in range(self.LP.N):\\n u = - np.linalg.inv(R+B.T.dot(self.V[i+1]).dot(B)).dot(.5*B.T.dot(self.W[i+1]) \\\\\\n + B.T.dot(self.V[i+1]).dot(A).dot(x))\\n if self.LP.dyn.u_dim == 1:\\n self.u[i] = float(u)\\n else:\\n self.u[i] = u\\n self.J_star[i] = float(x.T.dot(self.V[i]).dot(x) + self.W[i].T.dot(x)) #up to constant\\n\\n if i == 0:\\n self.J[i] = self.LP.cost.loss(x, u, i)\\n else:\\n self.J[i] = self.J[i-1] + self.LP.cost.loss(x, u, i)\\n x = self.LP.dyn.next_state(x, u)\\n self.x[i+1] = x\\n\\n self.J[self.LP.N] = self.J[self.LP.N-1] + self.LP.cost.loss(x, 0, self.LP.N)\\n\\n self.J_star[self.LP.N] = float(x.T.dot(self.V[self.LP.N]).dot(x) \\\\\\n + self.W[self.LP.N].T.dot(x)) #up to constant\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones = experiences\\n\\n # Get max predicted Q values (for next states) from target model\\n Q_targets_next = self.qnetwork_target(\\n next_states).detach().max(1)[0].unsqueeze(1)\\n \\n # Compute Q targets for current states \\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n\\n # Get expected Q values from local model\\n Q_expected = self.qnetwork_local(states).gather(1, actions)\\n\\n # Compute loss\\n loss = F.mse_loss(Q_expected, Q_targets)\\n\\n # Minimize the loss\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, self.tau) \\n\\n return\",\n \"def learn(self, experiences, gamma):\\n self.optimizer.zero_grad()\\n\\n states, actions, rewards, next_states, dones = experiences\\n\\n best_actions = self.qnetwork_local(next_states).detach().argmax(1).unsqueeze(1)\\n q_values_target = self.qnetwork_target(next_states).detach()\\n q_expected = rewards + (gamma * q_values_target.gather(1, best_actions)) * (1 - dones)\\n q_current = self.qnetwork_local(states).gather(1, actions)\\n\\n loss = F.mse_loss(q_expected, q_current)\\n\\n loss.backward()\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, dqn_agent.TAU)\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n qvalue = 0.0\\n for feature_name, value in self.featExtractor.getFeatures(state, action).iteritems():\\n qvalue += value * self.weights[feature_name]\\n return qvalue\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n qvalue = 0.0\\n for feature_name, value in self.featExtractor.getFeatures(state, action).iteritems():\\n qvalue += value * self.weights[feature_name]\\n return qvalue\",\n \"def ipdTft(length,gamma,epsilon,alpha = .8):\\r\\n #possible previous states (what each did in the last iteration)\\r\\n states = [(\\\"*\\\",\\\"*\\\"),(\\\"C\\\",\\\"D\\\"), (\\\"C\\\",\\\"C\\\"), (\\\"D\\\",\\\"C\\\"), (\\\"D\\\",\\\"D\\\")]\\r\\n #actions: Defect or Cooperate\\r\\n actions = [\\\"D\\\",\\\"C\\\"]\\r\\n #payoff matrix (as dict)\\r\\n payoff = {(\\\"C\\\",\\\"D\\\"): (-3,0), (\\\"C\\\",\\\"C\\\"): (-1,-1), \\r\\n (\\\"D\\\",\\\"C\\\"): (0,-3), (\\\"D\\\",\\\"D\\\"): (-2,-2)}\\r\\n #initialize learners \\r\\n\\r\\n #q1 = qLearn(states,actions,gamma,alpha,epsilon)\\r\\n #q1 = QLearnCont(ipd_feats,10,actions,gamma,alpha,epsilon,kernel = 'linear')\\r\\n #q1 = DQN(ipd_feats,10,actions,.99,.5,.1,learn_type = 'linear')\\r\\n q1 = DQN(ipd_feats,10,actions,.99,.5,.1,shape = (10,10,1))\\r\\n #initialize list of rewards\\r\\n rewards = []\\r\\n #iterate through length states and run the game\\r\\n prevState = (\\\"*\\\",\\\"*\\\")\\r\\n for i in range(length):\\r\\n #get actions\\r\\n print(\\\"Iteration %i:\\\" %i)\\r\\n print(\\\"Previous State:\\\", prevState)\\r\\n qa1 = q1.chooseAction(prevState)\\r\\n qa2 = tft(prevState[0])\\r\\n print(\\\"Player 1 Action:\\\",qa1)\\r\\n print(\\\"Player 2 Action:\\\",qa2)\\r\\n \\r\\n #find payoff\\r\\n newState = (qa1,qa2)\\r\\n reward = payoff[newState]\\r\\n rewards.append(reward[0])\\r\\n print(\\\"Player 1 Reward:\\\", reward[0])\\r\\n print(\\\"Player 2 Rewards:\\\", reward[1])\\r\\n print(\\\"Current average reward for Player 1:\\\",np.mean(rewards))\\r\\n #assign reward and update Q params\\r\\n q1.qUpdate(prevState,qa1,reward[0],newState)\\r\\n \\r\\n prevState = newState\\r\\n #print(q1.Q)\\r\\n return(rewards,q1)\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones, weights, indexes = experiences\\n\\n q_expected, q_targets = self.get_target_and_expected(states, \\n actions, \\n rewards, \\n next_states, \\n dones, \\n gamma)\\n\\n #print('q_expected.shape', q_expected.shape)\\n #print('q_targets.shape', q_targets.shape)\\n \\n # Compute loss\\n ##### deltas = F.mse_loss(q_expected, q_targets)\\n deltas = q_expected - q_targets\\n #print('loss.shape', loss.data.cpu().numpy().shape)\\n #print('loss', loss)\\n \\n _sampling_weights = (torch.Tensor(weights)\\n .view((-1, 1)))\\n \\n # mean square error\\n loss = torch.mean((deltas * _sampling_weights)**2)\\n\\n # importance sampling weights used to correct bias introduced \\n # by prioritisation experience replay\\n # See Annealing the bias https://arxiv.org/abs/1511.05952\\n #with torch.no_grad():\\n # weight = sum(np.multiply(weights, loss.data.cpu().numpy()))\\n # print('weight', weight)\\n # loss *= weight\\n # print('weights.shape', weights.shape)\\n # print('loss type', type(loss))\\n # print('loss shape', loss.size())\\n # loss *= weights\\n # Minimize the loss\\n # call zero_grad before calling backward() \\n # o.w. gradients are accumulated from multiple passes\\n self.optimizer.zero_grad()\\n # backward computes dloss/dx for every parameter x\\n loss.backward()\\n # updates parameters\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU) \\n \\n # ------------------- update priorities ------------------- # \\n priorities = abs(deltas.detach()).numpy()\\n #priorities = abs(q_expected.detach() - q_targets.detach()).numpy()\\n self.memory.update_priorities(priorities, indexes)\",\n \"def update(self, state, action, nextState, reward):\\n \\\"\\\"\\\"Description:\\n Use Q-Learning algoritm in slide 58 of MDP\\n \\\"\\\"\\\"\\n \\\"\\\"\\\" YOUR CODE HERE \\\"\\\"\\\"\\n maxQns = self.getValue(nextState) # get max q-value of next state\\n if maxQns == None:\\n maxQns = 0\\n Qsa = self.getQValue(state, action) #self.qValues[(state, action)]\\n difference = reward + self.discountRate * maxQns - Qsa\\n self.qValues[(state, action)] += self.alpha * difference\\n \\n self.vitCount[(state, action)] += 1\\n \\\"\\\"\\\" END CODE \\\"\\\"\\\"\",\n \"def learn(self):\\n \\n # target parameter update\\n # target parameter update\\n if self.learn_step_counter % self.nu_iter == 0:\\n self.target_net.load_state_dict(self.eval_net.state_dict())\\n #testing the preformace of the network\\n if self.learn_step_counter == 0:\\n print('As referece this first test on dev data. Is maded with the Q networks, initialized randomly : ' )\\n else:\\n print(\\\"\\\\n Lets copy the Q-value Net in to Q-target net!. And test the performace on the dev data: \\\")\\n \\n current_bleu = self.dev_network()\\n print(\\\"Current Bleu score is: \\\", current_bleu)\\n \\n self.learn_step_counter += 1\\n\\n \\n long_Batch = self.sample_size*3\\n # Sampling the higgest rewards values\\n b_memory_big = self.memory[np.argsort(-self.memory[:-self.max_output_length, self.state_size+1])][:long_Batch]\\n \\n sample_index = np.random.choice(long_Batch, self.sample_size)\\n b_memory = b_memory_big[sample_index, :]\\n\\n b_s = torch.FloatTensor(b_memory[:, :self.state_size])\\n b_a = torch.LongTensor(b_memory[:, self.state_size:self.state_size+1].astype(int))\\n b_r = torch.FloatTensor(b_memory[:, self.state_size+1:self.state_size+2])\\n b_s_ = torch.FloatTensor(b_memory[:, self.state_size+2: self.state_size+2 + self.state_size])\\n\\n b_is_eos = torch.FloatTensor(b_memory[:, self.size_memory1-1:]).view(self.sample_size, 1)\\n #print(b_a, b_a.size)\\n #print(b_is_eos)\\n #Activate the eval_net\\n unfreeze_model(self.eval_net)\\n \\n # q_eval w.r.t the action in experience\\n q_eval = self.eval_net(b_s).gather(1, b_a) # shape (batch, 1)\\n q_next = self.target_net(b_s_).detach() # detach from graph, don't backpropagate\\n #taking the most likely action.\\n b_a_ = torch.LongTensor(q_next.max(1)[1].view(self.sample_size, 1).long())\\n #b_a_ = q_next.max(1)[0].view(self.sample_size, 1).long() # shape (batch, 1)\\n q_eval_next = self.eval_net(b_s_).gather(1, b_a_) # shape (batch, 1)\\n \\n #If eos q_target = reward. \\n q_target = b_r + self.gamma * b_is_eos* q_eval_next.view(self.sample_size, 1) # shape (batch, 1)\\n #version 0\\n #q_target = b_r + self.gamma * q_next.max(1)[0].view(self.sample_size, 1) # shape (batch, 1)\\n \\n loss = self.loss_func(q_eval, q_target)\\n \\n self.tb_writer.add_scalar(\\\"learn/learn_batch_loss\\\",\\n loss.data, self.learn_step_counter)\\n\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n #desctivate the eval_net\\n freeze_model(self.eval_net)\",\n \"def forward(self, x):\\n # tracking shapes\\n B, C, H, W = x.size()\\n K = self.K\\n HW_prime = H * W\\n\\n # get qkv's\\n f = self.f(x).view(B, C // K, H * W) # B x (C/K) x (HW)\\n g = self.g(x) # B x (C/K) x H x W\\n h = self.h(x) # B x (C/2) x H x W\\n if self.down_sample:\\n g = F.max_pool2d(g, [2, 2]) # B x (C/K) x (H/2) x (W/2)\\n h = F.max_pool2d(h, [2, 2]) # B x (C/2) x (H/2) x (W/2)\\n HW_prime = HW_prime // 4 # update (HW)'<-(HW) // 4\\n\\n g = g.view(B, C // K, HW_prime) # B x (C/K) x (HW)'\\n h = h.view(B, C // 2, HW_prime) # B x (C/2) x (HW)'\\n\\n beta = self._dot_product_softmax(f, g) # B x (HW) x (HW)'\\n s = torch.einsum('ijk,ilk->ijl', h, beta).view(B, C // 2, H, W) # B x (C/2) x H x W\\n return self.gamma * self.v(s) + x # B x C x H x W\",\n \"def learn(self, experiences, gamma):\\n \\n states, actions, rewards, next_states, dones = experiences\\n\\n # Get max predicted Q values (for next states) from target model\\n Q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\\n # Compute Q targets for current states \\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n\\n # Get expected Q values from local model\\n Q_expected = self.qnetwork_local(states).gather(1, actions)\\n\\n # Compute loss\\n loss = F.mse_loss(Q_expected, Q_targets)\\n # Minimize the loss\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)\",\n \"def test_forward_values():\\n rnn = GeneratorRNN(1)\\n inputs = Variable(torch.zeros(1,1,3))\\n hidden = rnn.init_hidden()\\n e,pi,mu,sigma,rho,_ = rnn(inputs, hidden)\\n\\n assert (e >= 0).all()\\n assert (e <= 1).all()\\n\\n diff = torch.abs(1-torch.sum(pi))\\n assert (diff < 0.00001).all()\\n\\n assert (sigma > 0).all()\\n\\n assert (rho > -1).all()\\n assert (rho < 1).all()\\n\\n rnn = GeneratorRNN(3)\\n inputs = Variable(torch.zeros(10,1,3))\\n hidden = rnn.init_hidden()\\n e,pi,mu,sigma,rho,_ = rnn(inputs, hidden)\\n\\n pi_sum = torch.sum(pi,dim=2)\\n diff = torch.abs(1-pi_sum)\\n assert (diff < 0.00001).all()\",\n \"def computeQValueFromValues(self, state, action):\\r\\n #\\r\\n weightedVfvsSum = 0\\r\\n reward = 0\\r\\n # to get possible next state(s)\\r\\n for nextState, prob in self.mdp.getTransitionStatesAndProbs(state, action):\\r\\n reward += self.mdp.getReward(state, action, nextState) * prob\\r\\n #print \\\":computeQValueFromValues: nextState is: \\\", nextState, \\\" | self.values[nextState] is: \\\", self.values[nextState]\\r\\n weightedVfvsSum += prob * self.getValue(nextState)\\r\\n #\\r\\n return ( reward + ( self.discount * weightedVfvsSum) ) # making the actual qvalue\\r\",\n \"def learn(self):\\n if self.learn_step_counter % self.target_q_update_step == 0:\\n self.target_net.load_state_dict(self.eval_net.state_dict()) #update target_net's parameters\\n logging.info(\\\"updtate target q\\\")\\n self.learn_step_counter += 1\\n\\n rgbs,depths, rgbs_1, depths_1,questions,actions,rewards,terminals = self.memory.sample()\\n\\n rgbs_var = Variable(torch.FloatTensor(rgbs).cuda())\\n depths_var = Variable(torch.FloatTensor(depths).cuda())\\n rgbs_1_var = Variable(torch.FloatTensor(rgbs_1).cuda())\\n depths_1_var = Variable(torch.FloatTensor(depths_1).cuda())\\n questions_var = Variable(torch.LongTensor(questions).cuda())\\n actions_var = Variable(torch.LongTensor(actions).cuda())\\n rewards_var = Variable(torch.FloatTensor(rewards).cuda())\\n terminals_var = Variable(torch.FloatTensor(terminals).cuda())\\n\\n q_eval_matrix = self.eval_net(rgbs_var,depths_var,questions_var)\\n q_eval_matrix = q_eval_matrix.view(-1,9*28*28)\\n actions_var = actions_var.view(-1,1)\\n q_eval = torch.gather(q_eval_matrix, 1, actions_var) \\n q_eval = q_eval.squeeze(1)\\n\\n q_next_matrix = self.target_net(rgbs_1_var,depths_1_var,questions_var).detach() #don't backward\\n q_next_matrix = q_next_matrix.view(-1,9*28*28)\\n q_next = torch.max(q_next_matrix,1)[0]\\n\\n one_var = Variable(torch.ones_like(terminals_var))\\n\\n q_target = rewards_var + (one_var- terminals_var)*self.discount * q_next\\n \\n loss = self.loss_func(q_eval, q_target)\\n\\n\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n self.task_total_loss += loss.item()\\n self.task_total_q += q_target.mean()\\n self.update_count += 1\",\n \"def preval_forward(self, data_shot, label_shot, data_query):\\n embedding_query = self.encoder(data_query)\\n embedding_shot = self.encoder(data_shot)\\n logits = self.base_learner(embedding_shot)\\n loss = F.cross_entropy(logits, label_shot)\\n grad = torch.autograd.grad(loss, self.base_learner.parameters())\\n fast_weights = list(map(lambda p: p[1] - 0.01 * p[0], zip(grad, self.base_learner.parameters())))\\n logits_q = self.base_learner(embedding_query, fast_weights)\\n\\n for _ in range(1, 100):\\n logits = self.base_learner(embedding_shot, fast_weights)\\n loss = F.cross_entropy(logits, label_shot)\\n grad = torch.autograd.grad(loss, fast_weights)\\n fast_weights = list(map(lambda p: p[1] - 0.01 * p[0], zip(grad, fast_weights)))\\n logits_q = self.base_learner(embedding_query, fast_weights) \\n return logits_q\",\n \"def getQvalue(self, state, action):\\n featureVector = self.getFeatures(state, action)\\n qValue = 0\\n for k in featureVector.keys():\\n qValue = qValue + self.weights[k] * featureVector[k]\\n\\n return qValue\",\n \"def update(self, state, action, nextState, reward):\\n \\\"\\\"\\\"Description:\\n Use second equation in slide 71 of MDP\\n Adjest weight of active features depend on tranistion \\n \\\"\\\"\\\"\\n \\\"\\\"\\\" YOUR CODE HERE \\\"\\\"\\\"\\n feat = self.featExtractor.getFeatures(state, action)\\n\\n # if weight is empty, then weight will need to initial to 1 for all features\\n # According to which Extractor user choose, weight counter will have equal number of keys.\\n if len(self.weight) == 0:\\n feat = self.featExtractor.getFeatures(state, action)\\n self.weight.incrementAll(feat.keys(), 1)\\n \\n maxQns = self.getValue(nextState)\\n if maxQns == None:\\n maxQns = 0\\n Qsa = self.getQValue(state, action)\\n difference = ( reward + self.discountRate * maxQns ) - Qsa\\n \\n for key in self.weight.keys():\\n self.weight[key] += (self.alpha * difference * feat[key])\\n \\n \\n \\\"\\\"\\\" END CODE \\\"\\\"\\\"\",\n \"def computeQValueFromValues(self, state, action):\\n #get the Transition function and nextStates\\n state_prob_pair=self.mdp.getTransitionStatesAndProbs(state,action)\\n #initialize the value to zero\\n actual_value=0\\n #iterate over probabilities (transition functions) and next states\\n for pair in state_prob_pair:\\n #compute qvalue\\n actual_value+=pair[1]*(self.mdp.getReward(state,action,pair[0])+self.discount*self.values[pair[0]])\\n #print \\\"The Q value is \\\",actual_value\\n return actual_value\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones, idxs, weights = experiences\\n \\n\\n # Get max predicted Q values (for next states) from target model\\n Q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\\n # Compute Q targets for current states \\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n\\n # Get expected Q values from local model\\n Q_expected = self.qnetwork_local(states).gather(1, actions)\\n\\n # Compute loss MSE\\n loss = (Q_expected - Q_targets.detach()).pow(2)\\n # Add weights to loss\\n loss = loss * weights\\n # Add noise to loss to arrive at prior weights\\n prios = loss + 1e-6\\n # Take mean\\n loss = loss.mean()\\n\\n # Minimize the loss\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # Update buffer priorities\\n self.memory.update_priorities(zip(idxs, prios.data.cpu().numpy()))\\n\\n\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)\",\n \"def learn(self, state, action, reward, next_state):\\r\\n\\r\\n \\\"\\\"\\\"Please Fill Your Code Here.\\r\\n \\\"\\\"\\\"\\r\\n self.Q[state][action] = self.Q[state][action] + self.alpha * (reward + self.gamma * max(self.Q[next_state]) - self.Q[state][action])\\r\\n\\r\\n return 0\",\n \"def learn(self):\\n batch = self.agent.replay_buffer.sample(self.batch_size)\\n states = torch.tensor([x.state for x in batch], dtype=torch.float32).to(self.agent.device) # shape == (batch_size, 3, 6, 7)\\n actions = [x.action for x in batch]\\n rewards = torch.tensor([x.reward for x in batch], dtype=torch.float32).to(self.agent.device)\\n next_states = torch.tensor([x.next_state for x in batch], dtype=torch.float32).to(self.agent.device)\\n dones = [x.done for x in batch]\\n\\n self.optimizer.zero_grad()\\n\\n\\n q_vals = self.agent.policy_net(states)[range(len(actions)), actions] # Q vals for actions taken\\n q_next_vals = self.agent.target_net(next_states).detach() # we don't care about grad wrt target net\\n q_next_vals[dones] = 0.0 # terminal states have no future expected value\\n q_targets = rewards + self.gamma * torch.max(q_next_vals, dim=1)[0]\\n\\n # all_q_vals = self.agent.policy_net(states)\\n # print()\\n # print('actions')\\n # print(actions)\\n # print()\\n # print('original all q vals')\\n # print(self.agent.policy_net(states)) \\n # print(self.agent.policy_net(states).shape)\\n # print()\\n # print('QVALS:', q_vals)\\n # print(q_vals.shape)\\n # print('\\\\n\\\\n')\\n # print('QTARGETS:', q_targets)\\n # print(q_targets.shape)\\n\\n # breakpoint()\\n\\n loss = self.loss_fn(q_targets, q_vals).to(self.agent.device)\\n loss.backward()\\n \\n # for layer in self.agent.policy_net.named_parameters():\\n \\n # # print(f'layer: {layer[0]}')\\n # # print(f'grad:', layer[1].grad)\\n\\n # # print('loss', loss)\\n # # print('q_vals grad:', q_vals.grad)\\n # # print('states:', )\\n\\n self.optimizer.step()\\n\\n self.agent.learning_iters += 1\\n if self.agent.learning_iters % self.target_update_freq == 0:\\n self.agent.update_target_net()\\n # logger.info('Updated target net')\",\n \"def forward(self):\\n self.value = np.dot(self.x_node.value, self.w_node.value) + self.b_node.value\",\n \"def forward(self,\\n x: Tensor) \\\\\\n -> Tensor:\\n\\n x = self.convs[0](x)\\n res = x\\n for i in range(self.num_rates):\\n x = torch.tanh(self.filter_convs[i](\\n x)) * torch.sigmoid(self.gate_convs[i](x))\\n x = self.convs[i+1](x)\\n res = res + x\\n return res\",\n \"def forward(self, x):\\n x = self.efficient_net(x)\\n return x\",\n \"def computeQValueFromValues(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n qValue = 0\\n transitions = self.mdp.getTransitionStatesAndProbs(state, action)\\n #print('Transitions: ' + str(transitions))\\n for t in transitions:\\n nextState, prob = t\\n reward = self.mdp.getReward(state, action, nextState)\\n #print('Reward: ' + str(reward))\\n oneTransition = prob * (reward + self.discount * self.values[nextState])\\n qValue = qValue + oneTransition\\n return qValue\",\n \"def learn(self, experiences, gamma):\\n\\n states, actions, rewards, next_states, dones = experiences\\n\\n Q_targets = self.get_dqg_target(next_states, rewards, gamma, dones)\\n\\n # Get expected Q values\\n q_exp = self.qnetwork_local(states)\\n\\n # gets the q values along dimention 1 according to the actions, which is used as index\\n # >>> t = torch.tensor([[1,2],[3,4]])\\n # >>> torch.gather(t, 1, torch.tensor([[0],[1]]))\\n # tensor([[ 1],\\n # [ 4]])\\n q_exp = q_exp.gather(1, actions)\\n\\n # compute loss\\n loss = F.mse_loss(q_exp, Q_targets)\\n\\n # reset optimizer gradient\\n self.optimizer.zero_grad()\\n # do backpropagation\\n loss.backward()\\n # do optimize step\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, PARAM.TAU)\",\n \"def forward(self, inp):\\n return inp.dot(self.W) + self.b\",\n \"def learn(self, memory: ReplayMemory, batch_size: int) -> float:\\n # 从replay buffer当中采样，从经验回放集合中采样batch_size个样本，计算当前目标Q值\\n indices, (state_batch, next_batch, action_batch, reward_batch, done_batch), is_weights = \\\\\\n memory.sample(batch_size)\\n # 使用行为网络计算值函数 Q_j\\n values = self.__policy(state_batch).gather(1, action_batch)\\n \\n expected = []\\n policy_Q_batch = self.__policy(next_batch).cpu().data.numpy()\\n max_action_next = np.argmax(policy_Q_batch, axis=1)\\n target_Q_batch = self.__target(next_batch)\\n \\n for i in range(batch_size):\\n if done_batch[i]:\\n expected.append(reward_batch[i])\\n else:\\n target_Q_value = target_Q_batch[i, max_action_next[i]]\\n expected.append(reward_batch[i] + self.__gamma * target_Q_value)\\n \\n expected = torch.stack(expected)\\n TD_error = torch.abs(expected - values)\\n memory.update(indices, TD_error)\\n \\n # 根据目标函数 （Q_j - expected)^2来梯度下降\\n loss = (torch.FloatTensor(is_weights).to(self.__device) * F.mse_loss(values, expected)).mean()\\n\\n self.__optimizer.zero_grad()\\n loss.backward()\\n for param in self.__policy.parameters():\\n param.grad.data.clamp_(-1, 1)\\n self.__optimizer.step()\\n\\n return loss.item()\",\n \"def forward(self, prev_state, obs_t):\\r\\n # Use your network to compute qvalues for given state\\r\\n #print(state_t.shape)\\r\\n h = self.conv(obs_t)\\r\\n\\r\\n h = h.view(h.size(0), -1)\\r\\n\\r\\n new_state = h_new, c_new = self.lstm(h, prev_state)\\r\\n advantage = self.adv(h_new)\\r\\n value = self.val(h_new)\\r\\n\\r\\n\\r\\n adv_mean = torch.mean(advantage, dim=1, keepdim=True)\\r\\n qvalues = value + advantage - adv_mean\\r\\n\\r\\n return new_state, qvalues\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n feature_dictionary = self.featExtractor.getFeatures(state, action)\\n\\n QValue = 0\\n for feature in feature_dictionary:\\n QValue += self.weights[feature] * feature_dictionary[feature]\\n return QValue\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n feature_dictionary = self.featExtractor.getFeatures(state, action)\\n\\n QValue = 0\\n for feature in feature_dictionary:\\n QValue += self.weights[feature] * feature_dictionary[feature]\\n return QValue\",\n \"def update_Q(self, reward):\\n old_estimate = self.q_estimates[self.prev_action]\\n self.q_estimates[self.prev_action] = old_estimate + 1/self.N[self.prev_action] * (reward - old_estimate)\",\n \"def test_forward(self):\\n # test single input\\n self.model.w = np.array([[0.5, 0.25]])\\n self.model.b = 0.5\\n x = np.array([[0.2, 0.1]])\\n out = self.model.forward(x)\\n self.assertTrue(np.abs(out[0] - 0.6514) < 0.01)\\n\\n # test multiple inputs\\n self.model.w = np.array([[0.1, 0.2]])\\n self.model.b = 0.2\\n x = np.array([[0.3, 0.4],\\n [0.5, 0.6]])\\n out = self.model.forward(x)\\n should_be = np.array([0.5769,0.5915])\\n self.assertTrue(np.allclose(out, should_be, atol=0.01))\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones, indices = experiences\\n\\n # Get max predicted Q values (for next states) from target model\\n if self.dbl_dqn:\\n local_best_actions = self.qnetwork_local(next_states).detach().argmax(1)\\n Q_next_states = self.qnetwork_target(next_states)\\n Q_targets_next = Q_next_states.gather(1, local_best_actions.unsqueeze(1))\\n else:\\n Q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\\n\\n # Compute Q targets for current states\\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n\\n # Get expected Q values from local model\\n Q_expected = self.qnetwork_local(states).gather(1, actions)\\n\\n # Compute loss\\n if self.priority_rpl:\\n errors = abs(Q_expected - Q_targets)\\n self.memory.update_priorities(indices, errors)\\n importance = self.memory.get_importance(indices, self.a, self.b)\\n importance = np.array(importance)\\n loss = torch.mean(torch.mul(errors.float(), torch.from_numpy(importance).float().to(device)))\\n else:\\n loss = F.mse_loss(Q_expected, Q_targets)\\n\\n # Minimize the loss\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\",\n \"def back_propagate(self, reward, maxQ):\\n\\n error = self.alpha * (reward + self.gamma*maxQ - self.value)\\n #logging.debug(\\\"error is now %s\\\" % (error))\\n\\n # sigmoid derivate is sigmoid(x) * (1 - sigmoid(x) )\\n dsig = self.value * (1 - self.value)\\n\\n gradient = error * dsig\\n #logging.debug(\\\"gradient is now: %s\\\" % (gradient))\\n\\n self.weigths = np.add( self.weights, np.multiply(gradient, self.weights) )\\n # self.weights = [gradient * w + w for w in self.weights]\",\n \"def train(self, Q_pred: torch.FloatTensor, Q_true: torch.FloatTensor) -> float:\\n self.dqn.train(mode=True)\\n self.optim.zero_grad()\\n loss = self.loss_fn(Q_pred, Q_true)\\n loss.backward()\\n self.optim.step()\\n\\n return loss\",\n \"def forward(self, state_t):\\n # Use your network to compute qvalues for given state\\n qvalues = <YOUR CODE>\\n\\n assert qvalues.requires_grad, \\\"qvalues must be a torch tensor with grad\\\"\\n assert (\\n len(qvalues.shape) == 2 and \\n qvalues.shape[0] == state_t.shape[0] and \\n qvalues.shape[1] == n_actions\\n )\\n\\n return qvalues\",\n \"def forward(self, x, u0=torch.Tensor()):\\n x =self.vari_gpu(x)\\n u0 =self.vari_gpu(u0)\\n \\n # input x0 and batch size \\n num_batch = x.size(0)\\n x0 = x.view(num_batch, -1)\\n \\n A_hat = self.build_A_block()\\n B_hat = self.build_B_block()\\n \\n # Q_sqrt in QP\\n Q = self.Q_sqrt.mm(self.Q_sqrt.t())\\n R = self.R_sqrt.mm(self.R_sqrt.t())\\n R_diag = self.build_Rdiagnol_block(R)\\n Q_hat, Q_diag = self.build_Q_block(Q, Q, R, B_hat)\\n Q_sqrt_hat = sqrtm(Q_hat) # computs sqrt of Q\\n Q_sqrt_hat = Q_sqrt_hat.repeat(num_batch,1,1) # builds batch\\n \\n # p in QP p = 2 * (Q_diag*B_hat)^T * (A_hat*x0)\\n A_x0 = A_hat.mm(x0.t()).t() # presents[x1;x2;...;xN] size: batch * dim(x1;x2;...;xN)\\n p = 2*A_x0.mm(Q_diag.mm(B_hat))\\n \\n # G in QP\\n G1,G2 = self.build_G_block(B_hat)\\n G1 = G1.repeat(num_batch,1,1) # builds batch\\n G2 = G2.repeat(num_batch,1,1) # builds batch\\n \\n # h in QP\\n h1 = self.h1.repeat(num_batch,1) # builds batch\\n h21 = self.h21.repeat(num_batch,1) # builds batch\\n h21 -= A_x0 \\n h22 = self.h22.repeat(num_batch,1) # builds batch\\n h22 += A_x0\\n h2 = torch.cat((h21,h22),1)\\n \\n zero = self.zero.repeat(num_batch,1)\\n \\n # E in QP\\n E = self.E_sqrt.mm(self.E_sqrt.t())\\n E_sqrt = self.E_sqrt.repeat(num_batch,1,1)\\n \\n # for Q(x0,u0), add equality constraint: u(0) = u0 \\n if u0.nelement() != 0:\\n u0 = u0.view(num_batch, -1)\\n # F*z = f\\n F = self.F\\n f = u0*self.f\\n F = F.repeat(num_batch,1,1) # builds batch\\n #f = f.repeat(num_batch,1) # builds batch\\n# print(Q_sqrt_hat.size(), p.size(), G1.size(),\\n# h1.size(), G2.size(),h2.size(),\\n# E_sqrt.size(),F.size(),f.size())\\n\\n self.para = [Q_sqrt_hat, p, G1, h1, G2,\\n h2, E_sqrt, F, f]\\n u_opt,e_opt, = self.layer(Q_sqrt_hat, p, G1, h1, G2,\\n h2, E_sqrt, F, f,zero) # u_opt: batch*dim(u)\\n # for V(x0), defines the QP layer without equality \\n # constraints \\n else:\\n layer = QP_layer_no_eq(nz=self.num_u, nineq_u=\\n self.num_ineq_u, nineq_x=self.num_ineq_x)\\n self.para = [Q_sqrt_hat, p, G1, h1, G2,\\n h2, E_sqrt] \\n # gets the solution of the basic optimization problem\\n u_opt,e_opt, = layer(Q_sqrt_hat, p, G1, h1, G2, h2, \\n E_sqrt,zero) # u_opt: batch*dim(u)\\n\\n # get the optimal cost\\n # a+b: sum(i:1 to N): xi^T*Q*xi + u(i-1)^T*R*u(i-1)\\n # c: x0^T*Q*x0\\n # d:(i:1 to N):ei^T*E*ei\\n a = (u_opt.mm(Q_hat)*u_opt + p*u_opt).sum(1)\\n b = (A_x0.mm(Q_diag)*A_x0).sum(1)\\n c = (x0.mm(Q)*x0).sum(1)\\n d = (e_opt.mm(E)*e_opt).sum(1)\\n cost_opt = (a+b+c+d).unsqueeze(1) # size: batch*1\\n u0_opt = u_opt.mv(self.weight) # only the fisrt action\\n #print(u0,u0_opt)\\n return cost_opt, u0_opt\",\n \"def forward(self, x: torch.Tensor) -> torch.Tensor:\\n return torch.nn.functional.linear(\\n x,\\n self.weight_mu + self.weight_sigma * self.weight_epsilon,\\n self.bias_mu + self.bias_sigma * self.bias_epsilon,\\n )\",\n \"def forward(self, X):\\n self._X = X # For backprop later on.\\n self._z = np.dot(X, self._W) + self._b\\n a = self._act.a(self._z)\\n return a\",\n \"def computeQValueFromValues(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n transition_state_probs = self.mdp.getTransitionStatesAndProbs(state, action)\\n # Add each state and probability to q_value\\n q_value = 0\\n for state_, probability in transition_state_probs:\\n state_reward = self.mdp.getReward(state, state_, action)\\n q_value += probability * (state_reward + self.discount * self.values[state_])\\n return q_value\",\n \"def update_q_values(self, state, value):\\n if self.prev_state is not None and self.learning:\\n reward = self.reward(Game.game_state(state))\\n self.q_values[self.represent_state(self.prev_state), self.prev_action] += self.alpha * (\\n reward + self.gamma * value - self.prev_q_val)\",\n \"def forward(self, state_t):\\n # Use your network to compute qvalues for given state\\n qvalues = self.network(state_t)\\n\\n assert qvalues.requires_grad, \\\"qvalues must be a torch tensor with grad\\\"\\n assert len(\\n qvalues.shape) == 2 and qvalues.shape[0] == state_t.shape[0] and qvalues.shape[1] == self.n_actions\\n\\n return qvalues\",\n \"def forward(self, w_value, x_value, b_value):\\n self.inputs = [w_value, x_value, b_value]\\n # return np.matmul(x_value, w_value) + b_value # [Note] Matmul Order\\n return x_value.dot(w_value) + b_value # [Note] Matmul Order\",\n \"def forward(self, state_t):\\n # Use your network to compute qvalues for given state\\n conved_1 = self.conv1(state_t)\\n conved_2 = self.conv2(conved_1)\\n conved_3 = self.conv3(conved_2)\\n qvalues = self.dense(conved_3)\\n\\n assert qvalues.requires_grad, \\\"qvalues must be a torch tensor with grad\\\"\\n assert len(\\n qvalues.shape) == 2 and qvalues.shape[0] == state_t.shape[0] and qvalues.shape[1] == n_actions\\n\\n return qvalues\",\n \"def forward(self, state, action):\\n # Pass the states into the first layer\\n x = self.fc_layers[0](state)\\n x = self.bn(x)\\n x = F.relu(x)\\n # Concatenate the first layer output with the action\\n x = torch.cat((x, action), dim=1)\\n # Pass the input through all the layers apllying ReLU activation, but the last\\n for layer in self.fc_layers[1:-1]:\\n x = F.relu(layer(x))\\n # Pass the result through the output layer apllying sigmoid activation\\n x = torch.sigmoid(self.fc_layers[-1](x))\\n # Return the Q-Value for the input state-action\\n return x\",\n \"def computeQValueFromValues(self, state, action):\\n\\n ##util.raiseNotDefined()\\n #\\\"*** YOUR CODE STARTS HERE ***\\\"\\n # Code to remove --- from here\\n transitions = self.mdp.getTransitionStatesAndProbabilities(state, action)\\n qvalue = 0\\n for (nextState, probability) in transitions:\\n reward = self.mdp.getReward(state, action, nextState)\\n qvalue += probability *(reward + self.discount*self.values[nextState])\\n # Code to remove --- to here\\n #\\\"*** YOUR CODE FINISHES HERE ***\\\"\\n \\n return qvalue\",\n \"def training_step(self):\\n self.iteration += 1\\n # if not enough replay memories\\n if self.iteration < self.params.min_replays:\\n # skip training\\n return\\n # sample memories\\n states_val, action_val, rewards, next_state_val, continues \\\\\\n = (rl.tools.sample_memories(self.memory, self.params.batch_size))\\n # evaluate the target q\\n target_q = self.sess.run(self.graph.target_q_values, feed_dict={self.graph.states: next_state_val})\\n # if using double q\\n if self.params.double_q:\\n online_q = self.sess.run(self.graph.online_q_values, feed_dict={self.graph.states: next_state_val})\\n actions = np.argmax(online_q, axis=1)\\n max_next_q_values = target_q[np.arange(actions.shape[0]), actions].reshape(-1, 1)\\n else:\\n max_next_q_values = np.max(target_q, axis=1, keepdims=True)\\n # train the online DQN\\n td_target = rewards + continues * self.params.discount_factor * max_next_q_values\\n _, self.loss_val = self.sess.run([self.graph.training_op, self.graph.loss],\\n feed_dict={self.graph.states: states_val, self.graph.actions: action_val,\\n self.graph.td_target: td_target})\\n # copy to target\\n if self.params.copy_interval is None or (\\n self.params.copy_interval and (self.iteration % self.params.copy_interval == 0)):\\n self.sess.run(self.graph.copy_online_to_target)\",\n \"def train_step(self, experiences, gamma):\\n states = experiences['states']\\n rewards = experiences['rewards']\\n actions = experiences['actions']\\n next_states = experiences['next_states']\\n dones = experiences['dones']\\n q_values = self.main_network(states).gather(1, actions.view(-1, 1)).squeeze()\\n\\n # Get max predicted Q values (for next states) from target model\\n next_q_values = self.target_network(next_states).detach().max(1)[0]\\n\\n # Compute Q targets for current states\\n expected_q_value = rewards + (gamma * next_q_values * (1 - dones))\\n\\n # Compute loss\\n loss = F.mse_loss(q_values, expected_q_value)\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # Update the target network\\n self.soft_update(self.main_network, self.target_network, TAU)\",\n \"def forward(self, state):\\n if self.noisy:\\n lower, upper = self.x[0], self.x[-1]\\n test_x = lower + torch.rand(len(self.x)) * (upper - lower)\\n else:\\n test_x = self.x\\n\\n with torch.no_grad(), gpytorch.settings.fast_pred_var():\\n pred = self.gp(test_x)\\n ucb = pred.mean + self.beta() * pred.stddev\\n\\n max_id = torch.argmax(ucb)\\n next_point = test_x[[[max_id]]]\\n return next_point, torch.zeros(1)\",\n \"def Q(self, value):\\n assert value > 0, \\\"Q needs to be positive and above zero (we divide by Q)\\\"\\n self._Q = value\\n self._update()\",\n \"def update_policy(self, minibatch_size):\\n \\n steps = self.rewards.shape[0]\\n batch_size = self.rewards.shape[0] * self.rewards.shape[1]\\n #steps = 500\\n #batch_size = 500\\n #print(steps)\\n #print(batch_size)\\n \\n # Compute advantages\\n '''\\n with torch.no_grad():\\n if self.gae:\\n advantages = torch.zeros_like(self.rewards).to(self.training_device)\\n lastgaelam = 0\\n for t in reversed(range(steps)):\\n if t == steps - 1:\\n nextnonterminal = 1.0 - self.dones[t]\\n nextvalues = self.state_values[t]\\n else:\\n nextnonterminal = 1.0 - self.dones[t + 1]\\n nextvalues = self.state_values[t + 1]\\n delta = self.rewards[t] + self.gamma * nextvalues * nextnonterminal - self.state_values[t]\\n advantages[t] = lastgaelam = delta + self.gamma * self.gae_lambda * nextnonterminal * lastgaelam\\n returns = advantages + self.state_values\\n else:\\n returns = torch.zeros_like(self.rewards).to(self.training_device)\\n for t in reversed(range(steps)):\\n if t == steps - 1:\\n nextnonterminal = 1.0 - self.dones[t]\\n next_return = self.state_values[t]\\n else:\\n nextnonterminal = 1.0 - self.dones[t+1]\\n next_return = returns[t+1]\\n returns[t] = self.rewards[t] + self.gamma * nextnonterminal * next_return\\n advantages = returns - self.state_values\\n ''' \\n returns = torch.zeros_like(self.rewards).to(self.training_device)\\n for t in reversed(range(steps)):\\n if t == steps - 1:\\n nextnonterminal = 1.0 - self.dones[t]\\n next_return = self.state_values[t]\\n else:\\n nextnonterminal = 1.0 - self.dones[t+1]\\n next_return = returns[t+1]\\n returns[t] = self.rewards[t] + self.gamma * nextnonterminal * next_return\\n advantages = returns - self.state_values\\n \\n\\n # flatten the batch\\n #b_obs = self.states.reshape((-1,) + self.state_space)\\n #print(self.states.shape)\\n b_obs = self.states.reshape((-1,4)).detach()\\n b_logprobs = self.action_probs.reshape(-1,1).detach()\\n b_actions = self.actions.reshape((-1,)).detach()\\n b_advantages = advantages.reshape(-1,1)\\n b_returns = returns.reshape(-1,1)\\n b_values = self.state_values.reshape(-1,1)\\n \\n # Optimize policy and value network for K epochs, run optimization in minibatches\\n \\n inds = np.arange(batch_size)\\n for i_epoch_pi in range(self.epochs):\\n np.random.shuffle(inds)\\n for start in range(0, batch_size, minibatch_size):\\n end = start + minibatch_size\\n minibatch_ind = inds[start:end]\\n mb_advantages = b_advantages[minibatch_ind]\\n if self.norm_adv:\\n mb_advantages = (mb_advantages - mb_advantages.mean()) / (mb_advantages.std() + 1e-8)\\n \\n #_, newlogproba, entropy = self.get_action(b_obs[minibatch_ind], b_actions[minibatch_ind])\\n newlogproba, entropy = self.evaluate(b_obs[minibatch_ind], b_actions[minibatch_ind])\\n #ratio = (newlogproba - b_logprobs[minibatch_ind]).exp()\\n ratio = torch.exp((newlogproba - b_logprobs[minibatch_ind].detach()))\\n \\n # Stats\\n approx_kl = (b_logprobs[minibatch_ind] - newlogproba).mean()\\n\\n # Policy loss\\n pg_loss1 = -mb_advantages * ratio\\n pg_loss2 = -mb_advantages * torch.clamp(ratio, 1 - self.clip_epsilon, 1 + self.clip_epsilon)\\n pg_loss = torch.max(pg_loss1, pg_loss2).mean()\\n entropy_loss = entropy.mean()\\n\\n # Value loss\\n _, new_values = self.policy.forward(b_obs[minibatch_ind])\\n if self.clip_vloss:\\n \\n v_loss_unclipped = self.MseLoss(new_values,b_returns[minibatch_ind])\\n #v_loss_unclipped = ((new_values - b_returns[minibatch_ind]) ** 2)\\n v_clipped = b_values[minibatch_ind] + torch.clamp(new_values - b_values[minibatch_ind],\\n -self.clip_epsilon, self.clip_epsilon)\\n #v_loss_clipped = (v_clipped - b_returns[minibatch_ind]) ** 2\\n v_loss_clipped = self.MseLoss(v_clipped,b_returns[minibatch_ind])\\n v_loss_max = torch.max(v_loss_unclipped, v_loss_clipped)\\n #v_loss = 0.5 * v_loss_max.mean()\\n v_loss = 0.5 * v_loss_max\\n else:\\n #v_loss = 0.5 * ((new_values - b_returns[minibatch_ind]) ** 2).mean()\\n v_loss = self.MseLoss(new_values,b_returns[minibatch_ind])\\n\\n loss = pg_loss + v_loss * self.vf_coeff - self.ent_coeff * entropy_loss\\n\\n self.optimizer.zero_grad()\\n loss.backward()\\n torch.nn.utils.clip_grad_norm_(self.policy.parameters(), self.max_grad_norm)\\n self.optimizer.step()\\n # Copy new weights into old policy:\\n self.old_policy.load_state_dict(self.policy.state_dict())\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # OUR CODE HERE\\n #get the value of the state\\n qVal = self.values[state]\\n #iterate through the MDP transition states from the current state\\n for transitionState, probability in self.mdp.getTransitionStatesAndProbs(state, action):\\n #q value = discount * expected value of reward of state\\n qVal += self.discount * probability * self.values[transitionState]\\n return qVal\\n # END OUR CODE\",\n \"def update(self, state, action, nextState, reward):\\n \\\"*** YOUR CODE HERE ***\\\"\\n Q_Value = self.Q #calling constructor\\n\\n learning_rate = self.alpha #gives us the learning rate\\n\\n temporary_QValue = self.getQValue(state,action) #to get the Q value of the state\\n\\n nextState_QValue = self.getValue(nextState) #to get the Q value of the landing state when taken action a and state s\\n\\n discount_factor = self.discount #to get the gamma/ discount factor\\n\\n\\n Q_Value[(state,action)] = ((1-learning_rate) * temporary_QValue) + (learning_rate * (reward + discount_factor * nextState_QValue)) #for formula go to README_Reinforcement.txt at line 8\\n\\n #util.raiseNotDefined()\",\n \"def train_step(self):\\n # Sample training batch from replay\\n training_batch = self.replay.sample(self.batch_size)\\n\\n # Calculate target Q values for each example:\\n # For non-terminal states, targetQ is estimated according to\\n # targetQ = r + gamma*Q'(s',max_a Q(s',a))\\n # where Q' denotes the target network.\\n # For terminating states the target is computed as\\n # targetQ = r\\n updates = []\\n for exp in training_batch:\\n start,_,reward,end = exp\\n if(self.dampen_states):\\n # To dampen states (usually done after major patches or when the meta shifts)\\n # we replace winning rewards with 0.\\n reward = 0.\\n state_code = end.evaluate()\\n if(state_code==DraftState.DRAFT_COMPLETE or state_code in DraftState.invalid_states):\\n # Action moves to terminal state\\n updates.append(reward)\\n else:\\n # Follwing double DQN paper (https://arxiv.org/abs/1509.06461).\\n # Action is chosen by online network, but the target network is used to evaluate this policy.\\n # Each row in predicted_Q gives estimated Q(s',a) values for all possible actions for the input state s'.\\n feed_dict = {self.ddq_net.online_ops[\\\"input\\\"]:[end.format_state()],\\n self.ddq_net.online_ops[\\\"valid_actions\\\"]:[end.get_valid_actions()]}\\n predicted_action = self.ddq_net.sess.run(self.ddq_net.online_ops[\\\"prediction\\\"], feed_dict=feed_dict)[0]\\n\\n feed_dict = {self.ddq_net.target_ops[\\\"input\\\"]:[end.format_state()]}\\n predicted_Q = self.ddq_net.sess.run(self.ddq_net.target_ops[\\\"outQ\\\"], feed_dict=feed_dict)\\n\\n updates.append(reward + self.ddq_net.discount_factor*predicted_Q[0,predicted_action])\\n\\n # Update online net using target Q\\n # Experience replay stores action = (champion_id, position) pairs\\n # these need to be converted into the corresponding index of the input vector to the Qnet\\n actions = np.array([start.get_action(*exp[1]) for exp in training_batch])\\n targetQ = np.array(updates)\\n feed_dict = {self.ddq_net.online_ops[\\\"input\\\"]:np.stack([exp[0].format_state() for exp in training_batch],axis=0),\\n self.ddq_net.online_ops[\\\"actions\\\"]:actions,\\n self.ddq_net.online_ops[\\\"target\\\"]:targetQ,\\n self.ddq_net.online_ops[\\\"dropout_keep_prob\\\"]:0.5}\\n _ = self.ddq_net.sess.run(self.ddq_net.online_ops[\\\"update\\\"],feed_dict=feed_dict)\",\n \"def learn(self, experiences, gamma):\\n states_and_prev_recurrents, actions, recurrents, rewards, next_states, dones = experiences\\n\\n # Get max predicted Q values (for next states) from target model\\n next_states_and_recurrents = torch.cat([next_states, recurrents], dim=1)\\n Q_targets_next = self.qnetwork_target(next_states_and_recurrents).detach().max(1)[0].unsqueeze(1)\\n # Compute Q targets for current states\\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n\\n # Get expected Q values from local model\\n Q_expected = self.qnetwork_local(states_and_prev_recurrents).gather(1, actions)\\n\\n # Compute loss\\n loss_rl = F.mse_loss(Q_expected, Q_targets)\\n\\n states = states_and_prev_recurrents[:, :8]\\n target_recurrents = map_observation_to_recurrent_state(states)\\n recurrent_pred = self.qnetwork_local(states_and_prev_recurrents)[:, -5:]\\n\\n loss_internal_states = F.multilabel_soft_margin_loss(recurrent_pred, target_recurrents)\\n\\n loss = loss_rl + loss_internal_states\\n\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states = experiences\\n\\n # Get max predicted Q values (for next states) from target model\\n next_action_targets = self.target_model(next_states)\\n next_action = next_action_targets.max(1)[0].unsqueeze(-1)\\n targets = rewards + (gamma * torch.Tensor(next_action))\\n#\\n # Get expected Q values from policy model\\n action_policy = self.policy_model(states)\\n policy = action_policy.gather(1, actions)\\n # Compute loss\\n loss = F.mse_loss(policy, targets)\\n # Minimize the loss\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.policy_model, self.target_model, self.tau)\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n qvalue = 0\\n features = self.featExtractor.getFeatures(state, action)\\n #Each feature is in the form of dictionary {((3, 3), 'east'): 1.0}. Each key is a combination of coordinate and direction. Each value represents the old qvalue.\\n for feature in features.keys():\\n qvalue += features[feature] * self.weights[feature]\\n return qvalue\",\n \"def learn(self, state, action, reward, state_):\\n self.Q.optimizer.zero_grad()\\n states = T.tensor(state, dtype=T.float).to(self.Q.device)\\n action = T.tensor(action).to(self.Q.device)\\n reward = T.tensor(reward).to(self.Q.device)\\n states_ = T.tensor(state_, dtype=T.float).to(self.Q.device)\\n\\n q_pred = self.Q.forward(states)[action]\\n\\n q_next = self.Q.forward(states_).max()\\n\\n q_target = reward + self.gamma*q_next\\n\\n loss = self.Q.loss(q_target, q_pred).to(self.Q.device)\\n loss.backward()\\n self.Q.optimizer.step()\\n self.decrement_epsilon()\",\n \"def getQValue(self, gameState, action):\\n features = self.getFeatures(gameState, action)\\n return features * self.weights\",\n \"def computeQValueFromValues(self, state, action):\\n\\n # Find expected utility of making this move\\n x = 0\\n for t in self.mdp.getTransitionStatesAndProbs(state,action):\\n x += t[1] * self.getValue(t[0])\\n\\n\\n # Return Reward + discounted expected utility\\n return self.mdp.getReward(state,None,None) + self.discount*x\",\n \"def act(self, state_and_prev_recurrent, eps=0.):\\n state_and_prev_recurrent = torch.from_numpy(state_and_prev_recurrent).float().unsqueeze(0).to(device)\\n self.qnetwork_local.eval()\\n with torch.no_grad():\\n action_values = self.qnetwork_local(state_and_prev_recurrent)[:, :4]\\n self.qnetwork_local.train()\\n\\n # Epsilon-greedy action selection\\n if random.random() > eps:\\n return np.argmax(action_values.cpu().data.numpy())\\n else:\\n return random.choice(np.arange(self.action_size))\",\n \"def q_update(self):\\n\\n # exit if the experience buffer is not yet large enough\\n if self.experience_buffer.size < self.batch_size:\\n return\\n \\n # get the random batch\\n states, action_indices, rewards, not_terminals, succ_states, succ_players, succ_legal_moves = self.experience_buffer.random_batch(self.batch_size)\\n states = states.to(Globals.device)\\n action_indices = action_indices.to(Globals.device)\\n rewards = rewards.to(Globals.device)\\n not_terminals = not_terminals.to(Globals.device)\\n succ_states = succ_states.to(Globals.device)\\n succ_players = succ_players.to(Globals.device)\\n\\n # prepare the training data\\n q_values = self.target_network(succ_states)\\n target = torch.empty(1, self.batch_size)\\n for i in range(self.batch_size):\\n if not_terminals[i] == 0:\\n target[0, i] = rewards[i]\\n continue\\n\\n if succ_players[i] == CONST.WHITE_MOVE:\\n legal_q_values = q_values[0, 0:9][succ_legal_moves[i]]\\n q_value, _ = legal_q_values.max(0)\\n else:\\n legal_q_values = q_values[0, 9:18][succ_legal_moves[i]]\\n q_value, _ = legal_q_values.min(0)\\n\\n target[0, i] = rewards[i] + self.disc*not_terminals[i]*q_value\\n\\n # execute the training step of the network\\n self.training_network.train_step(states, target, action_indices) # the eligibility trace is used as td target\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones = experiences\\n # print('learn states.shape', states.shape)\\n # print('learn next_states.shape', next_states.shape)\\n \\n q_expected, q_targets = self.get_target_and_expected(states, \\n actions, \\n rewards, \\n next_states, \\n dones, \\n gamma)\\n\\n\\n # Compute loss\\n loss = F.mse_loss(q_expected, q_targets)\\n # Minimize the loss\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)\",\n \"def forward(self, x):\\n # Compute the mean norm of activations per channel.\\n nu2 = x.pow(2).mean(dim=[2, 3], keepdim=True)\\n\\n # Perform FRN.\\n x = x * torch.rsqrt(nu2 + self.eps.abs())\\n\\n # Scale and Bias\\n if self.is_scale:\\n x = self.weight * x\\n if self.is_bias:\\n x = x + self.bias\\n return x\",\n \"def forward(self, x):\\n n, c, t, v = x.size()\\n x1 = x.view(n, c * t, v)\\n y = None\\n for i in range(self.num_subset):\\n A1 = self.PA[i]\\n z = self.conv_d[i](torch.matmul(x1, A1).view(n, c, t, v))\\n y = z + y if y is not None else z\\n A2 = self.cen(x)\\n z2 = torch.matmul(x1, A2).view(n, c, t, v)\\n z2 = self.conv_cen(z2)\\n y += self.lamb * z2\\n y = self.bn(y)\\n y += self.down(x)\\n y = self.relu(y)\\n y = self.attention(y)\\n return y\",\n \"def update1(self, state, action, nextState, reward):\\n #print \\\"update1 in ApproximateQAgent\\\"\\n \\\"*** YOUR CODE HERE ***\\\"\\n ##################################################################################################################################Eric Did Stuff\\n actionList = nextState.getLegalActions(self.index)\\n\\n\\n #print \\\"Action List\\\", actionList\\n\\n\\n\\n\\n weights = self.getWeights()\\n\\n features = self.featExtractor.getFeatures(state, action, self)\\n #self.myFeats = features\\n if self.index == 0:\\n print \\\"FEATURES: \\\",features\\n value = self.computeValueFromQValues(nextState)\\n qValue = self.getQValue(state,action)\\n #print \\\"value\\\", value, \\\"qValue\\\", qValue\\n for feature in features:\\n if len(actionList) != 0:\\n weights[feature] = weights[feature] + self.alpha * (reward + self.discount * value - qValue) * features[feature]\\n else:\\n weights[feature] = weights[feature] + self.alpha * (reward - qValue) * features[feature]\\n #print \\\"feature\\\", feature, \\\"weights\\\", weights[feature]\\n #print \\\"weights\\\", weights\\n\\n #util.raiseNotDefined()\",\n \"def update_value(self, reward):\\n\\t\\tval = self.value\\n\\t\\tval = val + ((reward - val)/self.visited)\\n\\t\\tself.value = val\",\n \"def qlearning(env, iterations=1000, gamma=0.9, alpha=0.1):\\n nS = env.nS # number of states\\n nA = env.nA # number of actions\\n Q_value = np.zeros((nS, nA))\\n policy = np.ones((env.nS,env.nA))/env.nA\\n epsilon = 1\\n s_t1 = env.reset() # reset the environment and place the agent in the start square\\n ############################\\n # YOUR IMPLEMENTATION HERE #\\n # HINT: Don't forget to decay epsilon according to GLIE\\n\\n curr_state = s_t1\\n \\n start = time.time() # to time how long convergence takes\\n print(\\\"---Q Learning---\\\\nTraining Started.\\\")\\n \\n for k in range (1, iterations):\\n # if (k%10000) == 0:\\n # print(\\\"Now playing iteration: \\\", k)\\n epsilon = 1/k\\n curr_action, reward, new_state, done = take_one_step(env, policy, curr_state)\\n new_action = sample_action(policy, new_state)\\n Q_value[curr_state, curr_action] = Q_value[curr_state, curr_action] + alpha * (reward + gamma * (Q_value[new_state, np.argmax(Q_value[new_state])]) - Q_value[curr_state, curr_action])\\n \\n # epsilon-greedy policy update\\n Q_list = np.argwhere(Q_value[curr_state] == np.amax(Q_value[curr_state])).flatten() # get a list of all indices where Q is maximum, (argmax(Q))\\n max_Q = np.random.choice(Q_list.flatten()) # randomly pick from those indices. Picking each index is equally likely.\\n for a in range (nA):\\n if a == max_Q:\\n policy[curr_state][a] = epsilon/nA + (1 - epsilon) # for the chosen maximal index of Q, set the policy to epsilon/m + 1 - epsilon\\n else:\\n policy[curr_state][a] = epsilon/nA \\n \\n # print(\\\"Q_value = {0}\\\".format(Q_value))\\n # print(\\\"policy = {0}\\\".format(policy))\\n \\n if done:\\n curr_state = env.reset() # reset the environment and place the agent in the start square\\n curr_action = sample_action(policy, curr_state)\\n else:\\n curr_state = new_state\\n curr_action = new_action\\n \\n stop = time.time()\\n print(\\\"Training Completed.\\\")\\n print(\\\"It took: {0} iterations and {1} minutes\\\".format(k,(stop-start)/60))\\n \\n ############################\\n det_policy = np.argmax(Q_value, axis=1)\\n return Q_value, det_policy\",\n \"def computeQValueFromValues(self, state, action):\\n \\n \\n next_states_probs = self.mdp.getTransitionStatesAndProbs(state, action)\\n # liste des recompenses R(s,a,s')\\n rewards = []\\n # liste des probas de transitions P(s'|a,s)\\n probs = []\\n # liste des Vk(s')\\n previous_values = []\\n # occurence[0] = les next_state\\n # occurence[1] = les proba de transi\\n for occurence in next_states_probs:\\n rewards.append(self.mdp.getReward(state, action, occurence[0]))\\n probs.append(occurence[1])\\n previous_values.append(self.getValue(occurence[0]))\\n Q_value = 0\\n # boucle qui calcule somme des ( P(s'|a,s) * [R(s,a,s') + gamma * Vk(s')] ) sur les s'\\n for i in range(len(probs)):\\n Q_value += probs[i] * (rewards[i] + self.discount * previous_values[i])\\n \\n return Q_value\\n util.raiseNotDefined()\",\n \"def forward(self, input_x):\\n return self.net(input_x.float())\",\n \"def prediccion(self):\\n # Project the state ahead\\n self.X = self.F @ self.X + self.B @ self.M\\n self.P = self.F @ self.P @ self.F.T + self.Q\\n\\n return self.X\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # print \\\"getQValue\\\"\\n features = self.featExtractor.getFeatures(state, self.index)#.values()\\n #weights = self.weights.values()\\n #dotProduct = reduce( (lambda x, y: x*y), map( (lambda x, y: x+y), self.weights, features))\\n #return dotProduct\\n score = 0\\n for key in features.keys():\\n score += features[key]*self.weights[key]\\n return score\",\n \"def advantage(self, state):\\n Q = self.predict(state)\\n return Q - np.dot(self.π.pmf(state, Q), Q)\",\n \"def quantum_net(self, q_input_features, q_weights_flat):\\n\\n # Reshape weights\\n q_weights = q_weights_flat.reshape(self.args.q_depth, self.args.n_qubits, 3)\\n\\n # Start from state |+> , unbiased w.r.t. |0> and |1>\\n # Amplitude encoding\\n qml.QubitStateVector(q_input_features, wires=list(range(self.args.n_qubits)))\\n \\n # Sequence of trainable variational layers\\n for k in range(self.args.q_depth):\\n self.entangling_layer(self.args.n_qubits)\\n self.Rot_layer(q_weights[k])\\n\\n # Expectation values in the Z basis\\n exp_vals = [qml.expval(qml.PauliZ(position)) for position in range(self.args.target_class)]\\n return tuple(exp_vals)\",\n \"def getQValue(self, state, action):\\n features = self.featExtractor.getFeatures(state, action)\\n total = 0\\n for feat in features:\\n total += self.getWeights()[feat] * features[feat]\\n return total\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67463326","0.6215198","0.6126189","0.60463625","0.6016947","0.60107875","0.600079","0.598151","0.5964633","0.595709","0.5950874","0.59488696","0.5943859","0.5934017","0.59093964","0.5896094","0.58890605","0.5857793","0.58310497","0.58174837","0.579977","0.5798591","0.57938","0.57903445","0.57851666","0.57814026","0.5770534","0.5770534","0.57601297","0.5748083","0.57397264","0.57367706","0.57330817","0.5727399","0.5727159","0.57165533","0.570699","0.5697758","0.5696968","0.5696486","0.56620806","0.56576616","0.5647243","0.56453985","0.56414396","0.5634715","0.56321317","0.5631141","0.5624357","0.5620299","0.5619738","0.56118256","0.5603188","0.5603188","0.5594863","0.5581778","0.5568276","0.55674976","0.5561115","0.5560528","0.55534476","0.55493754","0.554388","0.5543701","0.5540772","0.55377597","0.5531491","0.55273855","0.551119","0.5510595","0.550562","0.5503964","0.55021906","0.5496681","0.549383","0.5492189","0.54765266","0.5469934","0.54694253","0.5463629","0.5462993","0.5447157","0.5446816","0.54462945","0.5442648","0.5439768","0.54388124","0.5434087","0.5416447","0.54121596","0.54042614","0.54040635","0.5403024","0.54019374","0.539096","0.53899777","0.53753227","0.536964","0.5366321"],"string":"[\n \"0.67463326\",\n \"0.6215198\",\n \"0.6126189\",\n \"0.60463625\",\n \"0.6016947\",\n \"0.60107875\",\n \"0.600079\",\n \"0.598151\",\n \"0.5964633\",\n \"0.595709\",\n \"0.5950874\",\n \"0.59488696\",\n \"0.5943859\",\n \"0.5934017\",\n \"0.59093964\",\n \"0.5896094\",\n \"0.58890605\",\n \"0.5857793\",\n \"0.58310497\",\n \"0.58174837\",\n \"0.579977\",\n \"0.5798591\",\n \"0.57938\",\n \"0.57903445\",\n \"0.57851666\",\n \"0.57814026\",\n \"0.5770534\",\n \"0.5770534\",\n \"0.57601297\",\n \"0.5748083\",\n \"0.57397264\",\n \"0.57367706\",\n \"0.57330817\",\n \"0.5727399\",\n \"0.5727159\",\n \"0.57165533\",\n \"0.570699\",\n \"0.5697758\",\n \"0.5696968\",\n \"0.5696486\",\n \"0.56620806\",\n \"0.56576616\",\n \"0.5647243\",\n \"0.56453985\",\n \"0.56414396\",\n \"0.5634715\",\n \"0.56321317\",\n \"0.5631141\",\n \"0.5624357\",\n \"0.5620299\",\n \"0.5619738\",\n \"0.56118256\",\n \"0.5603188\",\n \"0.5603188\",\n \"0.5594863\",\n \"0.5581778\",\n \"0.5568276\",\n \"0.55674976\",\n \"0.5561115\",\n \"0.5560528\",\n \"0.55534476\",\n \"0.55493754\",\n \"0.554388\",\n \"0.5543701\",\n \"0.5540772\",\n \"0.55377597\",\n \"0.5531491\",\n \"0.55273855\",\n \"0.551119\",\n \"0.5510595\",\n \"0.550562\",\n \"0.5503964\",\n \"0.55021906\",\n \"0.5496681\",\n \"0.549383\",\n \"0.5492189\",\n \"0.54765266\",\n \"0.5469934\",\n \"0.54694253\",\n \"0.5463629\",\n \"0.5462993\",\n \"0.5447157\",\n \"0.5446816\",\n \"0.54462945\",\n \"0.5442648\",\n \"0.5439768\",\n \"0.54388124\",\n \"0.5434087\",\n \"0.5416447\",\n \"0.54121596\",\n \"0.54042614\",\n \"0.54040635\",\n \"0.5403024\",\n \"0.54019374\",\n \"0.539096\",\n \"0.53899777\",\n \"0.53753227\",\n \"0.536964\",\n \"0.5366321\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5647406"},"document_rank":{"kind":"string","value":"42"}}},{"rowIdx":4899,"cells":{"query":{"kind":"string","value":"Gets the advantage and value by passing out of the base network through the value and advantage heads."},"document":{"kind":"string","value":"def adv_val(self, input_x) -> Tuple[Tensor, Tensor]:\n float_x = input_x.float()\n base_out = self.net(float_x)\n return self.fc_adv(base_out), self.fc_val(base_out)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_bias(self):","def __get_net_probs(self):\n return np.array([node.value for node in self.net]).reshape(5,5)","def net_output(self):\n result = self.gives()\n for k, v in self.needs().items():\n result[k] = result.get(k, 0) - v\n\n return result","def forward(self, obs):\n res = self.hidden_layers(obs)\n logits = self.logits(res)\n value = self.value_branch(res)\n return logits, value","def get_value(self):\n if not self.visited:\n # first visit at node\n self.visited = True\n\n # value calculation\n for node, weight in self.predecessors:\n self.value += (node.get_value() * weight)\n\n # applying activation function\n if self.activation is not None:\n self.activation()\n\n self.calculated = True\n\n return self.value\n else:\n # visited node\n if self.calculated:\n # calculated in this computation\n return self.value\n else:\n # recurrent connection\n return self.past_value","def test_find_highest_value_node_first(self):\n nn = NeuralNet(0, 0, '', '', blank=True)\n nn.create_net(2, 2, 2, 2)\n nn.eta = 0.1\n\n # Override weights to static value for reproducibility\n for node in nn.layers[2].nodes:\n node.weights = [0.6, 0.6]\n\n nn.layers[3].nodes[0].weights = [1.0, 1.0]\n nn.layers[3].nodes[1].weights = [0.0, 0.0]\n\n val = nn.assign_output([2, 3], test=True)\n self.assertEqual(val, '10')","def forward(self, input):\n mean, std = self.mean_net(input), self.std_net(input)\n return mean, std","def adv_val(self, input_x):\n float_x = input_x.float()\n base_out = self.conv(input_x).view(float_x.size()[0], -1)\n return self.head_adv(base_out), self.head_val(base_out)","def test_forward_values():\n rnn = GeneratorRNN(1)\n inputs = Variable(torch.zeros(1,1,3))\n hidden = rnn.init_hidden()\n e,pi,mu,sigma,rho,_ = rnn(inputs, hidden)\n\n assert (e >= 0).all()\n assert (e <= 1).all()\n\n diff = torch.abs(1-torch.sum(pi))\n assert (diff < 0.00001).all()\n\n assert (sigma > 0).all()\n\n assert (rho > -1).all()\n assert (rho < 1).all()\n\n rnn = GeneratorRNN(3)\n inputs = Variable(torch.zeros(10,1,3))\n hidden = rnn.init_hidden()\n e,pi,mu,sigma,rho,_ = rnn(inputs, hidden)\n\n pi_sum = torch.sum(pi,dim=2)\n diff = torch.abs(1-pi_sum)\n assert (diff < 0.00001).all()","def get_weights(self):","def getWeight(self) -> float:\n ...","def bias_prior(self):","def get_hidden_values(self, data):\n return T.nnet.sigmoid(T.dot(data, self.w1) + self.b1)","def weight(self):","def get_q_values(self, state, network):\n out = None\n state = state.permute(0, 3, 1, 2)\n #pdb.set_trace()\n ##############################################################\n ################ YOUR CODE HERE - 4-5 lines lines ################\n if network == 'q_network':\n out = self.q_network(state)\n else:\n out = self.target_network(state)\n ##############################################################\n ######################## END YOUR CODE #######################\n return out","def analyze_belief_strength_with_bias(self, G):\r\n n = []\r\n nbs_list = []\r\n for node in G.nodes: #cycles through the nodes of the graph to mine the attributes\r\n n.append(node) #appends each node to a list that will be put into a dictionary\r\n pbs_list = []\r\n og_bs = G.nodes[node]['belief_strength'] #mines the numerical value for a nodes belief strength, from a pre-set node attribute\r\n unc = G.nodes[node]['uncertainty'] #mines the numerical value for a nodes belief uncertainty, from a pre-set node attribute\r\n prob = G.nodes[node]['probability']\r\n for pre in G.predecessors(node):\r\n ew = G.edges[pre, node]['weight'] #mines the numerical value of an edge's weight, from a pre-set edge attribute\r\n pre_bs = G.nodes[pre]['belief_strength'] #mines the numerical value for a predecessors belief strength, from a pre-set node attribute\r\n x = ew * pre_bs #determines how much a node values its neighbor's opinion.\r\n pbs_list.append(x) #puts all values for predecessor belief strangths in a list\r\n if len(pbs_list) == 0:\r\n nbs = og_bs\r\n nbs = int(nbs)\r\n else:\r\n apbs = sum(pbs_list)/len(pbs_list) #calculates the average predecessor belief strength value for a node\r\n if apbs*og_bs > 0:\r\n if apbs > 0:\r\n nbs = min(og_bs + (0.1*prob*unc*apbs), 100)\r\n else:\r\n nbs = max(og_bs + (0.1*prob*unc*apbs), -100)\r\n nbs = int(nbs)\r\n else:\r\n nbs = og_bs\r\n nbs = int(nbs)\r\n nbs_list.append(nbs) #the new belief strengths are appended to a list that will be put into adictionary\r\n change = dict(zip(n, nbs_list)) #creates a dictionary from two lists which stores the nodes as keys and their new belief strengths as values\r\n print(change)\r\n return change #this will be used to update the list in a different function\r","def value(self, observation, prev_action, prev_reward):\n agent_inputs = buffer_to((observation, prev_action, prev_reward),\n device=self.device)\n _mu, _log_std, value, _rnn_state = self.model(*agent_inputs, self.prev_rnn_state)\n return value.to(\"cpu\")","def forward(self, value, query, lens):\n relevant_scores = self.relevant_score(value, query, lens)\n e_relevant_scores = torch.exp(relevant_scores)\n weights = e_relevant_scores / e_relevant_scores.sum(-1, keepdim=True)\n attention = (weights.unsqueeze(-1) * value).sum(1)\n return attention","def res_get(hp2res, hp_dict, hp_labels):\n logg = logging.getLogger(f\"c.{__name__}.res_get\")\n logg.setLevel(\"INFO\")\n logg.debug(f\"Start res_get\")\n\n # build the hp_set for the corresponding bar\n hp_set = []\n for label in hp_labels:\n hp_set.append(hp_dict[label])\n hp_set = tuple(hp_set)\n # get the corresponding loss value\n hp_val = hp2res[hp_set]\n\n logg.debug(f\"hp_set {hp_set} hp_val {hp_val}\")\n return hp_val","def _learn_node_parameter_var(outputs, weights, inputs):\n var = 0.\n\n \"\"\" YOUR CODE HERE \"\"\"\n temp = 0\n N_observe = outputs.shape[0]\n if inputs is None:\n temp = np.sum((outputs-weights[0])**2)\n else:\n for i in range(N_observe):\n temp += (outputs[i] - (np.sum(weights[1:] * inputs[i]) +weights[0]))**2\n var = temp/N_observe\n\n\n\n \"\"\" END YOUR CODE HERE \"\"\"\n\n return var","def getQValue(self, state, action):\n #print \"getQValue in ApproximateQAgent\"\n\n \"*** YOUR CODE HERE ***\"\n weights = self.getWeights()\n features = self.featExtractor.getFeatures(state, action, self)\n\n value = 0\n\n #print \"FEATURES: \", features\n #print \"WEIGHTS: \", weights\n\n for feature in features:\n value += features[feature]*weights[feature]\n return value\n #util.raiseNotDefined()","def get_reward(self):\n # Ver list\n self.Verlist = {\n '1': False,\n '2': False,\n '3': False,\n '4': False,\n '5': True,\n }\n # --------------------------------- NEW ----\n r = 0\n if self.ENVGetSIReset:\n V = {\n 'CoolRateTemp': self.DRateFun(self.mem['KCNTOMS']['Val']),\n 'CurrentTemp': self.mem['UAVLEG2']['Val'],\n 'CurrentPres': self.mem['ZINST65']['Val'],\n 'Dis': abs(self.DRateFun(self.mem['KCNTOMS']['Val']) - self.mem['UAVLEG2']['Val']),\n 'PZRLevel': self.mem['ZINST63']['Val'],\n 'SG1Nar': self.mem['ZINST78']['Val'], 'SG2Nar': self.mem['ZINST77']['Val'],\n 'SG3Nar': self.mem['ZINST76']['Val'],\n 'SG1Wid': self.mem['ZINST72']['Val'], 'SG2Wid': self.mem['ZINST71']['Val'],\n 'SG3Wid': self.mem['ZINST70']['Val'],\n 'SG1Pres': self.mem['ZINST75']['Val'], 'SG2Pres': self.mem['ZINST74']['Val'],\n 'SG3Pres': self.mem['ZINST73']['Val'],\n }\n if self.Verlist['1']:\n # Cooling rate에 따라서 온도 감소\n r -= V['Dis'] / 100\n # 가압기 수위 10 아래 종료\n # if V['PZRLevel'] <= 10: r -= 100\n if self.Verlist['2']:\n # 목표치까지 도달\n r += (29.5 - V['CurrentPres']) / 100\n r += (170 - V['CurrentTemp']) / 100\n if self.Verlist['3']:\n # Cooling rate에 따라서 온도 감소\n dis_reward = - V['Dis'] / 100 # [0.0 ~ -0.2] 동향을 보임\n # Pressure and Temp Dis\n curp = 29.5 if V['CurrentPres'] <= 29.5 else V['CurrentPres']\n curt = 170 if V['CurrentTemp'] <= 170 else V['CurrentTemp']\n dis_pres = (29.5 - V['CurrentPres']) / 100\n dis_temp = (170 - V['CurrentTemp']) / 100\n\n # r += (dis_pres * 0.1) + (dis_temp * 0.1) + (dis_reward * 10) # 감압 X\n r += (dis_pres * 0.1) + (dis_reward * 5)\n if self.Verlist['4']:\n # Cooling rate에 따라서 온도 감소\n dis_reward = - V['Dis'] / 100 # [0.0 ~ -0.2] 동향을 보임\n # Pressure and Temp Dis\n curp = 29.5 if V['CurrentPres'] <= 29.5 else V['CurrentPres']\n dis_pres = (29.5 - V['CurrentPres']) / 100\n PT_reward = - PTCureve().Check(Temp=V['CurrentTemp'], Pres=V['CurrentPres'])\n r += (dis_pres * 0.1) + (dis_reward * 5) + (PT_reward * 0.1)\n if self.Verlist['5']:\n r = 0\n # 1] Cooling rate에 따라서 온도 감소\n coolrate_r = - V['Dis']\n # 2] 가압기 수위 20~76% 구간 초과시 패널티\n pzrlevel_r = 0\n if 20 <= V['PZRLevel'] <= 76:\n pass\n else:\n if 20 > V['PZRLevel']:\n pzrlevel_r -= (20 - V['PZRLevel'])\n else:\n pzrlevel_r -= (V['PZRLevel'] - 76)\n # 3] 증기 발생기 6% ~ 50% 이상 초과 시 패널티\n sg_r = 0\n for _ in range(1, 4):\n if 6 <= V[f'SG{_}Nar'] <= 50:\n pass\n else:\n if 6 > V[f'SG{_}Nar']:\n sg_r -= (6 - V[f'SG{_}Nar'])\n else:\n sg_r -= (V[f'SG{_}Nar'] - 50)\n # 4] PT 커브에서 벗어나면 거리만큼 패널티\n PT_reward = - PTCureve().Check_Dis(Temp=V['CurrentTemp'], Pres=V['CurrentPres'])\n # 5] 목표치와 가까워 질 수록 +\n pres_r, temp_r = 0, 0\n pres_r = (29.5 - V['CurrentPres'])\n temp_r = (170 - V['CurrentTemp'])\n # 6] S/G 압력\n Avg_pres = (V['SG1Pres'] + V['SG2Pres'] + V['SG3Pres'])/3\n SGpres_r = 9 - Avg_pres if Avg_pres > 9 else 0\n # --------------------------------------------------------------\n w = {\n 'coolrate_r': [coolrate_r, 2],\n 'pzrlevel_r': [pzrlevel_r, 1],\n 'sg_r': [sg_r, 1.5],\n 'PT_reward': [PT_reward, 3],\n 'pres_r': [pres_r, 1],\n 'temp_r': [temp_r, 0.5],\n 'SGpres_r': [SGpres_r, 0.5]\n }\n\n log_txt_temp = ''\n for key in w.keys():\n r += w[key][0] * w[key][1]\n log_txt_temp += f'[{round(w[key][0]*w[key][1], 1)}:{w[key][0]}*{w[key][1]}]_'\n log_txt_temp = f'R:{r} = ' + log_txt_temp\n\n self.Loger_txt += log_txt_temp\n\n # self.Loger_txt += f\"R:{r} = {dis_pres * 0.1}+{dis_temp * 0.1}+({dis_reward * 10})\\t\"\n # self.Loger_txt += f\"R:{r} = {dis_pres * 0.1}+({dis_reward * 5})\\t\" #Verlist['3']\n # self.Loger_txt += f\"R:{r} = {dis_pres * 0.1}+({dis_reward * 5})+({PT_reward * 0.1})\\t\"\n\n # --------------------------------- Send R ----\n self.AcumulatedReward += r\n # self.Loger_txt += f'{r}\\t'\n self.DIS_CSF_Info += f'[R: {r}]\\t'\n return r","def forward(self, state):\n x = state\n feature = self.feature_layer(x)\n action_value = self.value_layer(feature)\n advantage = self.advantage_layer(feature)\n \n q_value = action_value + (advantage - advantage.mean(dim=1, keepdim=True))\n return q_value","def forward(self, state):\n\n # connect layers to each other and put relu activations between them\n for layer in self.hidden_layers:\n state = layer(state)\n state = F.relu(state)\n value = self.value_layer(state)\n return value","def forwardPolicyNet(self, state):\n with torch.no_grad():\n q_values = self.policy_net(state)\n return q_values","def _get_weight(self):\n return self.__weight","def _get_weight(self):\n return self.__weight","def _get_weight(self):\n return self.__weight","def _get_weight(self):\n return self.__weight","def _get_weight(self):\n return self.__weight","def _get_weight(self):\n return self.__weight","def _get_weight(self):\n return self.__weight","def _get_weight(self):\n return self.__weight","def value(self):\n #import pdb; pdb.set_trace()\n return ((self.team1.get_cur_hp() / self.team1.get_total_hp()) - \n (self.team2.get_cur_hp() / self.team2.get_total_hp()))","def _policy_nn(self):\n with tf.variable_scope(\"reward_params\") as scope:\n \n self.h1 = tf.layers.dense(self.input_ph, self.hidden_dim, tf.nn.tanh,\n kernel_initializer=tf.random_normal_initializer(\n stddev=np.sqrt(1 / self.params_dim)), name=\"h1\")\n self.h2 = tf.layers.dense(self.h1, self.hidden_dim, tf.nn.tanh,\n kernel_initializer=tf.random_normal_initializer(\n stddev=np.sqrt(1 / self.params_dim)), name=\"h2\")\n self.rewards = tf.layers.dense(self.h2, 1,\n kernel_initializer=tf.random_normal_initializer(\n stddev=np.sqrt(1 / self.hidden_dim)), name=\"rewards\")\n self.rewards_sum = tf.reduce_sum(self.rewards)","def get_hidden_values(self, input):\n return T.nnet.sigmoid(T.dot(input, self.W) + self.bh)","def get_thrust_value(self, command):\n return self._gain * numpy.abs(command) * command","def get(self) -> float:\n ...","def get_weight(self, val1, val2):\n\n\t\tnode1 = self.get_node(val1)\n\t\tnode2 = self.get_node(val2)\n\n\t\treturn node1.get_weight(node2)","def learn(self):\n # Calculate prior probabilities.\n self.priorpos = len(self.posdata) / (len(self.posdata) + len(self.negdata))\n self.priorneg = len(self.negdata) / (len(self.posdata) + len(self.negdata))\n print(\"Prior probability positive: \")\n print(self.priorpos)\n print(\"Prior probability negative: \")\n print(self.priorneg)\n\n # Calculate negative likelihood/conditional probability.\n occurpos = self.occurence(self.posvec)\n self.condpos = self.condprob(occurpos)\n occurneg = self.occurence(self.negvec)\n self.condneg = self.condprob(occurneg)","async def get_change(sochain_url, value_out, network, address):\n try:\n balance = await sochain_api.get_balance(sochain_url, network, address)\n balance = round(balance[0].amount * 10 ** 8)\n change = 0\n if balance - value_out > DUST_THRESHOLD:\n change = balance - value_out\n return change\n except Exception as err:\n raise Exception(str(err))","def net(input_lst, weight_lst, bias):\r\n net_total = bias\r\n\r\n for node in range(len(input_lst)):\r\n net_total += input_lst[node] * weight_lst[node]\r\n\r\n return net_total","def getWeights(self, gameState, action):\n return {'successorScore': 1.0}","def getWeights(self, gameState, action):\n return {'successorScore': 1.0}","def getWeights(self, gameState, action):\n return {'successorScore': 1.0}","def getWeights(self, gameState, action):\n return {'successorScore': 1.0}","def getWeights(self, gameState, action):\n return {'successorScore': 1.0}","def getWeights(self, gameState, action):\n return {'successorScore': 1.0}","def getWeights(self, gameState, action):\n return {'successorScore': 1.0}","def brain_weight_oz(self):\r\n return Heart.heart_weight_oz(self) # Used method from Heart Class\r","def forward(self, prev_state, obs_t):\r\n # Use your network to compute qvalues for given state\r\n #print(state_t.shape)\r\n h = self.conv(obs_t)\r\n\r\n h = h.view(h.size(0), -1)\r\n\r\n new_state = h_new, c_new = self.lstm(h, prev_state)\r\n advantage = self.adv(h_new)\r\n value = self.val(h_new)\r\n\r\n\r\n adv_mean = torch.mean(advantage, dim=1, keepdim=True)\r\n qvalues = value + advantage - adv_mean\r\n\r\n return new_state, qvalues","def LHopital(n, top, bot, accuracy=0.0001, scaledown=1.25):\n vtop = top(n)\n vbot = bot(n)\n i = 1\n while vtop == 0 and vbot == 0:\n vtop = deriv(top, n, i, accuracy, scaledown)\n vbot = deriv(bot, n, i, accuracy, scaledown)\n i += 1\n return vtop/vbot","def get_hidden_values(self, input):\r\n return T.nnet.sigmoid(T.dot(input, self.W) + self.b)","def get_hidden_values(self, input):\r\n return T.nnet.sigmoid(T.dot(input, self.W) + self.b)","def compute_loss(\n action_probs: tf.Tensor, values: tf.Tensor, returns: tf.Tensor\n) -> tf.Tensor:\n\n advantage = returns - values\n td = tf.subtract(returns, values)\n\n # actor\n # action_log_probs = tf.math.log(action_probs)\n # actor_loss = -tf.math.reduce_sum(action_log_probs * advantage)\n action_log_probs = tf.math.log(action_probs)\n actor_loss = -tf.math.reduce_mean(action_log_probs * td)\n\n # critic\n # td = tf.subtract(returns, values)\n # critic_loss = tf.reduce_mean(tf.square(td))\n critic_loss = huber_loss(values, returns)\n\n tf.print(\"a_loss:\", actor_loss, \"c_loss:\", critic_loss)\n\n return actor_loss + critic_loss","def gain(self):\n return self[1]","def get_expected_cost(self):","def value(self, observation, prev_action, prev_reward):\n model_inputs = buffer_to((observation, prev_action, prev_reward),\n device=self.device)\n _mu, _log_std, value = self.model(*model_inputs)\n return value.to(\"cpu\")","def baseEvaluate(self, gameState, action):\n features = self.getFeatures(gameState, action)\n weights = self.getWeights(gameState, action)\n return features * weights","def get_hyperparams(self):","def forward(self, pred, gt, weight=None):\n num_pos = torch.relu(torch.sum(gt) - 1) + 1\n num_neg = torch.relu(torch.sum(1 - gt) - 1) + 1\n if weight is not None:\n loss = nn.BCEWithLogitsLoss(reduction='none')(pred, gt.float())\n loss = torch.mean(loss * weight)\n elif self.balanced is False:\n loss = nn.BCEWithLogitsLoss(reduction='mean')(pred, gt.float())\n else:\n loss = nn.BCEWithLogitsLoss(pos_weight=num_neg * 1.0 / num_pos, reduction='mean')(pred, gt.float())\n\n # compute precision, recall, f1\n pred_labels = pred > 0\n gt, pred_labels, pred = gt.detach().cpu().numpy(), pred_labels.detach().cpu().numpy(), pred.detach().cpu().numpy()\n precision = precision_score(gt[0], pred_labels[0])\n recall = recall_score(gt[0], pred_labels[0])\n f1 = f1_score(gt[0], pred_labels[0])\n mean_logit_true = np.sum(pred * gt) / max(1, np.sum(gt))\n mean_logit_false = np.sum(pred * (1 - gt)) / max(1, np.sum(1 - gt))\n\n eval_stats = {\n \"loss\": loss,\n \"precision\": float(precision),\n \"recall\": float(recall),\n \"f1\": float(f1),\n \"logit_true\": float(mean_logit_true),\n \"logit_false\": float(mean_logit_false)\n }\n return eval_stats","def getWeights(self, gameState, actton):\n\t\treturn {'successorScore': 1.0}","def value(self) -> float:","def prediction_b(self):\r\n return self._prediction_b","def test_get_hyperflex_node_profile_by_moid(self):\n pass","def get_value_loss(flat_params):\n set_flat_params_to(value_net, tensor(flat_params))\n for param in value_net.parameters():\n if param.grad is not None:\n param.grad.data.fill_(0)\n values_pred = value_net(states)\n value_loss = (values_pred - returns).pow(2).mean() # MeanSquaredError\n\n # weight decay\n for param in value_net.parameters():\n value_loss += param.pow(2).sum() * l2_reg\n value_loss.backward()\n return value_loss.item(), get_flat_grad_from(value_net.parameters()).cpu().numpy()","def getWeight(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def _val_step(self, inputs, targets, extra_params):\n\n inputs = inputs.to(self.device)\n targets = targets.to(self.device, non_blocking=True)\n\n recons = self.generator(inputs)\n\n # Discriminator part.\n # pred_fake = self.discriminator(recons) # Generated fake image going through discriminator.\n # pred_real = self.discriminator(targets) # Real image going through discriminator.\n # gradient_penalty = compute_gradient_penalty(self.discriminator, targets, recons)\n # disc_loss = pred_fake.mean() - pred_real.mean() + self.lambda_gp * gradient_penalty\n\n # Generator part.\n # gen_loss = -pred_fake.mean()\n recon_loss = self.loss_funcs['recon_loss_func'](recons, targets)\n # total_gen_loss = gen_loss + self.recon_lambda * recon_loss\n\n step_loss = recon_loss\n step_loss_components = {'recon_loss': recon_loss}\n\n return recons, step_loss, step_loss_components","def value(self):\n return self.head","def evaluate(self, gameState, action):\n features = self.getFeatures(gameState, action)\n ####print \"features \", features\n weights = self.getWeights(gameState, action)\n ####print \"weights \", weights\n return features * weights","def get_net(netsnt, netrcv, tempsnt, temprcv):\n return {\n 'NET-PKT-SNT': (netsnt - tempsnt),\n 'NET-PKT-RCV': (netrcv - temprcv),\n }","def get_hidden_values(self, input):\n return T.nnet.sigmoid(T.dot(input, self.W) + self.b)","def get_hidden_values(self, input):\n return T.nnet.sigmoid(T.dot(input, self.W) + self.b)","def forward(self, input):\n\n common = self.common_tower(input)\n wdl = self.wdl_head(common)\n policy = self.policy_head(common)\n\n return wdl, policy","def call(self, obs):\n\t\tx = tf.convert_to_tensor(obs)\n\t\thidden_logs = self.hidden1(x)\n\t\thidden_vals = self.hidden2(x)\n\t\treturn self.logits(hidden_logs), self.value(hidden_vals)","def dealer_probs():\n # Pdf of any current hand (value, hard) and final value; p(v_f | v_c) where v_f = final value, v_c = current value\n probabilities = {}\n\n # End nodes: (value, True) for value >= 17 and (value, False) for value > 17\n # Dependencies (in order of increasing requirements):\n # Hard values, value >= 11, possiblity of bust, no possibility of going soft with an ace (value, True) depends on (value', True) for 17 > value' > value\n # Soft values, 17 >= value >= 11 (value, False) depends on (value', False) for 17 >= value' > value, (value', True) for 17 > value' > 11\n # Hard values, 11 > value >= 2 , no possibility of bust, possibility of going soft with an ace (value, True) depends on (value', True) for 17 > value' > value and (value', False) for 17 >= value' > 13\n\n\n # End nodes\n for value in xrange(17, 22):\n probabilities[(value, True)] = {value: 1.0}\n if value == 17: continue # on soft 17, dealer will still hit\n probabilities[(value, False)] = {value: 1.0}\n\n # Hard values, 17 > value >= 11, possibility of bust, no possibility of going soft with an ace\n for value in xrange(16, 10, -1):\n probabilities[(value, True)] = {}\n current_prob = probabilities[(value, True)]\n for next_card in xrange(1, min(10, 21-value)+1):\n next_prob = probabilities[(value + next_card, True)]\n for end_val in next_prob:\n current_prob[end_val] = current_prob.get(end_val, 0) + next_prob[end_val] * PROBABILITIES[next_card]\n\n # Soft values, 17 >= value >= 11\n for value in xrange(17, 10, -1):\n probabilities[(value, False)] = {}\n current_prob = probabilities[(value, False)]\n for next_card in xrange(1, 11):\n next_value = value + next_card\n hard = False\n if next_value > 21:\n next_value -= 10\n hard = True\n next_prob = probabilities[(next_value, hard)]\n for end_val in next_prob:\n current_prob[end_val] = current_prob.get(end_val, 0) + next_prob[end_val] * PROBABILITIES[next_card]\n\n # Hard values, 11 > value >= 2, no possibility of bust, possibility of going soft with an ace\n for value in xrange(10, 1, -1):\n probabilities[(value, True)] = {}\n current_prob = probabilities[(value, True)]\n for next_card in xrange(2, 12):\n next_value = value + next_card\n hard = (next_card != 11)\n next_prob = probabilities[(next_value, hard)]\n for end_val in next_prob:\n current_prob[end_val] = current_prob.get(end_val, 0) + next_prob[end_val] * PROBABILITIES[next_card]\n\n return probabilities","def test_find_highest_value_node_last(self):\n nn = NeuralNet(0, 0, '', '', blank=True)\n nn.create_net(2, 2, 2, 2)\n nn.eta = 0.1\n\n # Override weights to static value for reproducibility\n for node in nn.layers[2].nodes:\n node.weights = [0.6, 0.6]\n\n nn.layers[3].nodes[0].weights = [0.0, 0.0]\n nn.layers[3].nodes[1].weights = [1.0, 1.0]\n\n val = nn.assign_output([2, 3], test=True)\n self.assertEqual(val, '01')","def gibbs_ask_traffic(self, X, e, Z, bn, N):\n\n #makes copies\n X = e\n e = e\n\n #probability\n probability = [0,0]\n numerator = 0\n\n\n #True, False\n\n for x in range(N):\n # second joint\n if Z == True: # if non evidence variable\n random_choice = np.random.choice([0,1], 1, True, [0.5, 0.5])[0] #Rain or No Rain\n X[1] = bn[1][random_choice][0]\n else:\n random_choice = np.random.choice([0, 1], 1, True, [0.5, 0.5])[0] #Rain or No Rain\n X[1] = bn[1][random_choice][1]\n\n # first joint\n if X[1] == 0.8 or X[1] == 0.2: # Rain is true\n X[0] = bn[0][0]\n else: # Rain is False\n X[0] = bn[0][1]\n\n # third joint\n if X[1] == 0.8 or X[1] == 0.1: # traffic\n random_late = np.random.choice([0,1], 1, True, [0.5,0.5])[0]\n X[2] = bn[2][0][random_late]\n else: # no traffic\n random_late = np.random.choice([0, 1], 1, True, [0.5, 0.5])[0]\n X[2] = bn[2][1][random_late]\n\n # print(X)\n if X[0] == 0.1:\n probability[0] += 1\n else:\n probability[1] += 1\n\n\n probability[0] = probability[0] / N\n probability[1] = probability[1] / N\n # print(probability)\n return probability","def forward(self, x):\n dims = list(range(1, len(x.shape)))\n mean = x.mean(dim=dims, keepdim=True)\n var = torch.pow(x - mean, 2).mean(dim=dims, keepdim=True)\n return self.apply_gain_and_bias((x - mean) / (var + EPS).sqrt())","def getWeights(self, gameState, action):\n # return {'successorScore': 1.0}\n if self.isOffensive:\n return self.getOffensiveWeights(gameState, action)\n else:\n return self.getDefensiveWeights(gameState, action)","def test_get_damage(self):\n self.veh.health = 2.2\n for op in self.veh.operators:\n op.health = 0.5\n self.veh.get_damage(0.5)\n self.assertEqual(self.veh.health, 1.9)\n self.assertEqual(self.veh.operators[0].health, 0.4)\n self.assertEqual(self.veh.operators[1].health, 0.45)\n self.assertEqual(self.veh.operators[2].health, 0.45)","def getMyValue(self):\n valueBV = 0.0\n valueCR = 0.0\n valueAL = 0.0\n valueEC = 0.0\n valueIA = 0.0\n factorAL = globals.cityCRGen/globals.cityALGen\n factorEC = globals.cityCRGen/globals.cityECGen\n factorIA = globals.cityCRGen/globals.cityIAGen\n ratio = self.strength/100.0\n valueCR += self.myDesign.costCR*ratio\n valueAL += self.myDesign.costAL*ratio\n valueEC += self.myDesign.costEC*ratio\n valueIA += self.myDesign.costIA*ratio\n valueBV += (valueCR +\n valueAL*factorAL +\n valueEC*factorEC +\n valueIA*factorIA) / 1000.0\n return (valueBV, valueCR, valueAL, valueEC, valueIA)","def get_aff_net(sta):\n pass","def getQValue(self, gameState, action):\n features = self.getFeatures(gameState, action)\n return features * self.weights","def get_node_value(succs, preds):\n ret = 1\n if succs == 0:\n ret *= NODE_ENTRY\n\n if preds == 0:\n ret *= NODE_EXIT\n\n ret *= NODE_NORMAL\n return ret","def forward(self, x):\n x = F.relu(self.affine1(x))\n x = F.relu(self.affine2(x))\n\n # actor: choses action to take from state s_t\n # by returning probability of each action\n action_prob = F.softmax(self.action_head(x), dim=-1)\n\n # critic: evaluates being in the state s_t\n state_values = self.value_head(x)\n\n # return values for both actor and critic as a tupel of 2 values:\n # 1. a list with the probability of each action over the action space\n # 2. the value from state s_t\n return action_prob, state_values","def value_net(self):\n return functools.partial(self.value_net_fn, self.value_net_params)","def test_regression_relative_attention_bidirectional_values(self):\n outputs, unused_params = self.relative_attention.init_with_output(\n random.PRNGKey(0), self.query_len, self.key_len, bidirectional=True)\n self.assertEqual(outputs.shape,\n (1, self.num_heads, self.query_len, self.key_len))\n self.assertAlmostEqual(outputs[0, 0, 0, 0], 0.55764728, places=5)\n self.assertAlmostEqual(outputs[0, 1, 2, 1], -0.10935841, places=5)\n self.assertAlmostEqual(outputs[0, 1, 4, 6], 0.14510104, places=5)\n self.assertAlmostEqual(outputs[0, 2, 4, 6], -0.36783996, places=5)","def learn(self):\n \n # target parameter update\n # target parameter update\n if self.learn_step_counter % self.nu_iter == 0:\n self.target_net.load_state_dict(self.eval_net.state_dict())\n #testing the preformace of the network\n if self.learn_step_counter == 0:\n print('As referece this first test on dev data. Is maded with the Q networks, initialized randomly : ' )\n else:\n print(\"\\n Lets copy the Q-value Net in to Q-target net!. And test the performace on the dev data: \")\n \n current_bleu = self.dev_network()\n print(\"Current Bleu score is: \", current_bleu)\n \n self.learn_step_counter += 1\n\n \n long_Batch = self.sample_size*3\n # Sampling the higgest rewards values\n b_memory_big = self.memory[np.argsort(-self.memory[:-self.max_output_length, self.state_size+1])][:long_Batch]\n \n sample_index = np.random.choice(long_Batch, self.sample_size)\n b_memory = b_memory_big[sample_index, :]\n\n b_s = torch.FloatTensor(b_memory[:, :self.state_size])\n b_a = torch.LongTensor(b_memory[:, self.state_size:self.state_size+1].astype(int))\n b_r = torch.FloatTensor(b_memory[:, self.state_size+1:self.state_size+2])\n b_s_ = torch.FloatTensor(b_memory[:, self.state_size+2: self.state_size+2 + self.state_size])\n\n b_is_eos = torch.FloatTensor(b_memory[:, self.size_memory1-1:]).view(self.sample_size, 1)\n #print(b_a, b_a.size)\n #print(b_is_eos)\n #Activate the eval_net\n unfreeze_model(self.eval_net)\n \n # q_eval w.r.t the action in experience\n q_eval = self.eval_net(b_s).gather(1, b_a) # shape (batch, 1)\n q_next = self.target_net(b_s_).detach() # detach from graph, don't backpropagate\n #taking the most likely action.\n b_a_ = torch.LongTensor(q_next.max(1)[1].view(self.sample_size, 1).long())\n #b_a_ = q_next.max(1)[0].view(self.sample_size, 1).long() # shape (batch, 1)\n q_eval_next = self.eval_net(b_s_).gather(1, b_a_) # shape (batch, 1)\n \n #If eos q_target = reward. \n q_target = b_r + self.gamma * b_is_eos* q_eval_next.view(self.sample_size, 1) # shape (batch, 1)\n #version 0\n #q_target = b_r + self.gamma * q_next.max(1)[0].view(self.sample_size, 1) # shape (batch, 1)\n \n loss = self.loss_func(q_eval, q_target)\n \n self.tb_writer.add_scalar(\"learn/learn_batch_loss\",\n loss.data, self.learn_step_counter)\n\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n #desctivate the eval_net\n freeze_model(self.eval_net)","def __getstate__(self):\n return (self.layers, self.best_loss)","def _get_hop(self):\n return self.__hop","def GetWeight(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def receive_blocks(self, content: Tuple[int, ndarray]) -> Union[Iterable[netEncapsulation], netEncapsulation, None]:\n # get last state of working node\n last_state = self.Bak_Weights_Node.get(content[0], 0)\n # update global current state\n self.Current_Weights = self.Current_Weights + content[1]\n # get difference\n grad_diff = self.Current_Weights - last_state\n # update last state of working node\n self.Bak_Weights_Node[content[0]] = self.Current_Weights\n\n return netEncapsulation(content[0], (-1, grad_diff))","def coefficient(self) -> float:\n ...","def predict(self, model_input):\n # Should return a dictionary of move-prior pairs and the value from\n # the network's value head\n pass","def neural_result(self, input):\n n_output = self.network.activate(input)\n if n_output >= 0.5:\n return 2\n else:\n return 1","def analyze_belief_strength_without_bias(self, G):\r\n n = []\r\n nbs_list = []\r\n for node in G.nodes: #cycles through the nodes of the graph to mine the attributes\r\n n.append(node) #appends each node to a list that will be put into a dictionary\r\n pbs_list = []\r\n og_bs = G.nodes[node]['belief_strength'] #mines the numerical value for a nodes belief strength, from a pre-set node attribute\r\n unc = G.nodes[node]['uncertainty'] #mines the numerical value for a nodes belief uncertainty, from a pre-set node attribute\r\n prob = G.nodes[node]['probability']\r\n for pre in G.predecessors(node):\r\n ew = G.edges[pre, node]['weight'] #mines the numerical value of an edge's weight, from a pre-set edge attribute\r\n pre_bs = G.nodes[pre]['belief_strength'] #mines the numerical value for a predecessors belief strength, from a pre-set node attribute\r\n x = ew * pre_bs #determines how much a node values its neighbor's opinion.\r\n pbs_list.append(x) #puts all values for predecessor belief strangths in a list\r\n if len(pbs_list) == 0:\r\n nbs = og_bs\r\n nbs = int(nbs)\r\n else:\r\n apbs = sum(pbs_list)/len(pbs_list) #calculates the average predecessor belief strength value for a node\r\n nbs = min(og_bs + (0.1*prob*unc*apbs), 100) # average predecessor's belief strength is added to the original belief strength.\r\n nbs = max(nbs, -100)\r\n nbs = int(nbs)\r\n nbs_list.append(nbs) #the new belief strengths are appended to a list that will be put into adictionary\r\n change = dict(zip(n, nbs_list)) #creates a dictionary from two lists which stores the nodes as keys and their new belief strengths as values\r\n print(change)\r\n return change #this will be used to update the list in a different function\r","def invalid_values(net):\n\n check_results = {}\n\n # Contains all element attributes that are necessary to initiate a power flow calculation.\n # There's a tuple with the structure (attribute_name, input type restriction)\n # for each attribute according to pandapower data structure documantation\n # (see also type_checks function)\n\n important_values = {'bus': [('vn_kv', '>0'), ('in_service', 'boolean')],\n 'line': [('from_bus', 'positive_integer'),\n ('to_bus', 'positive_integer'),\n ('length_km', '>0'), ('r_ohm_per_km', '>=0'),\n ('x_ohm_per_km', '>=0'), ('c_nf_per_km', '>=0'),\n ('max_i_ka', '>0'), ('df', '0<x<=1'), ('in_service', 'boolean')],\n 'trafo': [('hv_bus', 'positive_integer'), ('lv_bus', 'positive_integer'),\n ('sn_mva', '>0'), ('vn_hv_kv', '>0'), ('vn_lv_kv', '>0'),\n ('vkr_percent', '>=0'),\n ('vk_percent', '>0'), ('pfe_kw', '>=0'), ('i0_percent', '>=0'),\n ('in_service', 'boolean')],\n 'trafo3w': [('hv_bus', 'positive_integer'), ('mv_bus', 'positive_integer'),\n ('lv_bus', 'positive_integer'),\n ('sn_hv_mva', '>0'), ('sn_mv_mva', '>0'), ('sn_lv_mva', '>0'),\n ('vn_hv_kv', '>0'), ('vn_mv_kv', '>0'), ('vn_lv_kv', '>0'),\n ('vkr_hv_percent', '>=0'), ('vkr_mv_percent', '>=0'),\n ('vkr_lv_percent', '>=0'), ('vk_hv_percent', '>0'),\n ('vk_mv_percent', '>0'), ('vk_lv_percent', '>0'),\n ('pfe_kw', '>=0'), ('i0_percent', '>=0'),\n ('in_service', 'boolean')],\n 'load': [('bus', 'positive_integer'), ('p_mw', 'number'),\n ('q_mvar', 'number'),\n ('scaling', '>=0'), ('in_service', 'boolean')],\n 'sgen': [('bus', 'positive_integer'), ('p_mw', 'number'),\n ('q_mvar', 'number'),\n ('scaling', '>=0'), ('in_service', 'boolean')],\n 'gen': [('bus', 'positive_integer'), ('p_mw', 'number'),\n ('scaling', '>=0'), ('in_service', 'boolean')],\n 'ext_grid': [('bus', 'positive_integer'), ('vm_pu', '>0'),\n ('va_degree', 'number')],\n 'switch': [('bus', 'positive_integer'), ('element', 'positive_integer'),\n ('et', 'switch_type'), ('closed', 'boolean')]}\n\n # matches a check function to each single input type restriction\n type_checks = {'>0': check_greater_zero,\n '>=0': check_greater_equal_zero,\n '<0': check_less_zero,\n '<=0': check_less_equal_zero,\n 'boolean': check_boolean,\n 'positive_integer': check_pos_int,\n 'number': check_number,\n '0<x<=1': check_greater_zero_less_equal_one,\n 'switch_type': check_switch_type\n }\n\n for key in important_values:\n if len(net[key]) > 0:\n for value in important_values[key]:\n for i, element in net[key].iterrows():\n check_result = type_checks[value[1]](element, i, value[0])\n if check_result is not None:\n if key not in check_results:\n check_results[key] = []\n # converts np.nan to str for easier usage of assert in pytest\n nan_check = pd.isnull(net[key][value[0]].at[i])\n if nan_check:\n check_results[key].append((i, value[0],\n str(net[key][value[0]].at[i]), value[1]))\n else:\n check_results[key].append((i, value[0],\n net[key][value[0]].at[i], value[1]))\n if check_results:\n return check_results","def estimate_advantage(self, obs, q_values):\n\n # TODO: Estimate the advantage when nn_baseline is True\n # HINT1: pass obs into the neural network that you're using to learn the baseline\n # extra hint if you're stuck: see your actor's run_baseline_prediction\n # HINT2: advantage should be [Q-b]\n if self.nn_baseline:\n b_n_unnormalized = self.baseline_model(obs)\n b_n = b_n_unnormalized * np.std(q_values) + np.mean(q_values)\n adv_n = (q_values - tf.squeeze(b_n)).numpy()\n # Else, just set the advantage to [Q]\n else:\n adv_n = q_values.copy()\n\n # Normalize the resulting advantages\n if self.standardize_advantages:\n adv_n = (adv_n - np.mean(adv_n)) / (np.std(adv_n) + 1e-8)\n\n return adv_n.astype(np.float32)","def cost_b_v(self):\n return self._cost_b_v"],"string":"[\n \"def get_bias(self):\",\n \"def __get_net_probs(self):\\n return np.array([node.value for node in self.net]).reshape(5,5)\",\n \"def net_output(self):\\n result = self.gives()\\n for k, v in self.needs().items():\\n result[k] = result.get(k, 0) - v\\n\\n return result\",\n \"def forward(self, obs):\\n res = self.hidden_layers(obs)\\n logits = self.logits(res)\\n value = self.value_branch(res)\\n return logits, value\",\n \"def get_value(self):\\n if not self.visited:\\n # first visit at node\\n self.visited = True\\n\\n # value calculation\\n for node, weight in self.predecessors:\\n self.value += (node.get_value() * weight)\\n\\n # applying activation function\\n if self.activation is not None:\\n self.activation()\\n\\n self.calculated = True\\n\\n return self.value\\n else:\\n # visited node\\n if self.calculated:\\n # calculated in this computation\\n return self.value\\n else:\\n # recurrent connection\\n return self.past_value\",\n \"def test_find_highest_value_node_first(self):\\n nn = NeuralNet(0, 0, '', '', blank=True)\\n nn.create_net(2, 2, 2, 2)\\n nn.eta = 0.1\\n\\n # Override weights to static value for reproducibility\\n for node in nn.layers[2].nodes:\\n node.weights = [0.6, 0.6]\\n\\n nn.layers[3].nodes[0].weights = [1.0, 1.0]\\n nn.layers[3].nodes[1].weights = [0.0, 0.0]\\n\\n val = nn.assign_output([2, 3], test=True)\\n self.assertEqual(val, '10')\",\n \"def forward(self, input):\\n mean, std = self.mean_net(input), self.std_net(input)\\n return mean, std\",\n \"def adv_val(self, input_x):\\n float_x = input_x.float()\\n base_out = self.conv(input_x).view(float_x.size()[0], -1)\\n return self.head_adv(base_out), self.head_val(base_out)\",\n \"def test_forward_values():\\n rnn = GeneratorRNN(1)\\n inputs = Variable(torch.zeros(1,1,3))\\n hidden = rnn.init_hidden()\\n e,pi,mu,sigma,rho,_ = rnn(inputs, hidden)\\n\\n assert (e >= 0).all()\\n assert (e <= 1).all()\\n\\n diff = torch.abs(1-torch.sum(pi))\\n assert (diff < 0.00001).all()\\n\\n assert (sigma > 0).all()\\n\\n assert (rho > -1).all()\\n assert (rho < 1).all()\\n\\n rnn = GeneratorRNN(3)\\n inputs = Variable(torch.zeros(10,1,3))\\n hidden = rnn.init_hidden()\\n e,pi,mu,sigma,rho,_ = rnn(inputs, hidden)\\n\\n pi_sum = torch.sum(pi,dim=2)\\n diff = torch.abs(1-pi_sum)\\n assert (diff < 0.00001).all()\",\n \"def get_weights(self):\",\n \"def getWeight(self) -> float:\\n ...\",\n \"def bias_prior(self):\",\n \"def get_hidden_values(self, data):\\n return T.nnet.sigmoid(T.dot(data, self.w1) + self.b1)\",\n \"def weight(self):\",\n \"def get_q_values(self, state, network):\\n out = None\\n state = state.permute(0, 3, 1, 2)\\n #pdb.set_trace()\\n ##############################################################\\n ################ YOUR CODE HERE - 4-5 lines lines ################\\n if network == 'q_network':\\n out = self.q_network(state)\\n else:\\n out = self.target_network(state)\\n ##############################################################\\n ######################## END YOUR CODE #######################\\n return out\",\n \"def analyze_belief_strength_with_bias(self, G):\\r\\n n = []\\r\\n nbs_list = []\\r\\n for node in G.nodes: #cycles through the nodes of the graph to mine the attributes\\r\\n n.append(node) #appends each node to a list that will be put into a dictionary\\r\\n pbs_list = []\\r\\n og_bs = G.nodes[node]['belief_strength'] #mines the numerical value for a nodes belief strength, from a pre-set node attribute\\r\\n unc = G.nodes[node]['uncertainty'] #mines the numerical value for a nodes belief uncertainty, from a pre-set node attribute\\r\\n prob = G.nodes[node]['probability']\\r\\n for pre in G.predecessors(node):\\r\\n ew = G.edges[pre, node]['weight'] #mines the numerical value of an edge's weight, from a pre-set edge attribute\\r\\n pre_bs = G.nodes[pre]['belief_strength'] #mines the numerical value for a predecessors belief strength, from a pre-set node attribute\\r\\n x = ew * pre_bs #determines how much a node values its neighbor's opinion.\\r\\n pbs_list.append(x) #puts all values for predecessor belief strangths in a list\\r\\n if len(pbs_list) == 0:\\r\\n nbs = og_bs\\r\\n nbs = int(nbs)\\r\\n else:\\r\\n apbs = sum(pbs_list)/len(pbs_list) #calculates the average predecessor belief strength value for a node\\r\\n if apbs*og_bs > 0:\\r\\n if apbs > 0:\\r\\n nbs = min(og_bs + (0.1*prob*unc*apbs), 100)\\r\\n else:\\r\\n nbs = max(og_bs + (0.1*prob*unc*apbs), -100)\\r\\n nbs = int(nbs)\\r\\n else:\\r\\n nbs = og_bs\\r\\n nbs = int(nbs)\\r\\n nbs_list.append(nbs) #the new belief strengths are appended to a list that will be put into adictionary\\r\\n change = dict(zip(n, nbs_list)) #creates a dictionary from two lists which stores the nodes as keys and their new belief strengths as values\\r\\n print(change)\\r\\n return change #this will be used to update the list in a different function\\r\",\n \"def value(self, observation, prev_action, prev_reward):\\n agent_inputs = buffer_to((observation, prev_action, prev_reward),\\n device=self.device)\\n _mu, _log_std, value, _rnn_state = self.model(*agent_inputs, self.prev_rnn_state)\\n return value.to(\\\"cpu\\\")\",\n \"def forward(self, value, query, lens):\\n relevant_scores = self.relevant_score(value, query, lens)\\n e_relevant_scores = torch.exp(relevant_scores)\\n weights = e_relevant_scores / e_relevant_scores.sum(-1, keepdim=True)\\n attention = (weights.unsqueeze(-1) * value).sum(1)\\n return attention\",\n \"def res_get(hp2res, hp_dict, hp_labels):\\n logg = logging.getLogger(f\\\"c.{__name__}.res_get\\\")\\n logg.setLevel(\\\"INFO\\\")\\n logg.debug(f\\\"Start res_get\\\")\\n\\n # build the hp_set for the corresponding bar\\n hp_set = []\\n for label in hp_labels:\\n hp_set.append(hp_dict[label])\\n hp_set = tuple(hp_set)\\n # get the corresponding loss value\\n hp_val = hp2res[hp_set]\\n\\n logg.debug(f\\\"hp_set {hp_set} hp_val {hp_val}\\\")\\n return hp_val\",\n \"def _learn_node_parameter_var(outputs, weights, inputs):\\n var = 0.\\n\\n \\\"\\\"\\\" YOUR CODE HERE \\\"\\\"\\\"\\n temp = 0\\n N_observe = outputs.shape[0]\\n if inputs is None:\\n temp = np.sum((outputs-weights[0])**2)\\n else:\\n for i in range(N_observe):\\n temp += (outputs[i] - (np.sum(weights[1:] * inputs[i]) +weights[0]))**2\\n var = temp/N_observe\\n\\n\\n\\n \\\"\\\"\\\" END YOUR CODE HERE \\\"\\\"\\\"\\n\\n return var\",\n \"def getQValue(self, state, action):\\n #print \\\"getQValue in ApproximateQAgent\\\"\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n weights = self.getWeights()\\n features = self.featExtractor.getFeatures(state, action, self)\\n\\n value = 0\\n\\n #print \\\"FEATURES: \\\", features\\n #print \\\"WEIGHTS: \\\", weights\\n\\n for feature in features:\\n value += features[feature]*weights[feature]\\n return value\\n #util.raiseNotDefined()\",\n \"def get_reward(self):\\n # Ver list\\n self.Verlist = {\\n '1': False,\\n '2': False,\\n '3': False,\\n '4': False,\\n '5': True,\\n }\\n # --------------------------------- NEW ----\\n r = 0\\n if self.ENVGetSIReset:\\n V = {\\n 'CoolRateTemp': self.DRateFun(self.mem['KCNTOMS']['Val']),\\n 'CurrentTemp': self.mem['UAVLEG2']['Val'],\\n 'CurrentPres': self.mem['ZINST65']['Val'],\\n 'Dis': abs(self.DRateFun(self.mem['KCNTOMS']['Val']) - self.mem['UAVLEG2']['Val']),\\n 'PZRLevel': self.mem['ZINST63']['Val'],\\n 'SG1Nar': self.mem['ZINST78']['Val'], 'SG2Nar': self.mem['ZINST77']['Val'],\\n 'SG3Nar': self.mem['ZINST76']['Val'],\\n 'SG1Wid': self.mem['ZINST72']['Val'], 'SG2Wid': self.mem['ZINST71']['Val'],\\n 'SG3Wid': self.mem['ZINST70']['Val'],\\n 'SG1Pres': self.mem['ZINST75']['Val'], 'SG2Pres': self.mem['ZINST74']['Val'],\\n 'SG3Pres': self.mem['ZINST73']['Val'],\\n }\\n if self.Verlist['1']:\\n # Cooling rate에 따라서 온도 감소\\n r -= V['Dis'] / 100\\n # 가압기 수위 10 아래 종료\\n # if V['PZRLevel'] <= 10: r -= 100\\n if self.Verlist['2']:\\n # 목표치까지 도달\\n r += (29.5 - V['CurrentPres']) / 100\\n r += (170 - V['CurrentTemp']) / 100\\n if self.Verlist['3']:\\n # Cooling rate에 따라서 온도 감소\\n dis_reward = - V['Dis'] / 100 # [0.0 ~ -0.2] 동향을 보임\\n # Pressure and Temp Dis\\n curp = 29.5 if V['CurrentPres'] <= 29.5 else V['CurrentPres']\\n curt = 170 if V['CurrentTemp'] <= 170 else V['CurrentTemp']\\n dis_pres = (29.5 - V['CurrentPres']) / 100\\n dis_temp = (170 - V['CurrentTemp']) / 100\\n\\n # r += (dis_pres * 0.1) + (dis_temp * 0.1) + (dis_reward * 10) # 감압 X\\n r += (dis_pres * 0.1) + (dis_reward * 5)\\n if self.Verlist['4']:\\n # Cooling rate에 따라서 온도 감소\\n dis_reward = - V['Dis'] / 100 # [0.0 ~ -0.2] 동향을 보임\\n # Pressure and Temp Dis\\n curp = 29.5 if V['CurrentPres'] <= 29.5 else V['CurrentPres']\\n dis_pres = (29.5 - V['CurrentPres']) / 100\\n PT_reward = - PTCureve().Check(Temp=V['CurrentTemp'], Pres=V['CurrentPres'])\\n r += (dis_pres * 0.1) + (dis_reward * 5) + (PT_reward * 0.1)\\n if self.Verlist['5']:\\n r = 0\\n # 1] Cooling rate에 따라서 온도 감소\\n coolrate_r = - V['Dis']\\n # 2] 가압기 수위 20~76% 구간 초과시 패널티\\n pzrlevel_r = 0\\n if 20 <= V['PZRLevel'] <= 76:\\n pass\\n else:\\n if 20 > V['PZRLevel']:\\n pzrlevel_r -= (20 - V['PZRLevel'])\\n else:\\n pzrlevel_r -= (V['PZRLevel'] - 76)\\n # 3] 증기 발생기 6% ~ 50% 이상 초과 시 패널티\\n sg_r = 0\\n for _ in range(1, 4):\\n if 6 <= V[f'SG{_}Nar'] <= 50:\\n pass\\n else:\\n if 6 > V[f'SG{_}Nar']:\\n sg_r -= (6 - V[f'SG{_}Nar'])\\n else:\\n sg_r -= (V[f'SG{_}Nar'] - 50)\\n # 4] PT 커브에서 벗어나면 거리만큼 패널티\\n PT_reward = - PTCureve().Check_Dis(Temp=V['CurrentTemp'], Pres=V['CurrentPres'])\\n # 5] 목표치와 가까워 질 수록 +\\n pres_r, temp_r = 0, 0\\n pres_r = (29.5 - V['CurrentPres'])\\n temp_r = (170 - V['CurrentTemp'])\\n # 6] S/G 압력\\n Avg_pres = (V['SG1Pres'] + V['SG2Pres'] + V['SG3Pres'])/3\\n SGpres_r = 9 - Avg_pres if Avg_pres > 9 else 0\\n # --------------------------------------------------------------\\n w = {\\n 'coolrate_r': [coolrate_r, 2],\\n 'pzrlevel_r': [pzrlevel_r, 1],\\n 'sg_r': [sg_r, 1.5],\\n 'PT_reward': [PT_reward, 3],\\n 'pres_r': [pres_r, 1],\\n 'temp_r': [temp_r, 0.5],\\n 'SGpres_r': [SGpres_r, 0.5]\\n }\\n\\n log_txt_temp = ''\\n for key in w.keys():\\n r += w[key][0] * w[key][1]\\n log_txt_temp += f'[{round(w[key][0]*w[key][1], 1)}:{w[key][0]}*{w[key][1]}]_'\\n log_txt_temp = f'R:{r} = ' + log_txt_temp\\n\\n self.Loger_txt += log_txt_temp\\n\\n # self.Loger_txt += f\\\"R:{r} = {dis_pres * 0.1}+{dis_temp * 0.1}+({dis_reward * 10})\\\\t\\\"\\n # self.Loger_txt += f\\\"R:{r} = {dis_pres * 0.1}+({dis_reward * 5})\\\\t\\\" #Verlist['3']\\n # self.Loger_txt += f\\\"R:{r} = {dis_pres * 0.1}+({dis_reward * 5})+({PT_reward * 0.1})\\\\t\\\"\\n\\n # --------------------------------- Send R ----\\n self.AcumulatedReward += r\\n # self.Loger_txt += f'{r}\\\\t'\\n self.DIS_CSF_Info += f'[R: {r}]\\\\t'\\n return r\",\n \"def forward(self, state):\\n x = state\\n feature = self.feature_layer(x)\\n action_value = self.value_layer(feature)\\n advantage = self.advantage_layer(feature)\\n \\n q_value = action_value + (advantage - advantage.mean(dim=1, keepdim=True))\\n return q_value\",\n \"def forward(self, state):\\n\\n # connect layers to each other and put relu activations between them\\n for layer in self.hidden_layers:\\n state = layer(state)\\n state = F.relu(state)\\n value = self.value_layer(state)\\n return value\",\n \"def forwardPolicyNet(self, state):\\n with torch.no_grad():\\n q_values = self.policy_net(state)\\n return q_values\",\n \"def _get_weight(self):\\n return self.__weight\",\n \"def _get_weight(self):\\n return self.__weight\",\n \"def _get_weight(self):\\n return self.__weight\",\n \"def _get_weight(self):\\n return self.__weight\",\n \"def _get_weight(self):\\n return self.__weight\",\n \"def _get_weight(self):\\n return self.__weight\",\n \"def _get_weight(self):\\n return self.__weight\",\n \"def _get_weight(self):\\n return self.__weight\",\n \"def value(self):\\n #import pdb; pdb.set_trace()\\n return ((self.team1.get_cur_hp() / self.team1.get_total_hp()) - \\n (self.team2.get_cur_hp() / self.team2.get_total_hp()))\",\n \"def _policy_nn(self):\\n with tf.variable_scope(\\\"reward_params\\\") as scope:\\n \\n self.h1 = tf.layers.dense(self.input_ph, self.hidden_dim, tf.nn.tanh,\\n kernel_initializer=tf.random_normal_initializer(\\n stddev=np.sqrt(1 / self.params_dim)), name=\\\"h1\\\")\\n self.h2 = tf.layers.dense(self.h1, self.hidden_dim, tf.nn.tanh,\\n kernel_initializer=tf.random_normal_initializer(\\n stddev=np.sqrt(1 / self.params_dim)), name=\\\"h2\\\")\\n self.rewards = tf.layers.dense(self.h2, 1,\\n kernel_initializer=tf.random_normal_initializer(\\n stddev=np.sqrt(1 / self.hidden_dim)), name=\\\"rewards\\\")\\n self.rewards_sum = tf.reduce_sum(self.rewards)\",\n \"def get_hidden_values(self, input):\\n return T.nnet.sigmoid(T.dot(input, self.W) + self.bh)\",\n \"def get_thrust_value(self, command):\\n return self._gain * numpy.abs(command) * command\",\n \"def get(self) -> float:\\n ...\",\n \"def get_weight(self, val1, val2):\\n\\n\\t\\tnode1 = self.get_node(val1)\\n\\t\\tnode2 = self.get_node(val2)\\n\\n\\t\\treturn node1.get_weight(node2)\",\n \"def learn(self):\\n # Calculate prior probabilities.\\n self.priorpos = len(self.posdata) / (len(self.posdata) + len(self.negdata))\\n self.priorneg = len(self.negdata) / (len(self.posdata) + len(self.negdata))\\n print(\\\"Prior probability positive: \\\")\\n print(self.priorpos)\\n print(\\\"Prior probability negative: \\\")\\n print(self.priorneg)\\n\\n # Calculate negative likelihood/conditional probability.\\n occurpos = self.occurence(self.posvec)\\n self.condpos = self.condprob(occurpos)\\n occurneg = self.occurence(self.negvec)\\n self.condneg = self.condprob(occurneg)\",\n \"async def get_change(sochain_url, value_out, network, address):\\n try:\\n balance = await sochain_api.get_balance(sochain_url, network, address)\\n balance = round(balance[0].amount * 10 ** 8)\\n change = 0\\n if balance - value_out > DUST_THRESHOLD:\\n change = balance - value_out\\n return change\\n except Exception as err:\\n raise Exception(str(err))\",\n \"def net(input_lst, weight_lst, bias):\\r\\n net_total = bias\\r\\n\\r\\n for node in range(len(input_lst)):\\r\\n net_total += input_lst[node] * weight_lst[node]\\r\\n\\r\\n return net_total\",\n \"def getWeights(self, gameState, action):\\n return {'successorScore': 1.0}\",\n \"def getWeights(self, gameState, action):\\n return {'successorScore': 1.0}\",\n \"def getWeights(self, gameState, action):\\n return {'successorScore': 1.0}\",\n \"def getWeights(self, gameState, action):\\n return {'successorScore': 1.0}\",\n \"def getWeights(self, gameState, action):\\n return {'successorScore': 1.0}\",\n \"def getWeights(self, gameState, action):\\n return {'successorScore': 1.0}\",\n \"def getWeights(self, gameState, action):\\n return {'successorScore': 1.0}\",\n \"def brain_weight_oz(self):\\r\\n return Heart.heart_weight_oz(self) # Used method from Heart Class\\r\",\n \"def forward(self, prev_state, obs_t):\\r\\n # Use your network to compute qvalues for given state\\r\\n #print(state_t.shape)\\r\\n h = self.conv(obs_t)\\r\\n\\r\\n h = h.view(h.size(0), -1)\\r\\n\\r\\n new_state = h_new, c_new = self.lstm(h, prev_state)\\r\\n advantage = self.adv(h_new)\\r\\n value = self.val(h_new)\\r\\n\\r\\n\\r\\n adv_mean = torch.mean(advantage, dim=1, keepdim=True)\\r\\n qvalues = value + advantage - adv_mean\\r\\n\\r\\n return new_state, qvalues\",\n \"def LHopital(n, top, bot, accuracy=0.0001, scaledown=1.25):\\n vtop = top(n)\\n vbot = bot(n)\\n i = 1\\n while vtop == 0 and vbot == 0:\\n vtop = deriv(top, n, i, accuracy, scaledown)\\n vbot = deriv(bot, n, i, accuracy, scaledown)\\n i += 1\\n return vtop/vbot\",\n \"def get_hidden_values(self, input):\\r\\n return T.nnet.sigmoid(T.dot(input, self.W) + self.b)\",\n \"def get_hidden_values(self, input):\\r\\n return T.nnet.sigmoid(T.dot(input, self.W) + self.b)\",\n \"def compute_loss(\\n action_probs: tf.Tensor, values: tf.Tensor, returns: tf.Tensor\\n) -> tf.Tensor:\\n\\n advantage = returns - values\\n td = tf.subtract(returns, values)\\n\\n # actor\\n # action_log_probs = tf.math.log(action_probs)\\n # actor_loss = -tf.math.reduce_sum(action_log_probs * advantage)\\n action_log_probs = tf.math.log(action_probs)\\n actor_loss = -tf.math.reduce_mean(action_log_probs * td)\\n\\n # critic\\n # td = tf.subtract(returns, values)\\n # critic_loss = tf.reduce_mean(tf.square(td))\\n critic_loss = huber_loss(values, returns)\\n\\n tf.print(\\\"a_loss:\\\", actor_loss, \\\"c_loss:\\\", critic_loss)\\n\\n return actor_loss + critic_loss\",\n \"def gain(self):\\n return self[1]\",\n \"def get_expected_cost(self):\",\n \"def value(self, observation, prev_action, prev_reward):\\n model_inputs = buffer_to((observation, prev_action, prev_reward),\\n device=self.device)\\n _mu, _log_std, value = self.model(*model_inputs)\\n return value.to(\\\"cpu\\\")\",\n \"def baseEvaluate(self, gameState, action):\\n features = self.getFeatures(gameState, action)\\n weights = self.getWeights(gameState, action)\\n return features * weights\",\n \"def get_hyperparams(self):\",\n \"def forward(self, pred, gt, weight=None):\\n num_pos = torch.relu(torch.sum(gt) - 1) + 1\\n num_neg = torch.relu(torch.sum(1 - gt) - 1) + 1\\n if weight is not None:\\n loss = nn.BCEWithLogitsLoss(reduction='none')(pred, gt.float())\\n loss = torch.mean(loss * weight)\\n elif self.balanced is False:\\n loss = nn.BCEWithLogitsLoss(reduction='mean')(pred, gt.float())\\n else:\\n loss = nn.BCEWithLogitsLoss(pos_weight=num_neg * 1.0 / num_pos, reduction='mean')(pred, gt.float())\\n\\n # compute precision, recall, f1\\n pred_labels = pred > 0\\n gt, pred_labels, pred = gt.detach().cpu().numpy(), pred_labels.detach().cpu().numpy(), pred.detach().cpu().numpy()\\n precision = precision_score(gt[0], pred_labels[0])\\n recall = recall_score(gt[0], pred_labels[0])\\n f1 = f1_score(gt[0], pred_labels[0])\\n mean_logit_true = np.sum(pred * gt) / max(1, np.sum(gt))\\n mean_logit_false = np.sum(pred * (1 - gt)) / max(1, np.sum(1 - gt))\\n\\n eval_stats = {\\n \\\"loss\\\": loss,\\n \\\"precision\\\": float(precision),\\n \\\"recall\\\": float(recall),\\n \\\"f1\\\": float(f1),\\n \\\"logit_true\\\": float(mean_logit_true),\\n \\\"logit_false\\\": float(mean_logit_false)\\n }\\n return eval_stats\",\n \"def getWeights(self, gameState, actton):\\n\\t\\treturn {'successorScore': 1.0}\",\n \"def value(self) -> float:\",\n \"def prediction_b(self):\\r\\n return self._prediction_b\",\n \"def test_get_hyperflex_node_profile_by_moid(self):\\n pass\",\n \"def get_value_loss(flat_params):\\n set_flat_params_to(value_net, tensor(flat_params))\\n for param in value_net.parameters():\\n if param.grad is not None:\\n param.grad.data.fill_(0)\\n values_pred = value_net(states)\\n value_loss = (values_pred - returns).pow(2).mean() # MeanSquaredError\\n\\n # weight decay\\n for param in value_net.parameters():\\n value_loss += param.pow(2).sum() * l2_reg\\n value_loss.backward()\\n return value_loss.item(), get_flat_grad_from(value_net.parameters()).cpu().numpy()\",\n \"def getWeight(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def _val_step(self, inputs, targets, extra_params):\\n\\n inputs = inputs.to(self.device)\\n targets = targets.to(self.device, non_blocking=True)\\n\\n recons = self.generator(inputs)\\n\\n # Discriminator part.\\n # pred_fake = self.discriminator(recons) # Generated fake image going through discriminator.\\n # pred_real = self.discriminator(targets) # Real image going through discriminator.\\n # gradient_penalty = compute_gradient_penalty(self.discriminator, targets, recons)\\n # disc_loss = pred_fake.mean() - pred_real.mean() + self.lambda_gp * gradient_penalty\\n\\n # Generator part.\\n # gen_loss = -pred_fake.mean()\\n recon_loss = self.loss_funcs['recon_loss_func'](recons, targets)\\n # total_gen_loss = gen_loss + self.recon_lambda * recon_loss\\n\\n step_loss = recon_loss\\n step_loss_components = {'recon_loss': recon_loss}\\n\\n return recons, step_loss, step_loss_components\",\n \"def value(self):\\n return self.head\",\n \"def evaluate(self, gameState, action):\\n features = self.getFeatures(gameState, action)\\n ####print \\\"features \\\", features\\n weights = self.getWeights(gameState, action)\\n ####print \\\"weights \\\", weights\\n return features * weights\",\n \"def get_net(netsnt, netrcv, tempsnt, temprcv):\\n return {\\n 'NET-PKT-SNT': (netsnt - tempsnt),\\n 'NET-PKT-RCV': (netrcv - temprcv),\\n }\",\n \"def get_hidden_values(self, input):\\n return T.nnet.sigmoid(T.dot(input, self.W) + self.b)\",\n \"def get_hidden_values(self, input):\\n return T.nnet.sigmoid(T.dot(input, self.W) + self.b)\",\n \"def forward(self, input):\\n\\n common = self.common_tower(input)\\n wdl = self.wdl_head(common)\\n policy = self.policy_head(common)\\n\\n return wdl, policy\",\n \"def call(self, obs):\\n\\t\\tx = tf.convert_to_tensor(obs)\\n\\t\\thidden_logs = self.hidden1(x)\\n\\t\\thidden_vals = self.hidden2(x)\\n\\t\\treturn self.logits(hidden_logs), self.value(hidden_vals)\",\n \"def dealer_probs():\\n # Pdf of any current hand (value, hard) and final value; p(v_f | v_c) where v_f = final value, v_c = current value\\n probabilities = {}\\n\\n # End nodes: (value, True) for value >= 17 and (value, False) for value > 17\\n # Dependencies (in order of increasing requirements):\\n # Hard values, value >= 11, possiblity of bust, no possibility of going soft with an ace (value, True) depends on (value', True) for 17 > value' > value\\n # Soft values, 17 >= value >= 11 (value, False) depends on (value', False) for 17 >= value' > value, (value', True) for 17 > value' > 11\\n # Hard values, 11 > value >= 2 , no possibility of bust, possibility of going soft with an ace (value, True) depends on (value', True) for 17 > value' > value and (value', False) for 17 >= value' > 13\\n\\n\\n # End nodes\\n for value in xrange(17, 22):\\n probabilities[(value, True)] = {value: 1.0}\\n if value == 17: continue # on soft 17, dealer will still hit\\n probabilities[(value, False)] = {value: 1.0}\\n\\n # Hard values, 17 > value >= 11, possibility of bust, no possibility of going soft with an ace\\n for value in xrange(16, 10, -1):\\n probabilities[(value, True)] = {}\\n current_prob = probabilities[(value, True)]\\n for next_card in xrange(1, min(10, 21-value)+1):\\n next_prob = probabilities[(value + next_card, True)]\\n for end_val in next_prob:\\n current_prob[end_val] = current_prob.get(end_val, 0) + next_prob[end_val] * PROBABILITIES[next_card]\\n\\n # Soft values, 17 >= value >= 11\\n for value in xrange(17, 10, -1):\\n probabilities[(value, False)] = {}\\n current_prob = probabilities[(value, False)]\\n for next_card in xrange(1, 11):\\n next_value = value + next_card\\n hard = False\\n if next_value > 21:\\n next_value -= 10\\n hard = True\\n next_prob = probabilities[(next_value, hard)]\\n for end_val in next_prob:\\n current_prob[end_val] = current_prob.get(end_val, 0) + next_prob[end_val] * PROBABILITIES[next_card]\\n\\n # Hard values, 11 > value >= 2, no possibility of bust, possibility of going soft with an ace\\n for value in xrange(10, 1, -1):\\n probabilities[(value, True)] = {}\\n current_prob = probabilities[(value, True)]\\n for next_card in xrange(2, 12):\\n next_value = value + next_card\\n hard = (next_card != 11)\\n next_prob = probabilities[(next_value, hard)]\\n for end_val in next_prob:\\n current_prob[end_val] = current_prob.get(end_val, 0) + next_prob[end_val] * PROBABILITIES[next_card]\\n\\n return probabilities\",\n \"def test_find_highest_value_node_last(self):\\n nn = NeuralNet(0, 0, '', '', blank=True)\\n nn.create_net(2, 2, 2, 2)\\n nn.eta = 0.1\\n\\n # Override weights to static value for reproducibility\\n for node in nn.layers[2].nodes:\\n node.weights = [0.6, 0.6]\\n\\n nn.layers[3].nodes[0].weights = [0.0, 0.0]\\n nn.layers[3].nodes[1].weights = [1.0, 1.0]\\n\\n val = nn.assign_output([2, 3], test=True)\\n self.assertEqual(val, '01')\",\n \"def gibbs_ask_traffic(self, X, e, Z, bn, N):\\n\\n #makes copies\\n X = e\\n e = e\\n\\n #probability\\n probability = [0,0]\\n numerator = 0\\n\\n\\n #True, False\\n\\n for x in range(N):\\n # second joint\\n if Z == True: # if non evidence variable\\n random_choice = np.random.choice([0,1], 1, True, [0.5, 0.5])[0] #Rain or No Rain\\n X[1] = bn[1][random_choice][0]\\n else:\\n random_choice = np.random.choice([0, 1], 1, True, [0.5, 0.5])[0] #Rain or No Rain\\n X[1] = bn[1][random_choice][1]\\n\\n # first joint\\n if X[1] == 0.8 or X[1] == 0.2: # Rain is true\\n X[0] = bn[0][0]\\n else: # Rain is False\\n X[0] = bn[0][1]\\n\\n # third joint\\n if X[1] == 0.8 or X[1] == 0.1: # traffic\\n random_late = np.random.choice([0,1], 1, True, [0.5,0.5])[0]\\n X[2] = bn[2][0][random_late]\\n else: # no traffic\\n random_late = np.random.choice([0, 1], 1, True, [0.5, 0.5])[0]\\n X[2] = bn[2][1][random_late]\\n\\n # print(X)\\n if X[0] == 0.1:\\n probability[0] += 1\\n else:\\n probability[1] += 1\\n\\n\\n probability[0] = probability[0] / N\\n probability[1] = probability[1] / N\\n # print(probability)\\n return probability\",\n \"def forward(self, x):\\n dims = list(range(1, len(x.shape)))\\n mean = x.mean(dim=dims, keepdim=True)\\n var = torch.pow(x - mean, 2).mean(dim=dims, keepdim=True)\\n return self.apply_gain_and_bias((x - mean) / (var + EPS).sqrt())\",\n \"def getWeights(self, gameState, action):\\n # return {'successorScore': 1.0}\\n if self.isOffensive:\\n return self.getOffensiveWeights(gameState, action)\\n else:\\n return self.getDefensiveWeights(gameState, action)\",\n \"def test_get_damage(self):\\n self.veh.health = 2.2\\n for op in self.veh.operators:\\n op.health = 0.5\\n self.veh.get_damage(0.5)\\n self.assertEqual(self.veh.health, 1.9)\\n self.assertEqual(self.veh.operators[0].health, 0.4)\\n self.assertEqual(self.veh.operators[1].health, 0.45)\\n self.assertEqual(self.veh.operators[2].health, 0.45)\",\n \"def getMyValue(self):\\n valueBV = 0.0\\n valueCR = 0.0\\n valueAL = 0.0\\n valueEC = 0.0\\n valueIA = 0.0\\n factorAL = globals.cityCRGen/globals.cityALGen\\n factorEC = globals.cityCRGen/globals.cityECGen\\n factorIA = globals.cityCRGen/globals.cityIAGen\\n ratio = self.strength/100.0\\n valueCR += self.myDesign.costCR*ratio\\n valueAL += self.myDesign.costAL*ratio\\n valueEC += self.myDesign.costEC*ratio\\n valueIA += self.myDesign.costIA*ratio\\n valueBV += (valueCR +\\n valueAL*factorAL +\\n valueEC*factorEC +\\n valueIA*factorIA) / 1000.0\\n return (valueBV, valueCR, valueAL, valueEC, valueIA)\",\n \"def get_aff_net(sta):\\n pass\",\n \"def getQValue(self, gameState, action):\\n features = self.getFeatures(gameState, action)\\n return features * self.weights\",\n \"def get_node_value(succs, preds):\\n ret = 1\\n if succs == 0:\\n ret *= NODE_ENTRY\\n\\n if preds == 0:\\n ret *= NODE_EXIT\\n\\n ret *= NODE_NORMAL\\n return ret\",\n \"def forward(self, x):\\n x = F.relu(self.affine1(x))\\n x = F.relu(self.affine2(x))\\n\\n # actor: choses action to take from state s_t\\n # by returning probability of each action\\n action_prob = F.softmax(self.action_head(x), dim=-1)\\n\\n # critic: evaluates being in the state s_t\\n state_values = self.value_head(x)\\n\\n # return values for both actor and critic as a tupel of 2 values:\\n # 1. a list with the probability of each action over the action space\\n # 2. the value from state s_t\\n return action_prob, state_values\",\n \"def value_net(self):\\n return functools.partial(self.value_net_fn, self.value_net_params)\",\n \"def test_regression_relative_attention_bidirectional_values(self):\\n outputs, unused_params = self.relative_attention.init_with_output(\\n random.PRNGKey(0), self.query_len, self.key_len, bidirectional=True)\\n self.assertEqual(outputs.shape,\\n (1, self.num_heads, self.query_len, self.key_len))\\n self.assertAlmostEqual(outputs[0, 0, 0, 0], 0.55764728, places=5)\\n self.assertAlmostEqual(outputs[0, 1, 2, 1], -0.10935841, places=5)\\n self.assertAlmostEqual(outputs[0, 1, 4, 6], 0.14510104, places=5)\\n self.assertAlmostEqual(outputs[0, 2, 4, 6], -0.36783996, places=5)\",\n \"def learn(self):\\n \\n # target parameter update\\n # target parameter update\\n if self.learn_step_counter % self.nu_iter == 0:\\n self.target_net.load_state_dict(self.eval_net.state_dict())\\n #testing the preformace of the network\\n if self.learn_step_counter == 0:\\n print('As referece this first test on dev data. Is maded with the Q networks, initialized randomly : ' )\\n else:\\n print(\\\"\\\\n Lets copy the Q-value Net in to Q-target net!. And test the performace on the dev data: \\\")\\n \\n current_bleu = self.dev_network()\\n print(\\\"Current Bleu score is: \\\", current_bleu)\\n \\n self.learn_step_counter += 1\\n\\n \\n long_Batch = self.sample_size*3\\n # Sampling the higgest rewards values\\n b_memory_big = self.memory[np.argsort(-self.memory[:-self.max_output_length, self.state_size+1])][:long_Batch]\\n \\n sample_index = np.random.choice(long_Batch, self.sample_size)\\n b_memory = b_memory_big[sample_index, :]\\n\\n b_s = torch.FloatTensor(b_memory[:, :self.state_size])\\n b_a = torch.LongTensor(b_memory[:, self.state_size:self.state_size+1].astype(int))\\n b_r = torch.FloatTensor(b_memory[:, self.state_size+1:self.state_size+2])\\n b_s_ = torch.FloatTensor(b_memory[:, self.state_size+2: self.state_size+2 + self.state_size])\\n\\n b_is_eos = torch.FloatTensor(b_memory[:, self.size_memory1-1:]).view(self.sample_size, 1)\\n #print(b_a, b_a.size)\\n #print(b_is_eos)\\n #Activate the eval_net\\n unfreeze_model(self.eval_net)\\n \\n # q_eval w.r.t the action in experience\\n q_eval = self.eval_net(b_s).gather(1, b_a) # shape (batch, 1)\\n q_next = self.target_net(b_s_).detach() # detach from graph, don't backpropagate\\n #taking the most likely action.\\n b_a_ = torch.LongTensor(q_next.max(1)[1].view(self.sample_size, 1).long())\\n #b_a_ = q_next.max(1)[0].view(self.sample_size, 1).long() # shape (batch, 1)\\n q_eval_next = self.eval_net(b_s_).gather(1, b_a_) # shape (batch, 1)\\n \\n #If eos q_target = reward. \\n q_target = b_r + self.gamma * b_is_eos* q_eval_next.view(self.sample_size, 1) # shape (batch, 1)\\n #version 0\\n #q_target = b_r + self.gamma * q_next.max(1)[0].view(self.sample_size, 1) # shape (batch, 1)\\n \\n loss = self.loss_func(q_eval, q_target)\\n \\n self.tb_writer.add_scalar(\\\"learn/learn_batch_loss\\\",\\n loss.data, self.learn_step_counter)\\n\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n #desctivate the eval_net\\n freeze_model(self.eval_net)\",\n \"def __getstate__(self):\\n return (self.layers, self.best_loss)\",\n \"def _get_hop(self):\\n return self.__hop\",\n \"def GetWeight(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def receive_blocks(self, content: Tuple[int, ndarray]) -> Union[Iterable[netEncapsulation], netEncapsulation, None]:\\n # get last state of working node\\n last_state = self.Bak_Weights_Node.get(content[0], 0)\\n # update global current state\\n self.Current_Weights = self.Current_Weights + content[1]\\n # get difference\\n grad_diff = self.Current_Weights - last_state\\n # update last state of working node\\n self.Bak_Weights_Node[content[0]] = self.Current_Weights\\n\\n return netEncapsulation(content[0], (-1, grad_diff))\",\n \"def coefficient(self) -> float:\\n ...\",\n \"def predict(self, model_input):\\n # Should return a dictionary of move-prior pairs and the value from\\n # the network's value head\\n pass\",\n \"def neural_result(self, input):\\n n_output = self.network.activate(input)\\n if n_output >= 0.5:\\n return 2\\n else:\\n return 1\",\n \"def analyze_belief_strength_without_bias(self, G):\\r\\n n = []\\r\\n nbs_list = []\\r\\n for node in G.nodes: #cycles through the nodes of the graph to mine the attributes\\r\\n n.append(node) #appends each node to a list that will be put into a dictionary\\r\\n pbs_list = []\\r\\n og_bs = G.nodes[node]['belief_strength'] #mines the numerical value for a nodes belief strength, from a pre-set node attribute\\r\\n unc = G.nodes[node]['uncertainty'] #mines the numerical value for a nodes belief uncertainty, from a pre-set node attribute\\r\\n prob = G.nodes[node]['probability']\\r\\n for pre in G.predecessors(node):\\r\\n ew = G.edges[pre, node]['weight'] #mines the numerical value of an edge's weight, from a pre-set edge attribute\\r\\n pre_bs = G.nodes[pre]['belief_strength'] #mines the numerical value for a predecessors belief strength, from a pre-set node attribute\\r\\n x = ew * pre_bs #determines how much a node values its neighbor's opinion.\\r\\n pbs_list.append(x) #puts all values for predecessor belief strangths in a list\\r\\n if len(pbs_list) == 0:\\r\\n nbs = og_bs\\r\\n nbs = int(nbs)\\r\\n else:\\r\\n apbs = sum(pbs_list)/len(pbs_list) #calculates the average predecessor belief strength value for a node\\r\\n nbs = min(og_bs + (0.1*prob*unc*apbs), 100) # average predecessor's belief strength is added to the original belief strength.\\r\\n nbs = max(nbs, -100)\\r\\n nbs = int(nbs)\\r\\n nbs_list.append(nbs) #the new belief strengths are appended to a list that will be put into adictionary\\r\\n change = dict(zip(n, nbs_list)) #creates a dictionary from two lists which stores the nodes as keys and their new belief strengths as values\\r\\n print(change)\\r\\n return change #this will be used to update the list in a different function\\r\",\n \"def invalid_values(net):\\n\\n check_results = {}\\n\\n # Contains all element attributes that are necessary to initiate a power flow calculation.\\n # There's a tuple with the structure (attribute_name, input type restriction)\\n # for each attribute according to pandapower data structure documantation\\n # (see also type_checks function)\\n\\n important_values = {'bus': [('vn_kv', '>0'), ('in_service', 'boolean')],\\n 'line': [('from_bus', 'positive_integer'),\\n ('to_bus', 'positive_integer'),\\n ('length_km', '>0'), ('r_ohm_per_km', '>=0'),\\n ('x_ohm_per_km', '>=0'), ('c_nf_per_km', '>=0'),\\n ('max_i_ka', '>0'), ('df', '0<x<=1'), ('in_service', 'boolean')],\\n 'trafo': [('hv_bus', 'positive_integer'), ('lv_bus', 'positive_integer'),\\n ('sn_mva', '>0'), ('vn_hv_kv', '>0'), ('vn_lv_kv', '>0'),\\n ('vkr_percent', '>=0'),\\n ('vk_percent', '>0'), ('pfe_kw', '>=0'), ('i0_percent', '>=0'),\\n ('in_service', 'boolean')],\\n 'trafo3w': [('hv_bus', 'positive_integer'), ('mv_bus', 'positive_integer'),\\n ('lv_bus', 'positive_integer'),\\n ('sn_hv_mva', '>0'), ('sn_mv_mva', '>0'), ('sn_lv_mva', '>0'),\\n ('vn_hv_kv', '>0'), ('vn_mv_kv', '>0'), ('vn_lv_kv', '>0'),\\n ('vkr_hv_percent', '>=0'), ('vkr_mv_percent', '>=0'),\\n ('vkr_lv_percent', '>=0'), ('vk_hv_percent', '>0'),\\n ('vk_mv_percent', '>0'), ('vk_lv_percent', '>0'),\\n ('pfe_kw', '>=0'), ('i0_percent', '>=0'),\\n ('in_service', 'boolean')],\\n 'load': [('bus', 'positive_integer'), ('p_mw', 'number'),\\n ('q_mvar', 'number'),\\n ('scaling', '>=0'), ('in_service', 'boolean')],\\n 'sgen': [('bus', 'positive_integer'), ('p_mw', 'number'),\\n ('q_mvar', 'number'),\\n ('scaling', '>=0'), ('in_service', 'boolean')],\\n 'gen': [('bus', 'positive_integer'), ('p_mw', 'number'),\\n ('scaling', '>=0'), ('in_service', 'boolean')],\\n 'ext_grid': [('bus', 'positive_integer'), ('vm_pu', '>0'),\\n ('va_degree', 'number')],\\n 'switch': [('bus', 'positive_integer'), ('element', 'positive_integer'),\\n ('et', 'switch_type'), ('closed', 'boolean')]}\\n\\n # matches a check function to each single input type restriction\\n type_checks = {'>0': check_greater_zero,\\n '>=0': check_greater_equal_zero,\\n '<0': check_less_zero,\\n '<=0': check_less_equal_zero,\\n 'boolean': check_boolean,\\n 'positive_integer': check_pos_int,\\n 'number': check_number,\\n '0<x<=1': check_greater_zero_less_equal_one,\\n 'switch_type': check_switch_type\\n }\\n\\n for key in important_values:\\n if len(net[key]) > 0:\\n for value in important_values[key]:\\n for i, element in net[key].iterrows():\\n check_result = type_checks[value[1]](element, i, value[0])\\n if check_result is not None:\\n if key not in check_results:\\n check_results[key] = []\\n # converts np.nan to str for easier usage of assert in pytest\\n nan_check = pd.isnull(net[key][value[0]].at[i])\\n if nan_check:\\n check_results[key].append((i, value[0],\\n str(net[key][value[0]].at[i]), value[1]))\\n else:\\n check_results[key].append((i, value[0],\\n net[key][value[0]].at[i], value[1]))\\n if check_results:\\n return check_results\",\n \"def estimate_advantage(self, obs, q_values):\\n\\n # TODO: Estimate the advantage when nn_baseline is True\\n # HINT1: pass obs into the neural network that you're using to learn the baseline\\n # extra hint if you're stuck: see your actor's run_baseline_prediction\\n # HINT2: advantage should be [Q-b]\\n if self.nn_baseline:\\n b_n_unnormalized = self.baseline_model(obs)\\n b_n = b_n_unnormalized * np.std(q_values) + np.mean(q_values)\\n adv_n = (q_values - tf.squeeze(b_n)).numpy()\\n # Else, just set the advantage to [Q]\\n else:\\n adv_n = q_values.copy()\\n\\n # Normalize the resulting advantages\\n if self.standardize_advantages:\\n adv_n = (adv_n - np.mean(adv_n)) / (np.std(adv_n) + 1e-8)\\n\\n return adv_n.astype(np.float32)\",\n \"def cost_b_v(self):\\n return self._cost_b_v\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5776241","0.5750878","0.5623462","0.54842955","0.5386926","0.52231693","0.52097505","0.5197751","0.5113644","0.5086685","0.5073465","0.50708735","0.5056254","0.5033763","0.5021825","0.5015476","0.50106674","0.5005514","0.4995753","0.49826834","0.4966393","0.49619266","0.4957525","0.49503857","0.4940665","0.49244165","0.49244165","0.49244165","0.49244165","0.49244165","0.49244165","0.49244165","0.49244165","0.49227518","0.4919729","0.4911313","0.4905583","0.4896395","0.48959696","0.4890918","0.48896733","0.48894134","0.48862803","0.48862803","0.48862803","0.48862803","0.48862803","0.48862803","0.48862803","0.48852536","0.48801818","0.48775497","0.48774955","0.48774955","0.48716152","0.4870855","0.48702246","0.48555374","0.4854864","0.4831371","0.48311788","0.48306584","0.48277628","0.482472","0.48242116","0.4822445","0.48213378","0.48205054","0.4819617","0.48105913","0.4803089","0.47956207","0.47956207","0.47949058","0.47926322","0.47876275","0.4785001","0.47837597","0.47819042","0.47760442","0.47744524","0.47734678","0.47693202","0.47660184","0.4765424","0.47653174","0.47619143","0.47607484","0.47589195","0.4757779","0.47575587","0.4756708","0.47563773","0.4753214","0.4749549","0.47460026","0.47404528","0.47342733","0.47323495","0.47280627"],"string":"[\n \"0.5776241\",\n \"0.5750878\",\n \"0.5623462\",\n \"0.54842955\",\n \"0.5386926\",\n \"0.52231693\",\n \"0.52097505\",\n \"0.5197751\",\n \"0.5113644\",\n \"0.5086685\",\n \"0.5073465\",\n \"0.50708735\",\n \"0.5056254\",\n \"0.5033763\",\n \"0.5021825\",\n \"0.5015476\",\n \"0.50106674\",\n \"0.5005514\",\n \"0.4995753\",\n \"0.49826834\",\n \"0.4966393\",\n \"0.49619266\",\n \"0.4957525\",\n \"0.49503857\",\n \"0.4940665\",\n \"0.49244165\",\n \"0.49244165\",\n \"0.49244165\",\n \"0.49244165\",\n \"0.49244165\",\n \"0.49244165\",\n \"0.49244165\",\n \"0.49244165\",\n \"0.49227518\",\n \"0.4919729\",\n \"0.4911313\",\n \"0.4905583\",\n \"0.4896395\",\n \"0.48959696\",\n \"0.4890918\",\n \"0.48896733\",\n \"0.48894134\",\n \"0.48862803\",\n \"0.48862803\",\n \"0.48862803\",\n \"0.48862803\",\n \"0.48862803\",\n \"0.48862803\",\n \"0.48862803\",\n \"0.48852536\",\n \"0.48801818\",\n \"0.48775497\",\n \"0.48774955\",\n \"0.48774955\",\n \"0.48716152\",\n \"0.4870855\",\n \"0.48702246\",\n \"0.48555374\",\n \"0.4854864\",\n \"0.4831371\",\n \"0.48311788\",\n \"0.48306584\",\n \"0.48277628\",\n \"0.482472\",\n \"0.48242116\",\n \"0.4822445\",\n \"0.48213378\",\n \"0.48205054\",\n \"0.4819617\",\n \"0.48105913\",\n \"0.4803089\",\n \"0.47956207\",\n \"0.47956207\",\n \"0.47949058\",\n \"0.47926322\",\n \"0.47876275\",\n \"0.4785001\",\n \"0.47837597\",\n \"0.47819042\",\n \"0.47760442\",\n \"0.47744524\",\n \"0.47734678\",\n \"0.47693202\",\n \"0.47660184\",\n \"0.4765424\",\n \"0.47653174\",\n \"0.47619143\",\n \"0.47607484\",\n \"0.47589195\",\n \"0.4757779\",\n \"0.47575587\",\n \"0.4756708\",\n \"0.47563773\",\n \"0.4753214\",\n \"0.4749549\",\n \"0.47460026\",\n \"0.47404528\",\n \"0.47342733\",\n \"0.47323495\",\n \"0.47280627\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5109669"},"document_rank":{"kind":"string","value":"9"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":48,"numItemsPerPage":100,"numTotalItems":95772,"offset":4800,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3MzgzMTg2MSwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3NzM4MzU0NjEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.n_hmh1vGy9ahciByyYnxR-F_krlRta0Zkxf2UJgMca_lSXq9JqMArrQzgzlyUMFZPLtS7ZdjjYML4J99SyfXBA","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 |
|---|---|---|---|---|---|---|
Add headers to both force latest IE rendering engine or Chrome Frame, and also to cache the rendered page for 10 minutes. | def add_header(r):
r.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
r.headers["Pragma"] = "no-cache"
r.headers["Expires"] = "0"
r.headers['Cache-Control'] = 'public, max-age=0'
return r | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_header(response):\n response.headers['X-UA-Compatible'] = 'IE=Edge,chrome=1'\n response.headers['Cache-Control'] = 'public, max-age=60'\n return response",
"def add_header(response):\n response.headers['X-UA-Compatible'] = 'IE=Edge,chrome=1'\n response.headers['Cache-Control'] = 'public, m... | [
"0.82239413",
"0.8223081",
"0.8223081",
"0.8223081",
"0.8223081",
"0.8196386",
"0.8163827",
"0.8163827",
"0.8163827",
"0.8163827",
"0.8163827",
"0.8163827",
"0.8163827",
"0.8163827",
"0.8163827",
"0.8163827",
"0.8163827",
"0.8163827",
"0.8163827",
"0.8163827",
"0.8163827",
... | 0.71290123 | 63 |
Returns a list of the currently connected playes (on the MC server). First tries to hit the cache to see if this has been checked recently. If there is no cache entry, queries the Minecraft server's zombiepygman API to get the list of currently connected players. | def _get_connected_player_list(self):
if not zpgapi.is_zgp_api_enabled():
# API is not configured, skip this.
return []
cache_key = 'api_connected_players'
cache_val = cache.get(cache_key)
if cache_val != None:
return cache_val
api = zpgapi.get_zpg_api_iface()
try:
api_response = api.cmd_list_connected()
cache_val = api_response['player_list']
except urllib2.URLError:
# Error with zombiepygman.
# This will get cached, but that's OK. It will prevent request
# pileup on the gunicorn workers.
cache_val = []
cache.set(cache_key, cache_val, 60)
return cache_val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_players(self):\n return self.server.status().players.online",
"def get_players():\n nfl_players = redis_cache('nfl_players_key', NFL_Player_2015.query.all)\n return nfl_players",
"def players(self):\n return self.currents.player",
"def get_players(self):\n\n # Append the cu... | [
"0.7143071",
"0.68768233",
"0.6365127",
"0.635414",
"0.62231076",
"0.60774004",
"0.6067745",
"0.60203606",
"0.6001943",
"0.5917321",
"0.5900113",
"0.58974326",
"0.5869177",
"0.5867893",
"0.5851105",
"0.58382463",
"0.5821852",
"0.57409716",
"0.5719336",
"0.57017183",
"0.565462... | 0.82015663 | 0 |
Ensure the value of 'done' is set to False when creating an item | def test_done_default_value_is_False(self):
item = Item(name = "A test item")
self.assertEqual(item.name, "A test item")
self.assertFalse(item.done) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_done_value_can_be_set_to_True(self):\n item = Item(name = \"A test item\", done = True)\n self.assertEqual(item.name, \"A test item\")\n self.assertTrue(item.done)",
"def test_create(self):\n Todo = self.env[\"todo.task\"]\n task = Todo.create({'name': 'Test Task'})\n ... | [
"0.73595536",
"0.69080955",
"0.6256873",
"0.6184523",
"0.61320096",
"0.60282576",
"0.6025874",
"0.59891725",
"0.58720154",
"0.5870808",
"0.58685875",
"0.5864126",
"0.5850043",
"0.5843042",
"0.580223",
"0.5788047",
"0.5772935",
"0.5769292",
"0.5767891",
"0.5756782",
"0.5730310... | 0.7237571 | 1 |
Ensure the value of 'done' is True when set to True when creating an item | def test_done_value_can_be_set_to_True(self):
item = Item(name = "A test item", done = True)
self.assertEqual(item.name, "A test item")
self.assertTrue(item.done) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_done_default_value_is_False(self):\n item = Item(name = \"A test item\")\n self.assertEqual(item.name, \"A test item\")\n self.assertFalse(item.done)",
"def test_create(self):\n Todo = self.env[\"todo.task\"]\n task = Todo.create({'name': 'Test Task'})\n self.as... | [
"0.7198816",
"0.6800873",
"0.65567577",
"0.6417597",
"0.6363705",
"0.6359525",
"0.6172014",
"0.6137984",
"0.61083496",
"0.6047177",
"0.60278106",
"0.6007678",
"0.59839237",
"0.59442586",
"0.590649",
"0.5906427",
"0.5846286",
"0.5799823",
"0.5794618",
"0.5780171",
"0.57660437"... | 0.76738805 | 0 |
Ensure the string value of the object is equal to the item name | def test_object_name_is_equal_to_item_name(self):
item = Item(name = "A test item")
self.assertEqual(str(item), "A test item") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_str(self):\n item = self.item\n\n self.assertEqual(str(item), self.item_raw['name'])",
"def _valid_object_with_name(ui_object):\n return ui_object.obj_name",
"def test_name(self):\n self.assertTrue(type(x.name) == str)",
"def test_values_single(self):\n input_item = self... | [
"0.72171146",
"0.6880246",
"0.6773977",
"0.6383563",
"0.6352",
"0.6319917",
"0.62903845",
"0.6150476",
"0.60850054",
"0.60359854",
"0.60222614",
"0.5974848",
"0.5964395",
"0.59447414",
"0.5942534",
"0.59195846",
"0.59191364",
"0.5898834",
"0.58966243",
"0.5865687",
"0.5844299... | 0.7843017 | 0 |
Create evaluator(s) for a given dataset. This uses the special metadata "evaluator_type" associated with each builtin dataset. For your own dataset, you can simply create an evaluator manually in your script and do not have to worry about the hacky ifelse logic here. | def build_evaluator(cls, cfg, dataset_name, output_folder=None):
if output_folder is None:
output_folder = os.path.join(cfg.OUTPUT_DIR, "inference")
evaluator_list = []
evaluator_type = MetadataCatalog.get(dataset_name).evaluator_type
if evaluator_type == "sem_seg":
return SemSegEvaluator(
dataset_name,
distributed=True,
output_dir=output_folder,
num_classes=4,
ignore_label=255
)
if evaluator_type == "cityscapes_sem_seg":
assert (
torch.cuda.device_count() >= comm.get_rank()
), "CityscapesEvaluator currently do not work with multiple machines."
return CityscapesSemSegEvaluator(dataset_name)
if len(evaluator_list) == 0:
raise NotImplementedError(
"no Evaluator for the dataset {} with the type {}".format(
dataset_name, evaluator_type
)
)
if len(evaluator_list) == 1:
return evaluator_list[0]
return DatasetEvaluators(evaluator_list) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_evaluator(cls, cfg, dataset_name, output_folder=None):\n if output_folder is None:\n output_folder = os.path.join(cfg.OUTPUT_DIR, \"inference\")\n evaluator_list = []\n evaluator_type = MetadataCatalog.get(dataset_name).evaluator_type\n if evaluator_type in [\"sem_s... | [
"0.71811223",
"0.7178588",
"0.7118122",
"0.62564474",
"0.6133015",
"0.5892592",
"0.5807464",
"0.5648055",
"0.5615826",
"0.5607056",
"0.55071527",
"0.54952985",
"0.5480512",
"0.5452857",
"0.54165035",
"0.54085374",
"0.5403301",
"0.5399699",
"0.5389954",
"0.5385437",
"0.5375982... | 0.69981503 | 3 |
Create a postvalidator function that makes sure the value of this item is a key in the sibling dictionary 'sib_name'. Raises a ValueError if not. This generally assumes siblings[sib_name] is a required CategoryElement. | def is_sib_key(sib_name):
def is_sib_key_val(siblings, value):
if value not in siblings[sib_name].keys():
raise ValueError(
"Must be a key of {}, but got {}"
.format(sib_name, value))
return value
return is_sib_key_val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate(self):\n for search_tag_name in self.get_search_tag_names():\n search_tag_obj = Tag(search_tag_name)\n for search_tag_value in self.get_search_tag_values(search_tag_name):\n for new_tag_name in self.get_new_tag_names(search_tag_name, search_tag_value):\n ... | [
"0.45828247",
"0.4572428",
"0.45380762",
"0.44724888",
"0.42696497",
"0.42584473",
"0.42416134",
"0.41420826",
"0.41245428",
"0.41224957",
"0.4097658",
"0.4080648",
"0.40750405",
"0.40694186",
"0.40613383",
"0.4061312",
"0.40393326",
"0.40243196",
"0.3988627",
"0.3969611",
"0... | 0.62593156 | 0 |
89 / 89 test cases passed. | def maxTurbulenceSize(self, arr: List[int]) -> int:
if len(arr) == 1:
return 1
ret = 1
tmp_ret = 0
last_flag = None
for i in range(1, len(arr)):
if arr[i] == arr[i - 1]:
current_flag = None
else:
current_flag = arr[i] > arr[i - 1]
if current_flag is None:
ret = max(ret, tmp_ret)
tmp_ret = 1
elif last_flag is None or last_flag == current_flag:
ret = max(ret, tmp_ret)
tmp_ret = 2
else:
tmp_ret += 1
last_flag = current_flag
return max(ret, tmp_ret) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_T01():",
"def test_T4():",
"def test_T4():",
"def exercise_b2_106():\r\n pass",
"def exercise_b2_113():\r\n pass",
"def test_basic(self):\n self.assertEqual(solution(\"\"\"11111\n19991\n19191\n19991\n11111\"\"\"), 6)\n self.assertEqual(solution(\"\"\"5483143223\n2745854711\n5... | [
"0.6906367",
"0.6610178",
"0.6610178",
"0.65972733",
"0.6592675",
"0.65818673",
"0.6549294",
"0.6506812",
"0.64938533",
"0.64341944",
"0.6431647",
"0.6431647",
"0.6419195",
"0.6403939",
"0.6397478",
"0.6384199",
"0.63813823",
"0.6361559",
"0.6293006",
"0.62877226",
"0.625898"... | 0.0 | -1 |
Try find newer version for test. if next version has already been failed, stop further upgrades. | def increase_version(self):
# type: (...) -> bool
if self.type == RequirementType.FINAL_LATEST_VERSION:
return False
# get the latest version that may work
if self.type == RequirementType.NOT_LATEST_VERSION:
# get version between the current and last
version_to_test = self.package.get_middle_version(
self.version, self.error_version)
if not version_to_test:
self.type = RequirementType.FINAL_LATEST_VERSION
return False
else:
version_to_test = self.package.last_version
if version_to_test == self.version:
# The latest version is already installed
return False
self.previous_version = self.version
self.version = version_to_test
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_upgrade_to_latest_but_same_version(self):\n with pytest.raises(\n ClickException,\n match=r\"The .* with id '.*' already has version .*. Nothing to upgrade.\",\n ):\n self.runner.invoke(\n cli,\n [\n \"upgrade\... | [
"0.7359393",
"0.7041746",
"0.68207544",
"0.6809215",
"0.6583295",
"0.6510883",
"0.64602184",
"0.6447396",
"0.64244986",
"0.6342098",
"0.63395315",
"0.63182235",
"0.63094175",
"0.63028187",
"0.63012606",
"0.6289545",
"0.62604177",
"0.6240322",
"0.61509264",
"0.61496556",
"0.61... | 0.6330563 | 11 |
get requirements file line. | def get_line(self):
# type: () -> str
line = "{}=={}".format(self.name, self.version)
if self.type != RequirementType.LATEST_VERSION:
line += ' # ' + TEMPLATES[self.type]
if self.type == RequirementType.NOT_LATEST_VERSION:
line = line.replace(r'(\S*)', self.error_version)
return line + '\n' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_line(self, path, line):\n\t\tlines = self.find_source(path)\n\t\tif lines == None:\n\t\t\treturn None\n\t\telse:\n\t\t\ttry:\n\t\t\t\treturn lines[line - 1]\n\t\t\texcept IndexError:\n\t\t\t\treturn None",
"def find_requirements():\n with open(\"requirements.txt\", 'r') as f:\n return f.read().... | [
"0.6740572",
"0.6701391",
"0.65815175",
"0.64647526",
"0.6415879",
"0.6412485",
"0.6349819",
"0.63256943",
"0.63117",
"0.6291996",
"0.62328476",
"0.6201596",
"0.6177119",
"0.6160064",
"0.6157574",
"0.615133",
"0.6138522",
"0.6128042",
"0.6090447",
"0.6074949",
"0.6072613",
... | 0.6781809 | 0 |
Split line on text and comment | def split_line(self, line):
# type: (str) -> tuple
parts = [s.strip() for s in line.split('#', 1)]
package = parts[0]
comment = parts[1] if len(parts) >= 2 else ''
return package, comment | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split_comment(cls, code):\r\n if '#' not in code: return code\r\n #: Remove comments only (leave quoted strings as they are)\r\n subf = lambda m: '' if m.group(0)[0]=='#' else m.group(0)\r\n return re.sub(cls.re_pytokens, subf, code)",
"def to_multi_line_comment(text: str) -> str:... | [
"0.6692685",
"0.66081315",
"0.65925145",
"0.6545137",
"0.6362264",
"0.6226867",
"0.62236226",
"0.6117526",
"0.6067819",
"0.60001516",
"0.59967846",
"0.5966611",
"0.59597796",
"0.5954498",
"0.59440887",
"0.59440887",
"0.5927107",
"0.5925445",
"0.59013635",
"0.5877957",
"0.5875... | 0.6687648 | 1 |
Calculate cosine distance between two vector | def findCosineDistance(vector1, vector2):
vec1 = vector1.flatten()
vec2 = vector2.flatten()
a = np.dot(vec1.T, vec2)
b = np.dot(vec1.T, vec1)
c = np.dot(vec2.T, vec2)
return 1 - (a / (np.sqrt(b) * np.sqrt(c))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cosine_distance(u, v):\n #print u,v\n return numpy.dot(u, v) / (math.sqrt(numpy.dot(u, u)) * math.sqrt(numpy.dot(v, v)))",
"def cosine_distance(u, v):\n return numpy.dot(u, v) / (math.sqrt(numpy.dot(u, u)) * math.sqrt(numpy.dot(v, v)))",
"def cosine_similarity(v1: Vector, v2: Vector) -> float:\n ... | [
"0.8144758",
"0.806103",
"0.7972851",
"0.79563916",
"0.7951864",
"0.77495205",
"0.7739488",
"0.7737394",
"0.7714112",
"0.7667365",
"0.76573527",
"0.7630341",
"0.7616587",
"0.76105106",
"0.76048666",
"0.7574436",
"0.7551911",
"0.7540636",
"0.7515504",
"0.7509719",
"0.7507556",... | 0.8303037 | 0 |
Verify the similarity of one vector to group vectors of one class | def CosineSimilarity(test_vec, source_vecs):
cos_dist = 0
for source_vec in source_vecs:
cos_dist += FacePredictor.findCosineDistance(test_vec, source_vec)
return cos_dist / len(source_vecs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_similarity(self):\n self.assertTrue(np.allclose(self.vectors.similarity('dog.n.01', 'dog.n.01'), 1))\n self.assertTrue(np.allclose(self.vectors.similarity('dog.n.01', 'mammal.n.01'), 0.180901358))",
"def test_dice_similarity_compiled():\n vector1 = np.array([1, 1, 0, 0])\n vector2 = ... | [
"0.750954",
"0.66709244",
"0.65119016",
"0.6507448",
"0.65028244",
"0.6483979",
"0.6449786",
"0.64489347",
"0.6439888",
"0.64329153",
"0.6320735",
"0.6308931",
"0.63024855",
"0.62732375",
"0.6246762",
"0.6246572",
"0.6237279",
"0.6201954",
"0.61760354",
"0.6173955",
"0.617291... | 0.55804986 | 100 |
Method to compile the BigQuery specific script execution command. | def generate_provider_specific_cmd_list(script, driver, output, error):
cmd_list = [driver, FLAGS.bq_project_id, FLAGS.bq_dataset_id,
script, output, error]
return cmd_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _define_script_command(command_name,\n parent_shell,\n bootstrap_script,\n container_path,\n scripts_path,\n script):\n script_fragment = \"\\\"{}\\\"\".format(script) if script ... | [
"0.58411306",
"0.5736632",
"0.55719966",
"0.5505636",
"0.54719853",
"0.5344112",
"0.5325198",
"0.5318884",
"0.53028625",
"0.5297254",
"0.528932",
"0.5273765",
"0.5254984",
"0.5248845",
"0.5227913",
"0.51987875",
"0.5188278",
"0.51837045",
"0.5174086",
"0.5140885",
"0.5131505"... | 0.0 | -1 |
Add index operation with name to the operations given. | def add_index_operation(self, name, operations):
if name not in self._index_operations:
self._add_io(name, operations)
else:
raise AttributeError("An index operation with the name {} was already taken".format(name)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_index(self, name, func):\n assert name not in self.indices\n info_name = 'index:%s:%s' % (self.info['name'], name)\n info = self.store._get_info(info_name, index_for=self.info['name'])\n index = Index(self, info, func)\n self.indices[name] = index\n if IndexKeyBuil... | [
"0.68858343",
"0.6698154",
"0.64274466",
"0.6417586",
"0.63482445",
"0.6007961",
"0.5947242",
"0.5861968",
"0.5853543",
"0.57812166",
"0.57532567",
"0.57404816",
"0.57012236",
"0.5667653",
"0.5642528",
"0.5634883",
"0.56331265",
"0.5619371",
"0.55785316",
"0.5549118",
"0.5546... | 0.85664165 | 0 |
Return the offset of the param inside this parameterized object. This does not need to account for shaped parameters, as it basically just sums up the parameter sizes which come before param. | def _offset_for(self, param):
if param.has_parent():
p = param._parent_._get_original(param)
if p in self.parameters:
return reduce(lambda a,b: a + b.size, self.parameters[:p._parent_index_], 0)
return self._offset_for(param._parent_) + param._parent_._offset_for(param)
return 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def offset(self):\n return self.__offset",
"def offset(self):\n return self.__offset",
"def get_offset(self):\n return self.offset",
"def wm_offset(self):\n return self.get_par(\"offset\")",
"def offset(self):\n return self._offset",
"def offset(self):\n return self.... | [
"0.65088356",
"0.65088356",
"0.6396925",
"0.63015145",
"0.6291252",
"0.6291252",
"0.6291252",
"0.6291252",
"0.6291252",
"0.6291252",
"0.6291252",
"0.62532693",
"0.62532693",
"0.62532693",
"0.62496376",
"0.62265295",
"0.61739165",
"0.61539537",
"0.61539537",
"0.61539537",
"0.6... | 0.79988617 | 1 |
get the raveled index for a param that is an int array, containing the indexes for the flattened param inside this parameterized logic. !Warning! be sure to call this method on the highest parent of a hierarchy, as it uses the fixes to do its work | def _raveled_index_for(self, param):
from ..param import ParamConcatenation
if isinstance(param, ParamConcatenation):
return np.hstack((self._raveled_index_for(p) for p in param.params))
return param._raveled_index() + self._offset_for(param) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _raveled_index_for(self, param):\n from .param import ParamConcatenation\n if isinstance(param, ParamConcatenation):\n return np.hstack((self._raveled_index_for(p) for p in param.params))\n return param._raveled_index() + self._offset_for(param)",
"def _raveled_index_for_trans... | [
"0.71273017",
"0.6010891",
"0.59065056",
"0.5804188",
"0.58011395",
"0.57862777",
"0.57440937",
"0.57440937",
"0.57353306",
"0.56626016",
"0.56598043",
"0.5625494",
"0.5600237",
"0.5588847",
"0.5567432",
"0.55587304",
"0.55522966",
"0.554781",
"0.55181646",
"0.5507306",
"0.55... | 0.71871 | 0 |
get the raveled index for a param for the transformed parameter array (optimizer array). that is an int array, containing the indexes for the flattened param inside this parameterized logic. !Warning! be sure to call this method on the highest parent of a hierarchy, as it uses the fixes to do its work. If you do not know what you are doing, do not use this method, it will have unexpected returns! | def _raveled_index_for_transformed(self, param):
ravi = self._raveled_index_for(param)
if self._has_fixes():
fixes = self._fixes_
### Transformed indices, handling the offsets of previous fixes
transformed = (np.r_[:self.size] - (~fixes).cumsum())
return transformed[ravi[fixes[ravi]]]
else:
return ravi | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _raveled_index_for(self, param):\n from ..param import ParamConcatenation\n if isinstance(param, ParamConcatenation):\n return np.hstack((self._raveled_index_for(p) for p in param.params))\n return param._raveled_index() + self._offset_for(param)",
"def _raveled_index_for(self... | [
"0.73500043",
"0.72873694",
"0.5873878",
"0.5873878",
"0.58434486",
"0.56710553",
"0.5656544",
"0.5656544",
"0.5554051",
"0.554955",
"0.5519457",
"0.5428711",
"0.536669",
"0.5312925",
"0.5258314",
"0.5250333",
"0.51969874",
"0.51883346",
"0.5186911",
"0.51863664",
"0.5186337"... | 0.69185156 | 2 |
Flattened array of ints, specifying the index of this object. This has to account for shaped parameters! | def _raveled_index(self):
return np.r_[:self.size] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _idxs_postformat_array(self):\n self.idxs = np.array(self.idxs)",
"def flatten_idx(idx, axis=-1):\n idx = numpy.asanyarray(idx)\n if not idx.dtype.kind in ('i', 'u'):\n idx = idx.astype(int)\n preshape = idx.shape[:axis]\n postshape = idx.shape[axis:]\n stride = int(numpy.product... | [
"0.65175533",
"0.62058824",
"0.5974461",
"0.59025675",
"0.58936995",
"0.58421",
"0.58367753",
"0.57612103",
"0.5670626",
"0.5655063",
"0.5648909",
"0.56180966",
"0.5589195",
"0.55857176",
"0.55857176",
"0.5580362",
"0.55702096",
"0.5560747",
"0.544082",
"0.5435741",
"0.541882... | 0.53458685 | 27 |
Helper preventing copy code. This adds the given what (transformation, prior etc) to parameter index operations which. reconstrained are reconstrained indices. warn when reconstraining parameters if warning is True. | def _add_to_index_operations(self, which, reconstrained, what, warning):
if warning and reconstrained.size > 0:
# TODO: figure out which parameters have changed and only print those
print("WARNING: reconstraining parameters {}".format(self.hierarchy_name() or self.name))
index = self._raveled_index()
which.add(what, index)
return index | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def warn_inplace(exc, nav, repl_pairs, local_opt):\r\n if isinstance(exc, InconsistencyError):\r\n return\r\n return NavigatorOptimizer.warn(exc, nav, repl_pairs, local_opt)",
"def ensure_default_constraints(self,warn=False):\n positive_strings = ['variance','lengthscale', 'precis... | [
"0.6421251",
"0.57638377",
"0.53960013",
"0.5364344",
"0.52853006",
"0.52772886",
"0.52772886",
"0.52772886",
"0.52637357",
"0.52537453",
"0.52390754",
"0.5176815",
"0.51558375",
"0.514963",
"0.51430506",
"0.5140084",
"0.5106313",
"0.5041951",
"0.49778527",
"0.4977233",
"0.49... | 0.71344423 | 1 |
Helper preventing copy code. Remove given what (transform prior etc) from which param index ops. | def _remove_from_index_operations(self, which, transforms):
if len(transforms) == 0:
transforms = which.properties()
removed = np.empty((0,), dtype=int)
for t in list(transforms):
unconstrained = which.remove(t, self._raveled_index())
removed = np.union1d(removed, unconstrained)
if t is __fixed__:
self._highest_parent_._set_unfixed(self, unconstrained)
return removed | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _remove_operator(self, operator):",
"def remove_extra_index_from_context_actions(context_action_dict):\n keys_to_keep = {'initial_value', 'replacement_value'}\n for question in context_action_dict:\n for obj_dct in context_action_dict[question]:\n total_keys = set(obj_dct.keys())\n ... | [
"0.5864179",
"0.57993364",
"0.5767263",
"0.5759645",
"0.57012475",
"0.5697558",
"0.5676129",
"0.56178457",
"0.559176",
"0.55809194",
"0.5571276",
"0.5533166",
"0.5462391",
"0.5455604",
"0.54388994",
"0.54100037",
"0.539974",
"0.5399218",
"0.53672886",
"0.53319484",
"0.5327874... | 0.65478945 | 1 |
Emit a JSON representation of a given row | def format(self, row):
return json.dumps(row.print_fields) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write(self, row: Optional[Any] = None):\n self.fout.write('{}\\n'.format(json.dumps(row, cls=self.encoder)))",
"def row_to_json(row: sqlite3.Row) -> str:\n d = {}\n for key in row.keys():\n d[key] = row[key]\n\n return json.dumps(d)",
"def __data_row_to_json(self, row):\n raw_... | [
"0.745525",
"0.7241681",
"0.72320414",
"0.6897235",
"0.68846",
"0.6736316",
"0.65954936",
"0.65526325",
"0.6160118",
"0.61541754",
"0.6141491",
"0.61156374",
"0.6115557",
"0.6070374",
"0.60693794",
"0.6057097",
"0.5938166",
"0.5934188",
"0.58886075",
"0.58313084",
"0.5826782"... | 0.7718322 | 0 |
return a header for the row | def header(self, fields):
return fields | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _horizontal_header(self):\n return self.header()",
"def _horizontal_header(self):\n return self.header()",
"def __get_header_tags(self):\n tag = \"<th>{}</th>\"\n\n return (tag * len(self.__rows)).format(*self.__rows)",
"def _generateRowHeader(self, obj, **args):\n resu... | [
"0.7744287",
"0.7744287",
"0.7658061",
"0.7620999",
"0.75094855",
"0.74332565",
"0.73744935",
"0.73059195",
"0.7254804",
"0.7210276",
"0.7183111",
"0.7131767",
"0.71054065",
"0.7100797",
"0.7089827",
"0.69185275",
"0.69134706",
"0.6910354",
"0.6902813",
"0.6865558",
"0.685388... | 0.62879777 | 73 |
Populate the class with the json info | def populate(self, fid1, fid2):
self.input1 = json.load(fid1)
self.input2 = json.load(fid2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, json):\n\n self.id = json[\"id\"]\n self.alternateId = json[\"alternateId\"]\n self.name = json[\"name\"]\n\n if \"description\" in json:\n self.description = json[\"description\"]\n\n if \"episodeCount\" in json:\n self.episodeCount = jso... | [
"0.7457732",
"0.74043804",
"0.7343072",
"0.71182615",
"0.7032978",
"0.6789153",
"0.66915345",
"0.66697764",
"0.66629",
"0.66505814",
"0.66464657",
"0.6644336",
"0.6605952",
"0.66035146",
"0.65517664",
"0.65442574",
"0.6533766",
"0.65309536",
"0.65301555",
"0.65257514",
"0.652... | 0.0 | -1 |
Creates a dictonary of nodes listed by currie id from answers 1 and 2 | def make_node_dict(self):
if self.input1 is None or self.input2 is None:
raise Exception("Missing input: please run the populate() method first")
self.node_dict1 = {}
for node in self.input1['knowledge_graph']['nodes']:
self.node_dict1[node['id']] = node
self.node_dict2 = {}
for node in self.input2['knowledge_graph']['nodes']:
self.node_dict2[node['id']] = node | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_nodes_by_id(ntwrk, nodeid):\r\n return {k: v for el in ntwrk\r\n for k, v in el.items() if k == nodeid}",
"def node_diff(self):\n if self.input1 is None or self.input2 is None:\n raise Exception(\"Missing input: please run the populate() method first\")\n if s... | [
"0.5874153",
"0.5803899",
"0.5788026",
"0.5769955",
"0.56848216",
"0.56081706",
"0.5563815",
"0.55347794",
"0.5533629",
"0.55147934",
"0.5420318",
"0.53809404",
"0.53226113",
"0.53205335",
"0.52443105",
"0.52339405",
"0.5148043",
"0.5130552",
"0.5121005",
"0.5114256",
"0.5098... | 0.60742897 | 0 |
Runs through all of the nodes in the json responses storing the intersection and set differences into a dictonary organized by tuples of node ids or the tuple (1, 1) for all nodes. | def node_diff(self):
if self.input1 is None or self.input2 is None:
raise Exception("Missing input: please run the populate() method first")
if self.node_dict1 is None or self.node_dict2 is None:
self.make_node_dict()
# Initialize dictonaries to keep track of the nodes in respnse 1 and response 2
g1={}
g2={}
# Set to keep track of the union of all curie ids
curie_set = set()
for curie in self.node_dict1.keys():
g1[curie] = {}
# intersection is only in the g1 dictionary
g1[curie]['intersection'] = set()
# node section keeps track of node ids associated with each node i.e. "n0"
g1[curie]['node'] = set()
curie_set.add(curie)
for curie in self.node_dict2.keys():
g2[curie] = {}
# node section keeps track of node ids associated with each node i.e. "n0"
g2[curie]['node'] = set()
curie_set.add(curie)
node_names1 = []
node_names2 = []
# extract all node ids (i.e. "n0","n1",ect...)
if len(self.input1['question_graph']['nodes'])>0:
if 'id' in self.input1['question_graph']['nodes'][0]:
node_names1 = [x['id'] for x in self.input1['question_graph']['nodes']]
elif 'node_id' in self.input1['question_graph']['nodes'][0]:
node_names1 = [x['node_id'] for x in self.input1['question_graph']['nodes']]
if len(self.input2['question_graph']['nodes'])>0:
if 'id' in self.input2['question_graph']['nodes'][0]:
node_names2 = [x['id'] for x in self.input2['question_graph']['nodes']]
elif 'node_id' in self.input2['question_graph']['nodes'][0]:
node_names2 = [x['node_id'] for x in self.input2['question_graph']['nodes']]
# initialize the result dictonary
diff_dict = {}
diff_dict["-1|-1"] = {'intersection':[],'g1-g2':[],'g2-g1':[]}
# initialize node id tuple keys
for id1 in node_names1:
for id2 in node_names2:
diff_dict[id1+"|"+id2] = {'intersection':[],'g1-g2':[],'g2-g1':[]}
# iterate through answers
for answer1 in self.input1['answers']:
for answer2 in self.input2['answers']:
for id1 in answer1['node_bindings'].keys():
# This is to handle cases where answer node id has a list or a string
if isinstance(answer1['node_bindings'][id1], str):
bindings1 = [answer1['node_bindings'][id1]]
elif isinstance(answer1['node_bindings'][id1], list):
bindings1 = answer1['node_bindings'][id1]
for curie1 in bindings1:
# store node id
g1[curie1]['node'].add(id1)
for id2 in answer2['node_bindings'].keys():
# This is to handle cases where answer node id has a list or a string
if isinstance(answer2['node_bindings'][id2], str):
bindings2 = [answer2['node_bindings'][id2]]
elif isinstance(answer2['node_bindings'][id2], list):
bindings2 = answer2['node_bindings'][id2]
for curie2 in bindings2:
# store node id
g2[curie2]['node'].add(id2)
if curie1 == curie2:
# stor intersection tuple
g1[curie1]['intersection'].add(id1+"|"+id2)
# iterate through all curies
for curie in curie_set:
# check if curie is from answer 1
if curie in g1.keys():
# check if in intersection
if len(g1[curie]['intersection'])>0:
diff_dict["-1|-1"]['intersection'] += [self.node_dict1[curie]]
for id1 in node_names1:
for id2 in node_names2:
node_tuple = id1+"|"+id2
if id1 in g1[curie]['node'] and id2 in g2[curie]['node']:
diff_dict[node_tuple]['intersection'] += [self.node_dict1[curie]]
elif id1 in g1[curie]['node']:
diff_dict[node_tuple]['g1-g2'] += [self.node_dict1[curie]]
elif id2 in g2[curie]['node']:
diff_dict[node_tuple]['g2-g1'] += [self.node_dict1[curie]]
# If not in intersection store in g1-g2
else:
diff_dict["-1|-1"]['g1-g2'] += [self.node_dict1[curie]]
for id1 in g1[curie]['node']:
# iterate through all answer 2 ids
for id2 in node_names2:
diff_dict[id1+"|"+id2]['g1-g2'] += [self.node_dict1[curie]]
# if not in g1 but in g2 then in g2-g1
elif curie in g2.keys():
diff_dict["-1|-1"]['g2-g1'] += [self.node_dict2[curie]]
for id2 in g2[curie]['node']:
# iterate through all answer 1 ids
for id1 in node_names1:
diff_dict[id1+"|"+id2]['g2-g1'] += [self.node_dict2[curie]]
return diff_dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dict_sets_intersection_test(self, data):\n\n data_info = self.get_data_info(data)\n finished = []\n\n for part in data:\n for union_part in data:\n if part != union_part and union_part not in finished:\n data[part].intersection(data[union_part])... | [
"0.57611847",
"0.57074016",
"0.5648599",
"0.5608913",
"0.55996966",
"0.54121363",
"0.539312",
"0.5247284",
"0.5185026",
"0.51842594",
"0.51647484",
"0.51572686",
"0.51484066",
"0.5144395",
"0.5093303",
"0.5067902",
"0.5056289",
"0.5055382",
"0.5027136",
"0.5016611",
"0.500497... | 0.6736763 | 0 |
Create matrix associated with kernel interpolation. | def interp_matrix(qpnts, spnts, npgrid, nsamp, deg_max):
# Initialize
A = np.zeros((nsamp,npgrid))
# Create matrix
for i in xrange(nsamp):
for j in xrange(npgrid):
cosTheta = np.dot(spnts[i], qpnts[j])
if(abs(cosTheta)>1):
cosTheta = np.sign(cosTheta)
A[i,j] = inv_funk_radon_kernel(cosTheta, deg_max)
return A | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _calculate_interpolation_matrix(self, X):\n G = np.zeros((len(X), self.hidden_shape))\n for data_point_arg, data_point in enumerate(X):\n for center_arg, center in enumerate(self.centers):\n if self.mode == 'gaus':\n G[\n data_po... | [
"0.6601181",
"0.5991661",
"0.59131616",
"0.5783467",
"0.5772154",
"0.5769376",
"0.5727504",
"0.571512",
"0.5695456",
"0.56801045",
"0.5649581",
"0.56263125",
"0.56191933",
"0.55479634",
"0.54599106",
"0.54450864",
"0.5416208",
"0.54120284",
"0.54111737",
"0.5408678",
"0.53303... | 0.5754054 | 6 |
Create matrix associated with inversion based on Aganj et al. formalism. | def interp_matrix_new(qpnts, spnts, npgrid, nsamp, deg_max):
# Initialize
A = np.zeros((nsamp,npgrid))
# Create matrix
for i in xrange(nsamp):
for j in xrange(npgrid):
cosTheta = np.dot(spnts[i], qpnts[j])
if(abs(cosTheta)>1):
cosTheta = np.sign(cosTheta)
A[i,j] = inv_funk_radon_even_kernel(cosTheta, deg_max)
return A | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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 ... | [
"0.6711361",
"0.6592599",
"0.6546603",
"0.64961314",
"0.6466997",
"0.64629614",
"0.6427826",
"0.6343991",
"0.6329846",
"0.6236044",
"0.62210953",
"0.621212",
"0.62022287",
"0.6199758",
"0.6198103",
"0.6197292",
"0.6197292",
"0.61816674",
"0.615353",
"0.61416143",
"0.6140042",... | 0.0 | -1 |
Create random signal on the sphere | def rand_sig(u, b, n, theta):
# Locally used names
from numpy import dot, exp
# Diffusion tensor parameters -- diffusion along x-axis
lambda1 = 1700e-6
lambda2 = 300e-6
lambda3 = 300e-6
# diagonal diffusion tensor for "prolate white matter"
D1 = np.diag([lambda1, lambda2, lambda3])
D2 = D1
D3 = D1
# rotation of diffusion tensor
rotationMatrix = rotation3Dy(theta)
D1 = dot(dot(rotationMatrix,D1),rotationMatrix.T)
#
rotationMatrix = rotation3Dz(-theta)
D2 = dot(dot(rotationMatrix,D2),rotationMatrix.T)
angle = np.arccos(np.cos(theta)*np.cos(theta))*180/np.pi
# XXX - check with cory these semantics
if n==1:
s = exp(-b * dot(u, dot(D1,u)) ) # Single mode
elif n==2:
s = 0.5 * (exp(-b * dot(u, dot(D1,u)) ) +
exp(-b * dot(u, dot(D2,u)) ) )
elif n==3:
s = (1.0/3) * (exp(-b * dot(u, dot(D1,u)) ) +
exp(-b * dot(u, dot(D2,u)) ) +
exp(-b * dot(u, dot(D3,u)) ) )
return (angle,s) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rndSphere():\n sph = [0,0,0]\n \n sph[2] = random.uniform(-1.0,1.0)\n z2 = math.sqrt(1.0 - sph[2]*sph[2])\n phi = (2. * math.pi) * random.random()\n sph[0] = z2 * math.cos(phi)\n sph[1] = z2 * math.sin(phi)\n \n return sph",
"def randomPointOnSphere(r):\n x = np.random.no... | [
"0.7532667",
"0.7204255",
"0.71878636",
"0.7109239",
"0.70131403",
"0.69970477",
"0.6976129",
"0.69127107",
"0.69005173",
"0.6890995",
"0.6522725",
"0.64420277",
"0.6441751",
"0.64262915",
"0.6411878",
"0.6391545",
"0.6374727",
"0.6287322",
"0.6277766",
"0.6242343",
"0.623808... | 0.0 | -1 |
Reproducing kernel Calculate the inverse FunkRadon transform of reproducing kernel for the space of spherical harmonics of maximum degree N. | def inv_funk_radon_kernel(mu, N):
# Check that -1 <= mu <= 1
mu = np.clip(mu, -1, 1)
# Need Legendre polynomials
legPolys = legp(mu, N)
p_at_zero = legp(0, N)
coefs = 2*np.arange(0, N+1, 2) + 1
ker = coefs*legPolys[::2]/p_at_zero[::2]
return ker.sum() / (8*np.pi) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inv_funk_radon_even_kernel(mu, N):\n\n # Check that -1 <= mu <= 1\n mu = np.clip(mu, -1, 1)\n\n # Need Legendre polynomials\n legPolys = legp(mu, N)\n p_at_zero = legp(0, N)\n\n coefs_num = 2*np.arange(0, N+1) + 1\n coefs_den = np.arange(2,N+1,2) * (np.arange(2,N+1,2) + 1)\n\n ker = coe... | [
"0.7213641",
"0.63983333",
"0.61867654",
"0.61385816",
"0.61052585",
"0.60678124",
"0.6047397",
"0.59877527",
"0.598379",
"0.59239495",
"0.584012",
"0.5723425",
"0.57071584",
"0.5696312",
"0.55959344",
"0.556116",
"0.5512384",
"0.5488459",
"0.5458828",
"0.5453336",
"0.543654"... | 0.7255298 | 0 |
Reproducing kernel Calculate inverse FunkRadon transform and inverse spherical Laplacian of reproducing kernel for even degree subspace of spherical harmonics of maximum degree N, i.e., calculates H(\mu) = \Delta^1 G^1 K_e(\mu), where \Delta is the spherical Laplacian and G is the FunkRadon transporm. The calculation is done in spectral space. | def inv_funk_radon_even_kernel(mu, N):
# Check that -1 <= mu <= 1
mu = np.clip(mu, -1, 1)
# Need Legendre polynomials
legPolys = legp(mu, N)
p_at_zero = legp(0, N)
coefs_num = 2*np.arange(0, N+1) + 1
coefs_den = np.arange(2,N+1,2) * (np.arange(2,N+1,2) + 1)
ker = coefs_num[2::2]*legPolys[2::2] / (p_at_zero[2::2] * coefs_den)
return ker.sum() / (8.0*np.pi*np.pi) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inv_funk_radon_kernel(mu, N):\n\n # Check that -1 <= mu <= 1\n mu = np.clip(mu, -1, 1)\n\n # Need Legendre polynomials\n legPolys = legp(mu, N)\n p_at_zero = legp(0, N)\n coefs = 2*np.arange(0, N+1, 2) + 1\n ker = coefs*legPolys[::2]/p_at_zero[::2]\n return ker.sum() / (8*np.pi)",
"de... | [
"0.739296",
"0.6562701",
"0.65557134",
"0.65486634",
"0.63957083",
"0.6381057",
"0.6323597",
"0.62995636",
"0.6100595",
"0.59519017",
"0.59446114",
"0.59294933",
"0.59197277",
"0.5910358",
"0.5873097",
"0.58403426",
"0.5745301",
"0.5744658",
"0.5742014",
"0.57419306",
"0.5586... | 0.7455563 | 0 |
Reproducing kernel Calculate of reproducing kernel for even subspace of spherical harmonics of maximum degree N. | def even_kernel(mu, N):
# Check that -1 <= mu <= 1
mu = np.clip(mu, -1, 1)
# Need Legendre polynomials
legPolys = legp(mu, N)
coefs = 2*np.arange(0, N+1) + 1
ker = coefs[0::2]*legPolys[0::2]
return ker.sum() / (4.0*np.pi) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def even_kernel_der(mu, N):\n\n # Check that -1 <= mu <= 1\n mu = np.clip(mu, -1, 1)\n\n #Derivatives of Legendre polynomials\n DlegPolys = legp_der(mu, N)\n \n coefs = 2*np.arange(0, N+1) + 1\n \n ker = coefs[0::2]*DlegPolys[0::2] \n\n return ker.sum() / (4.0*np.pi)",
"def inv_funk_radon... | [
"0.6827804",
"0.67321193",
"0.67197824",
"0.65318835",
"0.6531037",
"0.6433048",
"0.62198204",
"0.6084965",
"0.60187733",
"0.60123444",
"0.59886587",
"0.59792995",
"0.5959411",
"0.59217125",
"0.5896507",
"0.58899844",
"0.5817358",
"0.5794526",
"0.5773375",
"0.5705847",
"0.568... | 0.7083843 | 0 |
Derivative of reproducing kernel on even subspaces of maximum degree N. | def even_kernel_der(mu, N):
# Check that -1 <= mu <= 1
mu = np.clip(mu, -1, 1)
#Derivatives of Legendre polynomials
DlegPolys = legp_der(mu, N)
coefs = 2*np.arange(0, N+1) + 1
ker = coefs[0::2]*DlegPolys[0::2]
return ker.sum() / (4.0*np.pi) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def even_kernel(mu, N):\n\n # Check that -1 <= mu <= 1\n mu = np.clip(mu, -1, 1)\n\n # Need Legendre polynomials\n legPolys = legp(mu, N)\n \n\n coefs = 2*np.arange(0, N+1) + 1\n \n ker = coefs[0::2]*legPolys[0::2] \n\n return ker.sum() / (4.0*np.pi)",
"def compute_gradient_kernel_respect... | [
"0.63502026",
"0.60510343",
"0.5926386",
"0.59101856",
"0.5898114",
"0.56899774",
"0.56315917",
"0.5616251",
"0.558586",
"0.55735755",
"0.55652493",
"0.55386996",
"0.5501476",
"0.54612076",
"0.54292554",
"0.54179746",
"0.54039854",
"0.5398605",
"0.5376709",
"0.53656363",
"0.5... | 0.66818523 | 0 |
Reproducing kernel Calculate of reproducing kernel for subspace of spherical harmonics of maximum degree N. | def kernel(mu, N):
# Check that -1 <= mu <= 1
mu = np.clip(mu, -1, 1)
# Need Legendre polynomials
legPolys = legp(mu, N)
coefs = 2*np.arange(0, N+1) + 1
ker = coefs*legPolys
return ker.sum() / (4.0*np.pi) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_stitch(N):\n\tif N is None:\n\t\tN = np.int32(HII_DIM) #prepare for stitching\n\tMETA_GRID_SIZE = DIM/N\n\tM = np.int32(HII_DIM/META_GRID_SIZE)\n\t#HII_DIM = np.int32(HII_DIM)\n\tf_pixel_factor = DIM/HII_DIM;\n\tscale = np.float32(BOX_LEN/DIM)\n\tprint 'scale', scale\n\tHII_scale = np.float32(BOX_LEN/HII_... | [
"0.6673899",
"0.66569775",
"0.6480273",
"0.6411122",
"0.62793094",
"0.626478",
"0.60912395",
"0.6079251",
"0.5977385",
"0.5952887",
"0.5948711",
"0.59083223",
"0.58799875",
"0.58414066",
"0.58391666",
"0.5796582",
"0.56330234",
"0.5628569",
"0.5627499",
"0.55669326",
"0.55633... | 0.6426333 | 3 |
Given the coefficients, evaluate model at a specific direction omega | def even_pODF(omega, qpoints, c, N):
n,m = qpoints.shape
sum = 0.0
for i in range(n):
mu = np.dot(omega,qpoints[i,:])
mu = np.clip(mu, -1.0, 1.0)
sum += c[i]*even_kernel(mu, N)
return sum | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def omega(self):\n return self._data.train_X @ self._thetas",
"def solve_model():\n from scipy.integrate import ode\n # Initialise constants and state variables\n (init_states, constants) = initConsts()\n\n # Set timespan to solve over\n voi = linspace(0, 100, 5000)\n\n # Construct ODE o... | [
"0.5641719",
"0.5596931",
"0.5473129",
"0.54537827",
"0.5378322",
"0.53513557",
"0.528142",
"0.5268483",
"0.5266664",
"0.5229376",
"0.521022",
"0.5209983",
"0.52085",
"0.51614934",
"0.5149023",
"0.50841874",
"0.5070143",
"0.50686336",
"0.5039311",
"0.5032286",
"0.5028618",
... | 0.0 | -1 |
Given the coefficients, evaluate model at a specific direction (theta,phi) | def even_pODF_opt(angles,*args): # qpoints, c, N):
qpoints = args[0]
c = args[1]
N = args[2]
n,m = qpoints.shape
theta,phi = angles[0], angles[1]
omega = np.array([np.sin(theta)*np.cos(phi),np.sin(theta)*np.sin(phi),np.cos(theta)])
sum = 0.0
for i in range(n):
mu = np.dot(omega,qpoints[i,:])
mu = np.clip(mu, -1.0, 1.0)
sum += c[i]*even_kernel(mu, N)
return -(N+1)**2 * sum | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def eval(self, theta, phi):\n required_fields = [\"coeff\", \"order\"]\n for field in required_fields:\n if field not in self.linear_fit.keys():\n raise ValueError(\"It looks like \"\n \"interface_energy_poly_expansion \"\n ... | [
"0.60838443",
"0.5885254",
"0.5861287",
"0.5416153",
"0.52906",
"0.5278243",
"0.52711785",
"0.518602",
"0.5174683",
"0.51556545",
"0.51364434",
"0.51288843",
"0.5110274",
"0.5109226",
"0.5090163",
"0.5054213",
"0.5048513",
"0.50369865",
"0.5005936",
"0.49957308",
"0.4991553",... | 0.0 | -1 |
Given the coefficients, evaluate gradient of model at a specific direction (theta,phi) returns 2x1 gradient | def even_pODF_opt_grad(angles, *args):
qpoints = args[0]
c = args[1]
N = args[2]
n,m = qpoints.shape
theta,phi = angles[0], angles[1]
omega = np.array([np.sin(theta)*np.cos(phi),np.sin(theta)*np.sin(phi),np.cos(theta)])
#Partial in theta direction
sum = 0.0
for i in range(n):
mu = np.dot(omega,qpoints[i,:])
mu = np.clip(mu, -1.0, 1.0)
r_i, theta_i, phi_i = car2sph(qpoints[i,0],qpoints[i,1],qpoints[i,2])
sum += c[i]*even_kernel_der(mu, N)*(-np.cos(theta_i)*np.cos(theta) + np.cos(phi - phi_i)*np.cos(theta)*np.sin(theta_i))
p_theta = sum
#Partial in phi direction
sum = 0.0
for i in range(n):
mu = np.dot(omega,qpoints[i,:])
mu = np.clip(mu, -1.0, 1.0)
r_i, theta_i, phi_i = car2sph(qpoints[i,0],qpoints[i,1],qpoints[i,2])
sum += c[i]*even_kernel_der(mu, N)*( -np.sin(phi - phi_i)*np.sin(theta)*np.sin(theta_i) )
p_phi = sum
return -(N + 1)**2 * np.array([p_theta,p_phi]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"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 compute_gradient(theta, X, y):\n m = X.shape[0]\n grad_theta = np.dot(X.transpose(), (np.dot(X, t... | [
"0.73058945",
"0.7201665",
"0.7106998",
"0.70931894",
"0.70859104",
"0.70620006",
"0.7045631",
"0.6992574",
"0.6935396",
"0.67486787",
"0.67435336",
"0.67086285",
"0.67086285",
"0.6706915",
"0.67043006",
"0.6637536",
"0.6625402",
"0.6624418",
"0.6577811",
"0.65765494",
"0.657... | 0.0 | -1 |
Returns truncated iterated logarithm y = log( log(x) ) where if x<delta, x = delta and if 1delta < x, x = 1delta. | def exp_integral(x):
gamma = 0.577215665
return (-gamma - expn(x,1) - np.log(x)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ilog(x,delta):\n if(delta < x and x < 1.0 - delta):\n return np.log( -np.log(x) )\n elif(x < delta):\n return np.log( -np.log(delta) )\n else: \n return np.log( -np.log(1.0 - delta) )",
"def logit(x: torch.Tensor, eps=1e-5) -> torch.Tensor:\n x = torch.clamp(x, eps, 1.0 - eps... | [
"0.8148231",
"0.7274531",
"0.7241603",
"0.7214562",
"0.7204403",
"0.7167102",
"0.71177113",
"0.6768097",
"0.669359",
"0.6662506",
"0.66573983",
"0.66425556",
"0.66316724",
"0.66110545",
"0.6557691",
"0.6542005",
"0.6526384",
"0.6520332",
"0.6498638",
"0.6453334",
"0.6449421",... | 0.0 | -1 |
Returns truncated iterated logarithm y = log( log(x) ) where if x<delta, x = delta and if 1delta < x, x = 1delta. | def ilog(x,delta):
if(delta < x and x < 1.0 - delta):
return np.log( -np.log(x) )
elif(x < delta):
return np.log( -np.log(delta) )
else:
return np.log( -np.log(1.0 - delta) ) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logit(x: torch.Tensor, eps=1e-5) -> torch.Tensor:\n x = torch.clamp(x, eps, 1.0 - eps)\n return torch.log(x / (1.0 - x))",
"def safelog(x):\n #return np.log(x)\n return np.log(np.clip(x,floor,np.inf))",
"def diff_log(x):\n \n return np.diff(np.log(x)),np.log(x)[0]",
"def diff_log(x):\n\n ... | [
"0.72744215",
"0.7240807",
"0.7214393",
"0.72042274",
"0.716658",
"0.711701",
"0.6767486",
"0.6693635",
"0.6662013",
"0.6657874",
"0.66419184",
"0.66316617",
"0.66109407",
"0.6556733",
"0.6541151",
"0.65251803",
"0.6519674",
"0.6498009",
"0.645293",
"0.6449499",
"0.64343315",... | 0.8147607 | 0 |
Create a 3D rotation matrix for rotation about xaxis. (1 0 0 ) R(theta) = (0 cos(x) sin(x)) (0 sin(x) cos(x)) | def rotation3Dx(theta):
rmat = np.zeros((3,3))
rmat[0,0], rmat[0,1], rmat[0,2] = 1.0, 0.0, 0.0
rmat[1,0], rmat[1,1], rmat[1,2] = 0.0, np.cos(theta), np.sin(theta)
rmat[2,0], rmat[2,1], rmat[2,2] = 0.0, -np.sin(theta), np.cos(theta)
return rmat | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def matrix_rotate_3d_x(deg: float) -> np.matrix:\n from numpy import cos, sin, pi\n rad_x = -deg * pi/180\n c_x = cos(rad_x)\n s_x = sin(rad_x)\n return np.matrix([[1, 0, 0], [0, c_x, -s_x], [0, s_x, c_x]])",
"def rotation3D_x(angle: float) -> np.array:\n c = np.cos(angle)\n s = np.sin(angle... | [
"0.80429703",
"0.77990216",
"0.77074045",
"0.76701725",
"0.7432882",
"0.7401681",
"0.73251915",
"0.7267913",
"0.71938413",
"0.71556383",
"0.70411855",
"0.7036028",
"0.70312065",
"0.7028589",
"0.7012928",
"0.69417447",
"0.692393",
"0.68872285",
"0.6844814",
"0.6838681",
"0.680... | 0.78315115 | 1 |
Create a 3D rotation matrix for rotation about yaxis. ( cos(x) 0 sin(x)) R(theta) = ( 0 1 0 ) ( sin(x) 0 cos(x)) | def rotation3Dy(theta):
rmat = np.zeros((3,3))
rmat[0,0], rmat[0,1], rmat[0,2] = np.cos(theta), 0.0, -np.sin(theta)
rmat[1,0], rmat[1,1], rmat[1,2] = 0.0, 1.0, 0.0
rmat[2,0], rmat[2,1], rmat[2,2] = np.sin(theta), 0.0, np.cos(theta)
return rmat | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def matrix_rotate_3d_y(deg: float) -> np.matrix:\n from numpy import cos, sin, pi\n rad_y = -deg * pi/180\n c_y = cos(rad_y)\n s_y = sin(rad_y)\n return np.matrix([[c_y, 0, s_y], [0, 1, 0], [-s_y, 0, c_y]])",
"def rotation3Dz(theta):\n rmat = np.zeros((3,3))\n rmat[0,0] = rmat[1,1] = np.cos(... | [
"0.7846392",
"0.7652564",
"0.75773746",
"0.72624236",
"0.72098386",
"0.71632046",
"0.711217",
"0.707963",
"0.7057155",
"0.70560473",
"0.701651",
"0.6999073",
"0.6945559",
"0.69309556",
"0.68679565",
"0.6837997",
"0.68178195",
"0.6785411",
"0.6732221",
"0.67160934",
"0.6714742... | 0.751571 | 3 |
Create a 3D rotation matrix for rotation about zaxis. ( cos(x) sin(x) 0) R(theta) = (sin(x) cos(x) 0) ( 0 0 1) | def rotation3Dz(theta):
rmat = np.zeros((3,3))
rmat[0,0] = rmat[1,1] = np.cos(theta)
rmat[0,1] = np.sin(theta)
rmat[1,0] = -rmat[0,1]
rmat[2,2] = 1
return rmat | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def matrix_rotate_3d_z(deg: float) -> np.matrix:\n from numpy import cos, sin, pi\n rad_z = -deg * pi/180\n c_z = cos(rad_z)\n s_z = sin(rad_z)\n return np.matrix([[c_z, -s_z, 0], [s_z, c_z, 0], [0, 0, 1]])",
"def rotation3D_z(angle: float) -> np.array:\n c = np.cos(angle)\n s = np.sin(angle... | [
"0.8186974",
"0.802003",
"0.7951418",
"0.76159006",
"0.75433534",
"0.74739504",
"0.7473712",
"0.7445926",
"0.7439543",
"0.74234265",
"0.736115",
"0.7298137",
"0.7291585",
"0.72050965",
"0.7194949",
"0.7179259",
"0.71736616",
"0.71396255",
"0.71220154",
"0.71090776",
"0.709833... | 0.84704345 | 0 |
Return angle between two vectors in R^3, in radians | def angle(x, y, deg=False):
rad_angle = np.arccos(np.dot(x, y)/ (norm(x)*norm(y)))
if deg:
return rad_angle*(180.0/np.pi)
else:
return rad_angle | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def angle(v1: Vector, v2: Vector) -> float:\n return math.degrees(math.acos((v1 * v2) / (v1.length() * v2.length())))",
"def vec_angle_rad(v1,v2):\r\n \r\n c = np.dot(v1,v2)/(vector_len(v2)* vector_len(v2))\r\n return math.acos(c)",
"def angle_between_vectors(a, b):\n return math.acos(dot_produc... | [
"0.84158295",
"0.8327667",
"0.82317805",
"0.816077",
"0.8124094",
"0.8080465",
"0.8073348",
"0.80499214",
"0.791963",
"0.7917364",
"0.78978354",
"0.78865665",
"0.7873176",
"0.7855662",
"0.7855398",
"0.7853263",
"0.7845532",
"0.7814118",
"0.7813398",
"0.778545",
"0.7780554",
... | 0.0 | -1 |
Compute the geodesic distance on the sphere for two points. The points are assumed to lie on the surface of the same sphere. | def spherical_distances(x, y):
# Compute the norms of all points, we do NOT check they actually all lie on
# the same sphere (that's the caller's responsibility).
xn = np.sqrt((x**2).sum(axis=1))
yn = np.sqrt((y**2).sum(axis=1))
ang_cos = np.dot(x, y.T)/(xn[:, None]*yn[None, :])
# Protect against numerical noise giving us cosine values outside the -1,1
# range, where arccos would return nans.
ang_cos = np.clip(ang_cos, -1, 1)
return xn[:, None]*np.arccos(ang_cos) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def distance_sphere(self, other):\n if not self.crs == getattr(other, \"crs\", \"EPSG:4326\") == \"EPSG:4326\":\n raise ValueError(\"Only can calculate spherical distance with 'EPSG:4326' crs.\")\n return _binary_op(arctern.ST_DistanceSphere, self, other)",
"def distance_on_sphere(lat1, ... | [
"0.7638325",
"0.70502967",
"0.6934199",
"0.6927222",
"0.6903243",
"0.6792316",
"0.6787839",
"0.6785977",
"0.6757207",
"0.6749283",
"0.6746814",
"0.6737798",
"0.6729415",
"0.6711453",
"0.66890496",
"0.66774637",
"0.664188",
"0.6629779",
"0.6612115",
"0.66114235",
"0.66067094",... | 0.7146757 | 1 |
Estimate the bandwith ie the radius to use with an RBF kernel in the MeanShift algorithm | def estimate_bandwidth(X, quantile=0.3):
distances = spherical_distances(X, X)
distances = np.triu(distances, 1)
distances_sorted = np.sort(distances[distances > 0])
bandwidth = distances_sorted[np.floor(quantile * len(distances_sorted))]
return bandwidth | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _kernel(self, bw, X, x):\n return (1.0 / np.sqrt(2 * np.pi) / bw) * np.exp(\n -((X - x) ** 2) / (bw ** 2 * 2.0)\n )",
"def R(self):\n\t\treturn (arange(self.rbins) + 0.5) * (self.cbins - 0.5) / self.rbins",
"def get_bollinger_bands(rm, rstd):\n \n upper_band=rm+2*rstd\n low... | [
"0.6161731",
"0.61592114",
"0.6056328",
"0.59708244",
"0.5914149",
"0.5861118",
"0.58004457",
"0.5719034",
"0.57188016",
"0.57011205",
"0.5696227",
"0.5671052",
"0.56710136",
"0.5659563",
"0.56463724",
"0.56430066",
"0.5637317",
"0.5626428",
"0.56258416",
"0.5621374",
"0.5596... | 0.0 | -1 |
Perform MeanShift Clustering of data using a flat kernel | def mean_shift(X, bandwidth=None):
if bandwidth is None:
bandwidth = estimate_bandwidth(X)
n_points, n_features = X.shape
n_clusters = 0
bandwidth_squared = bandwidth**2
points_idx_init = np.arange(n_points)
stop_thresh = 1e-3*bandwidth # when mean has converged
cluster_centers = [] # center of clusters
# track if a points been seen already
been_visited_flag = np.zeros(n_points, dtype=np.bool)
# number of points to possibly use as initilization points
n_points_init = n_points
# used to resolve conflicts on cluster membership
cluster_votes = []
random_state = np.random.RandomState(0)
while n_points_init:
# pick a random seed point
tmp_index = random_state.randint(n_points_init)
# use this point as start of mean
start_idx = points_idx_init[tmp_index]
my_mean = X[start_idx, :] # intilize mean to this points location
# points that will get added to this cluster
my_members = np.zeros(n_points, dtype=np.bool)
# used to resolve conflicts on cluster membership
this_cluster_votes = np.zeros(n_points, dtype=np.uint16)
while True: # loop until convergence
# dist squared from mean to all points still active
# FIXME - this needs to be converted to spherical distances.
sqrt_dist_to_all = np.sum((my_mean - X)**2, axis=1)
# points within bandwidth
in_idx = sqrt_dist_to_all < bandwidth_squared
# add a vote for all the in points belonging to this cluster
this_cluster_votes[in_idx] += 1
my_old_mean = my_mean # save the old mean
my_mean = np.mean(X[in_idx, :], axis=0) # compute the new mean
# add any point within bandwidth to the cluster
my_members = np.logical_or(my_members, in_idx)
# mark that these points have been visited
been_visited_flag[my_members] = True
if np.linalg.norm(my_mean-my_old_mean) < stop_thresh:
# check for merge possibilities
merge_with = -1
for c in range(n_clusters):
# distance from possible new clust max to old clust max
dist_to_other = np.linalg.norm(my_mean -
cluster_centers[c])
# if its within bandwidth/2 merge new and old
if dist_to_other < bandwidth/2:
merge_with = c
break
if merge_with >= 0: # something to merge
# record the max as the mean of the two merged
# (I know biased twoards new ones)
cluster_centers[merge_with] = 0.5 * (my_mean+
cluster_centers[merge_with])
# add these votes to the merged cluster
cluster_votes[merge_with] += this_cluster_votes
else: # its a new cluster
n_clusters += 1 # increment clusters
cluster_centers.append(my_mean) # record the mean
cluster_votes.append(this_cluster_votes)
break
# we can initialize with any of the points not yet visited
points_idx_init = np.where(been_visited_flag == False)[0]
n_points_init = points_idx_init.size # number of active points in set
# a point belongs to the cluster with the most votes
labels = np.argmax(cluster_votes, axis=0)
return cluster_centers, labels | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cluster_meanshift(self, data, bandwidth=None, bin_seeding=False):\n if bandwidth is None:\n bandwidth = cl.estimate_bandwidth(data)\n\n ms = cl.MeanShift(bandwidth=bandwidth, bin_seeding=bin_seeding)\n ms.fit(data)\n\n labels = ms.labels_\n\n return labels, [np.nan... | [
"0.6720604",
"0.6584007",
"0.6550382",
"0.64145166",
"0.6413286",
"0.627287",
"0.6238827",
"0.61965424",
"0.61758494",
"0.6154797",
"0.6143025",
"0.6117063",
"0.6048166",
"0.6015218",
"0.6009818",
"0.6004305",
"0.5915785",
"0.59050244",
"0.5881358",
"0.58780664",
"0.5875312",... | 0.62292767 | 7 |
References 'Distributing many points on a sphere' by E.B. Saff and A.B.J. Kuijlaars, Mathematical Intelligencer, 19.1 (1997), pp. 511 | def saff_kuijlaars(N):
k = np.arange(N)
h = -1 + 2.0 * k / (N - 1)
theta = np.arccos(h)
phi = np.zeros_like(h)
for i in range(1, N - 1):
phi[i] = (phi[i - 1] + 3.6 / np.sqrt(N * (1 - h[i]**2))) % (2.0 * np.pi)
return sph2car(np.ones_like(theta), theta, phi) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sphere(indiv):\n return sum([ x ** 2 for x in indiv])",
"def sphere(self, x):\r\n # return np.random.rand(1)[0]**0 * sum(x**2) + 1 * np.random.rand(1)[0]\r\n return sum((x+0)**2)",
"def partsphere(self, x):\r\n self.counter += 1\r\n # return np.random.rand(1)[0]**0 * sum(x**2... | [
"0.7038946",
"0.6950157",
"0.69140077",
"0.68093324",
"0.66389656",
"0.6611303",
"0.6572137",
"0.648919",
"0.6481571",
"0.6474984",
"0.64451575",
"0.64319617",
"0.6428179",
"0.64160025",
"0.640967",
"0.6393354",
"0.6356308",
"0.633187",
"0.62893623",
"0.62585074",
"0.6178017"... | 0.0 | -1 |
Convert spherical coordinates to Cartesian coordinates. | def sph2car(r, theta, phi):
x = r * np.sin(theta) * np.cos(phi)
y = r * np.sin(theta) * np.sin(phi)
z = r * np.cos(theta)
return x, y, z | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def SphericalToCartesian(Spherical):\n\n # r,theta,phi -> x,y,z\n r = Spherical[:,0]\n st = np.sin(Spherical[:,1])\n sp = np.sin(Spherical[:,2])\n ct = np.cos(Spherical[:,1])\n cp = np.cos(Spherical[:,2])\n x = r*st*cp\n y = r*st*sp\n z = r*ct\n\n if (len(Spherical[0,:])==3):\n ... | [
"0.79381543",
"0.77366406",
"0.77325046",
"0.76741",
"0.7667967",
"0.76263297",
"0.7475714",
"0.7456057",
"0.7433543",
"0.7418165",
"0.7412523",
"0.736814",
"0.7343558",
"0.73400825",
"0.73142827",
"0.7298736",
"0.7206924",
"0.7128369",
"0.707744",
"0.6962617",
"0.6935745",
... | 0.5963385 | 91 |
Sample the pODF using a rejection technique. | def sample_pODF(nsamples,qpoints,coefs,N):
points = np.zeros((nsamples,4))
#Maximum of pODF
C = ( (N + 1.0)**2 / (4.0 * np.pi) ) * coefs.sum()
number_of_samples = 0
while number_of_samples < nsamples:
#Random sample on the sphere
rphi = np.random.uniform( 0.0, 2.0*np.pi)
rmu = np.random.uniform(-1.0, 1.0)
rsin_theta = np.sqrt(1.0 - rmu**2)
x,y,z = rsin_theta * np.cos(rphi), rsin_theta * np.sin(rphi), rmu
f = np.abs(even_pODF(np.array([x,y,z]),qpoints,coefs,N))
#Uniform random used for rejection
rho = np.random.uniform(0.0, 1.0)
if C*rho < f:
#Accept random point
points[number_of_samples,:] = np.array([x,y,z,f/C])
number_of_samples += 1
return points | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_does_not_sample_twice_ppswor(self):\n with self.assertRaises(ValueError):\n s = private_sampling.ThresholdSample(\n 1.0, private_sampling.PpsworSamplingMethod)\n s.process(\"a\", math.log(FAILURE_PROBABILITY_INVERSE, math.e))\n s.process(\"a\", 1)",
"def rejection_sample(self,... | [
"0.6341869",
"0.6320421",
"0.6018086",
"0.5842575",
"0.58349407",
"0.57898366",
"0.57707685",
"0.5673086",
"0.5649213",
"0.56451184",
"0.562531",
"0.5600256",
"0.55618894",
"0.55617553",
"0.5559686",
"0.5514322",
"0.55063957",
"0.5383353",
"0.5362512",
"0.53615665",
"0.531038... | 0.577311 | 6 |
Compute a similarity matrix for a set of points. The points are assumed to lie on the surface of the same sphere. | def similarity_matrix(points, sigma):
distances_squared = spherical_distances(points, points)**2
return np.exp( -distances_squared / (2.0 * sigma) ) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def self_similarity_matrix(feature_vectors):\n norm_feature_vectors, mean, std = at.normalize_features([feature_vectors.T])\n norm_feature_vectors = norm_feature_vectors[0].T\n sim_matrix = 1.0 - distance.squareform(\n distance.pdist(norm_feature_vectors.T, 'cosine'))\n return sim_matrix",
"de... | [
"0.66129136",
"0.63335097",
"0.62122184",
"0.6183862",
"0.60915583",
"0.60669845",
"0.59568816",
"0.5932109",
"0.5899266",
"0.588513",
"0.5874931",
"0.5850991",
"0.5815165",
"0.5814901",
"0.58031887",
"0.5772447",
"0.5766222",
"0.5751658",
"0.57376456",
"0.5730853",
"0.571602... | 0.7539285 | 0 |
Compute a graph Laplacian for a set of points. The points are assumed to lie on the surface of the same sphere. | def laplacian(points, sigma):
S = similarity_matrix(points, sigma)
(npnts,npnts) = S.shape
D = np.zeros_like(S)
for i in range(npnts):
#D[i,i] = 1.0 / np.sqrt(S[i,:].sum())
D[i,i] = S[i,:].sum()
return (D - S) #(np.eye(npnts,npnts) - np.dot(D,np.dot(S,D))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def laplacian(self, point):\n n_vertices, n_faces = point.shape[-2], self.faces.shape[0]\n vertex_0, vertex_1, vertex_2 = self._vertices(point)\n len_edge_12 = gs.linalg.norm((vertex_1 - vertex_2), axis=-1)\n len_edge_02 = gs.linalg.norm((vertex_0 - vertex_2), axis=-1)\n len_edge... | [
"0.6669824",
"0.62479734",
"0.6143647",
"0.60507256",
"0.60478675",
"0.5883016",
"0.58383894",
"0.5776216",
"0.5732057",
"0.56500006",
"0.5618606",
"0.5549746",
"0.5351798",
"0.5340996",
"0.5318419",
"0.53017426",
"0.52880955",
"0.5279453",
"0.5237156",
"0.52357775",
"0.52184... | 0.6151292 | 2 |
Decorator to help verify that a function was actually executed. Annotates a function with an attribute 'didrun', and only sets it to True if the function is actually called. | def checkrun(f):
@functools.wraps(f)
def wrapper(*args, **kwargs):
wrapper.didrun = True
return f(*args, **kwargs)
wrapper.didrun = False
return wrapper | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_called(self, func):\n self.called[func] = False\n def _check(*args, **kwargs):\n self.called[func] = True\n return func(*args, **kwargs)\n return _check",
"def run_once(func):\n @wraps(func)\n def wrapper(*args, **kwargs):\n if not wrapper.has_run... | [
"0.65756035",
"0.6015735",
"0.60046905",
"0.5997352",
"0.59535944",
"0.5899848",
"0.5813919",
"0.57161885",
"0.5611487",
"0.55894804",
"0.5569097",
"0.556421",
"0.55513084",
"0.55510217",
"0.55382",
"0.5538129",
"0.55316585",
"0.5526899",
"0.55099505",
"0.5504471",
"0.5504471... | 0.8174126 | 0 |
Developers can define their own workflow classes in external python packages, in which case the workflowname must be specified as a fullyqualified class name. | def test_workflow_class_discovery():
config = {
"workflow-name": "tests.workflows.test_workflow.CustomWorkflow",
"cluster-type": CLUSTER_TYPE
}
template_dir = tempfile.mkdtemp(suffix="test-workflow-discovery-template")
with open(f"{template_dir}/workflow.yaml", 'w') as f:
yaml.dump(config, f)
_execution_dir, workflow = launch_flow(template_dir, 1)
assert isinstance(workflow, CustomWorkflow)
assert workflow.execute.didrun | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def import_workflow_class(workflow_name):\n try:\n module_name = \"workflow.\" + workflow_name\n importlib.import_module(module_name)\n return True\n except ImportError:\n return False",
"def get_workflow_object(\n workflow_name, settings, logger, client, token, decision, max... | [
"0.7437935",
"0.66066194",
"0.6272784",
"0.62531227",
"0.5922669",
"0.59157443",
"0.58219445",
"0.5800828",
"0.57692146",
"0.5733996",
"0.5662112",
"0.56386393",
"0.55851597",
"0.5581028",
"0.5571103",
"0.55317545",
"0.55233943",
"0.5494293",
"0.5466347",
"0.54425746",
"0.543... | 0.6346265 | 2 |
Users can specify environment variables in their config file which will be set in the driver and worker environments. Make sure those variables are set during the workflow, but not after. | def test_workflow_environment():
config = {
"workflow-name": "workflow",
"cluster-type": CLUSTER_TYPE,
"environment-variables": {
"FOO": "BAR",
"FOO2": "BAR2"
}
}
template_dir = tempfile.mkdtemp(suffix="test-workflow-environment-template")
with open(f"{template_dir}/workflow.yaml", 'w') as f:
yaml.dump(config, f)
@checkrun
def execute(workflow_inst):
def _check():
assert os.environ['FOO'] == "BAR"
assert os.environ["OMP_NUM_THREADS"] == '1'
return True
# driver env
_check()
# worker env
assert all(workflow_inst.run_on_each_worker(_check).values())
os.environ['FOO'] = 'ORIGINAL_FOO'
_execution_dir, _workflow = launch_flow(template_dir, 1, _custom_execute_fn=execute)
assert execute.didrun
# Environment is restored after execution is finished.
assert os.environ['FOO'] == 'ORIGINAL_FOO'
assert 'FOO2' not in os.environ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def env_config():\n # setup\n env = {'ELB_GCP_PROJECT': 'expected-gcp-project',\n 'ELB_GCP_REGION': 'expected-gcp-region',\n 'ELB_GCP_ZONE': 'expected-gcp-zone',\n 'ELB_BATCH_LEN': '93',\n 'ELB_CLUSTER_NAME': 'expected-cluster-name',\n 'ELB_RESULTS': 'gs://ex... | [
"0.70271873",
"0.7026732",
"0.69392926",
"0.69331855",
"0.68138427",
"0.6760369",
"0.6758569",
"0.6714527",
"0.67041445",
"0.66552407",
"0.65845776",
"0.65845776",
"0.65845776",
"0.65845776",
"0.65845776",
"0.65845776",
"0.6584399",
"0.65421516",
"0.6530069",
"0.6528909",
"0.... | 0.7265635 | 0 |
The config can specify a resource manager server address as "driver", which means the workflow should launch the resource manager on the scheduler machine. Make sure it launches, but is also shut down after the workflow exits. | def test_resource_manager_on_driver():
config = {
"workflow-name": "workflow",
"cluster-type": CLUSTER_TYPE,
"resource-manager": {
"server": "driver",
"port": 4000,
"config": {
"read_reqs": 123,
"read_data": 456,
"write_reqs": 789,
"write_data": 321
}
}
}
template_dir = tempfile.mkdtemp(suffix="test-resource-manager-on-driver-template")
with open(f"{template_dir}/workflow.yaml", 'w') as f:
yaml.dump(config, f)
@checkrun
def execute(workflow_inst):
client = ResourceManagerClient('127.0.0.1', 4000)
mgr_config = client.read_config()
assert mgr_config == config["resource-manager"]["config"], \
"Resource manager config does not match the one in the workflow config"
_execution_dir, _workflow = launch_flow(template_dir, 1, _custom_execute_fn=execute)
assert execute.didrun
# FIXME: For mysterious reasons, the check below does not work on Travis-CI.
# Somehow, read_config() succeeds despite the fact that
# the resource manager server was already terminated??
if os.environ.get('TRAVIS', '') == 'true':
pytest.skip("Skipping resource manager shutdown check on Travis-CI")
# Server should not be running any more after workflow exits.
with pytest.raises(TimeoutError):
client2 = ResourceManagerClient('127.0.0.1', 4000)
client2.read_config() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def launch(config):\n \n launch_with_configs([config])",
"def run_xenon_simple(workflow, machine, worker_config):\n scheduler = Scheduler()\n\n return scheduler.run(\n xenon_interactive_worker(machine, worker_config),\n get_workflow(workflow)\n )",
"def test_set_power_schedule_for_de... | [
"0.59481937",
"0.5393874",
"0.5334805",
"0.53214973",
"0.52877617",
"0.5262214",
"0.52576655",
"0.52325445",
"0.51960254",
"0.5173219",
"0.51681364",
"0.5132155",
"0.51199645",
"0.5117904",
"0.5104992",
"0.5102506",
"0.5085037",
"0.5080357",
"0.50710267",
"0.5063733",
"0.5049... | 0.67965436 | 0 |
Setup for test_worker_initialization(), below. Parameterized for the "oncepermachine' case (and its opposite). | def setup_worker_initialization_template(request):
once_per_machine = request.param
template_dir = tempfile.mkdtemp(suffix="test-worker-initialization")
worker_script = f"{template_dir}/do-nothing.sh"
with open(worker_script, 'w') as f:
f.write("#!/bin/bash\n")
f.write("sleep 10")
os.chmod(worker_script, 0o777)
config = {
"workflow-name": "workflow",
"cluster-type": CLUSTER_TYPE,
"worker-initialization": {
"script-path": "do-nothing.sh",
"only-once-per-machine": once_per_machine,
"script-args": ["_TEST_SCRIPT_FAKE_ARG_"], # This is just here to make it easy to identify the process
"launch-delay": 0
}
}
with open(f"{template_dir}/workflow.yaml", 'w') as f:
yaml.dump(config, f)
return template_dir, config, once_per_machine | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_worker_initialization(setup_worker_initialization_template):\n template_dir, _config, once_per_machine = setup_worker_initialization_template\n \n num_workers = 2\n if once_per_machine or CLUSTER_TYPE in (\"synchronous\", \"processes\"):\n expected_script_count = 1\n else:\n e... | [
"0.7411761",
"0.71275353",
"0.6863804",
"0.68591213",
"0.68004584",
"0.67204416",
"0.66945666",
"0.66871023",
"0.66871023",
"0.6637621",
"0.6634074",
"0.657743",
"0.6510289",
"0.6509755",
"0.6507559",
"0.6495748",
"0.6495748",
"0.64917386",
"0.6455389",
"0.64043945",
"0.63973... | 0.6802044 | 4 |
The config can specify a script to be run on each worker upon cluster initialization. This test verifies that it is launched and active while the workflow runs, and that it is launched on each worker, or just once per machine, depending on the config. | def test_worker_initialization(setup_worker_initialization_template):
template_dir, _config, once_per_machine = setup_worker_initialization_template
num_workers = 2
if once_per_machine or CLUSTER_TYPE in ("synchronous", "processes"):
expected_script_count = 1
else:
expected_script_count = num_workers
@checkrun
def execute(workflow_inst):
script_dir = Path(workflow_inst.config['worker-initialization']['script-path']).parent
script_count = len(find_processes('_TEST_SCRIPT_FAKE_ARG_'))
assert script_count > 0, f"Worker script is not running. Check logs in:\n{script_dir}"
assert script_count <= expected_script_count, f"Worker script started too many times. Check logs in:\n{script_dir}"
assert script_count == expected_script_count, f"Worker script not started on all workers. Check logs in:\n{script_dir}"
_execution_dir, workflow_inst = launch_flow(template_dir, num_workers, _custom_execute_fn=execute)
script_dir = Path(workflow_inst.config['worker-initialization']['script-path']).parent
script_count = len(find_processes('_TEST_SCRIPT_FAKE_ARG_'))
assert script_count == 0, \
("Worker script(s) remained running after the workflow exited."\
f"Check logs in:\n{script_dir}") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_cluster_jobs_script(self):\r\n\r\n qiime_config = load_qiime_config()\r\n submit_script = qiime_config['cluster_jobs_fp']\r\n\r\n if (submit_script):\r\n full_path = which(submit_script)\r\n if full_path:\r\n submit_script = full_path\r\n ... | [
"0.6706494",
"0.6451912",
"0.62901366",
"0.6208054",
"0.6111138",
"0.59998226",
"0.59990007",
"0.59590906",
"0.5952131",
"0.5922806",
"0.5853597",
"0.579472",
"0.57890517",
"0.57299614",
"0.5724651",
"0.5720135",
"0.57154197",
"0.57125825",
"0.5700395",
"0.5678336",
"0.567510... | 0.70054567 | 0 |
You can provide an initialization script for each worker to call before the workflow starts. The most common usecase for such a script is to launch a local dvid server on each worker (for posting in parallel to the cloud). We provide the necessary script for local dvid workers outofthebox, in scripts/workerdvid. This test verifies that it works. | def test_worker_dvid_initialization():
repo_dir = Path(flyemflows.__file__).parent.parent
template_dir = tempfile.mkdtemp(suffix="test-worker-dvid")
# Copy worker script/config into the template
shutil.copy(f'{repo_dir}/scripts/worker-dvid/dvid.toml',
f'{template_dir}/dvid.toml')
shutil.copy(f'{repo_dir}/scripts/worker-dvid/launch-worker-dvid.sh',
f'{template_dir}/launch-worker-dvid.sh')
config = {
"workflow-name": "workflow",
"cluster-type": CLUSTER_TYPE,
"worker-initialization": {
"script-path": "launch-worker-dvid.sh",
"only-once-per-machine": True,
"script-args": ["_TEST_SCRIPT_FAKE_ARG_"], # This is just here to make it easy to identify the process
"launch-delay": 1.0
}
}
with open(f"{template_dir}/workflow.yaml", 'w') as f:
yaml.dump(config, f)
def is_worker_dvid_running():
return len(find_processes('_TEST_SCRIPT_FAKE_ARG_')) > 0
@checkrun
def execute(workflow_inst):
script_dir = Path(workflow_inst.config['worker-initialization']['script-path']).parent
assert is_worker_dvid_running(), f"Worker DVID is not running. Check logs in:\n{script_dir}"
_execution_dir, workflow_inst = launch_flow(template_dir, 1, _custom_execute_fn=execute)
script_dir = Path(workflow_inst.config['worker-initialization']['script-path']).parent
assert not is_worker_dvid_running(), \
("Worker DVID remained running after the workflow exited."\
f"Check logs in:\n{script_dir}") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_worker_initialization(setup_worker_initialization_template):\n template_dir, _config, once_per_machine = setup_worker_initialization_template\n \n num_workers = 2\n if once_per_machine or CLUSTER_TYPE in (\"synchronous\", \"processes\"):\n expected_script_count = 1\n else:\n e... | [
"0.7326153",
"0.70049655",
"0.6345922",
"0.6308314",
"0.6258606",
"0.6253948",
"0.6138363",
"0.6117165",
"0.61046404",
"0.60405153",
"0.6030067",
"0.6017148",
"0.6017148",
"0.60138994",
"0.5929832",
"0.5922357",
"0.5922357",
"0.5841495",
"0.5836372",
"0.5836372",
"0.5832595",... | 0.7815065 | 0 |
Return the next power of 10 | def nextpow10(n):
if n == 0:
return 0
else:
return math.ceil(math.log10(abs(n))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def next_pow_two(n):\n i = 1\n while i < n:\n i = i << 1\n return i",
"def _next_power_of_two(self, n):\n if n == 0:\n return 1\n return int(2 ** math.ceil(math.log2(n)))",
"def next_power2(num):\n return 2 ** int(np.ceil(np.log2(num)))",
"def next_power_2(x: int) -> int:\n r... | [
"0.7424253",
"0.73961514",
"0.7280163",
"0.7175434",
"0.713948",
"0.71352744",
"0.69893503",
"0.6905554",
"0.68357366",
"0.67452294",
"0.6701021",
"0.6685439",
"0.6657409",
"0.6649841",
"0.66056854",
"0.658991",
"0.6583599",
"0.656067",
"0.6541835",
"0.6518142",
"0.6472119",
... | 0.8007733 | 0 |
Return a number that looks 'nice', with a maximum error | def magicnr(value, error):
magics = [ (10 ** (nextpow10(error))),
(10 ** (nextpow10(error))) / 2.0,
(10 ** (nextpow10(error))) / 4.0,
(10 ** (nextpow10(error))) / 10.0,
(10 ** (nextpow10(error))) / 20.0,
(10 ** (nextpow10(error))) / 40.0,
(10 ** (nextpow10(error))) / 100.0,
]
magics.sort()
magics.reverse()
magic = magics[-1]
for n in magics:
if n < abs(value):
magic = n
break
return fround(value, magic) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_precision(err):\n return max(0, int(-math.log10(2 * err)) + 1)",
"def computeGoodMax(totalTimes, noerrs):\n # Could allow a small amount of space above the top, but it's annnoying for percentages!\n # return None\n factor = 1.00\n maxReading = factor * max(\n [max([v for v in l if ... | [
"0.684441",
"0.6396268",
"0.620864",
"0.6083352",
"0.6061179",
"0.6019383",
"0.601921",
"0.5970972",
"0.5961703",
"0.59382796",
"0.5932441",
"0.592237",
"0.5899084",
"0.5895729",
"0.58700436",
"0.58562726",
"0.5854558",
"0.58429986",
"0.58234286",
"0.5815658",
"0.58116823",
... | 0.66190135 | 1 |
Get the path to a CSV by name. | def _get_csv_path(name):
return os.path.join(cwd, 'output/app_info', name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def csv_path(name):\n return \"./data/%s\" % name",
"def csv_dir(self):\n return op.join(self.root_dir, 'csv')",
"def get_cached_csv(self, category: str) -> str:\n csv_path = f\"{self.csv_dir}/{category.lower()}.csv\"\n if path.exists(csv_path):\n return csv_path\n rai... | [
"0.82250005",
"0.64448506",
"0.6438859",
"0.638522",
"0.635775",
"0.62658775",
"0.6196743",
"0.60490125",
"0.60278124",
"0.5936994",
"0.59059805",
"0.58804125",
"0.58804125",
"0.58078647",
"0.5763088",
"0.5756751",
"0.5756751",
"0.5756751",
"0.5755957",
"0.57534754",
"0.57398... | 0.7574934 | 1 |
Turns the CSV into a workable dictionary. | def _csv_to_dict(name):
csv_path = _get_csv_path(name)
result = []
with open(csv_path) as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
result.append(row)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def csv_to_dict(self):\n log = logger.configure(\"default\")\n try: \n df = pd.read_csv(self.__csv_path)\n except IOError as e:\n # file not found\n log.error('Could not import {}. Got error {}'.format(self.__csv_path, e))\n raise \n else:\n ... | [
"0.773511",
"0.75966036",
"0.7308401",
"0.7227723",
"0.7156224",
"0.7100157",
"0.70313346",
"0.6998957",
"0.69969165",
"0.69475853",
"0.69401574",
"0.6889729",
"0.6880265",
"0.68693936",
"0.6866036",
"0.68612945",
"0.68607634",
"0.6772458",
"0.6684127",
"0.6684127",
"0.660402... | 0.7150343 | 5 |
Get the app's name. | def _get_app_name(app):
return app[APP_NAME_KEY] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_name():\n return config.APP_NAME",
"def app_name(self) -> str:\n return self._app_name",
"def app_name(self):\n return self._app_name",
"def app_name(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"app_name\")",
"def get_app_name(self):\n return get... | [
"0.9113221",
"0.88275534",
"0.8791967",
"0.87901825",
"0.8730592",
"0.8585392",
"0.85836774",
"0.84330225",
"0.83433735",
"0.83433735",
"0.8274585",
"0.81731343",
"0.8169378",
"0.8116642",
"0.80174756",
"0.7825664",
"0.7809752",
"0.7760691",
"0.7760691",
"0.7760691",
"0.77606... | 0.88942343 | 1 |
Get the contact's first name. | def _get_contact_first_name(app):
name = app.get(CONTACT_NAME_KEY)
if name:
return ' {}'.format(name.split(' ')[0]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_first_name(self):\n return self._first_name",
"def get_first_name(self) -> str:\n return self.first_name",
"def first_name(self):\n return self._first_name",
"def first_name(self):\n return self._first_name",
"def first_name(self):\n return self._first_name",
"d... | [
"0.86260074",
"0.8617128",
"0.8315871",
"0.8315871",
"0.8315871",
"0.8312541",
"0.81962097",
"0.8183392",
"0.8183392",
"0.80284345",
"0.7993891",
"0.7896602",
"0.7896602",
"0.78449786",
"0.7739931",
"0.77090037",
"0.7706754",
"0.7706754",
"0.7706754",
"0.7706754",
"0.7706754"... | 0.8650525 | 0 |
Get the contacts email address. | def _get_contact_email(app):
return app[CONTACT_EMAIL_KEY] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_email(self):\n return self.reference[REF_EMAIL_ADDRESS][REF_VALUE]",
"def contact_email(self) -> str:\n return pulumi.get(self, \"contact_email\")",
"def get_contact_email():\n from shotglass2.shotglass import get_site_config\n \n site_config = get_site_config()\n \n to = N... | [
"0.83159286",
"0.8266356",
"0.7886328",
"0.7697728",
"0.75914663",
"0.7493357",
"0.7450327",
"0.73740244",
"0.73260653",
"0.7248775",
"0.7248775",
"0.7248775",
"0.72211725",
"0.72211725",
"0.72211725",
"0.72211725",
"0.71998024",
"0.71859884",
"0.7072096",
"0.70538586",
"0.70... | 0.7802634 | 3 |
Get the subject to send with the email. | def _get_email_subject(app_name):
return '{} <==> Tote'.format(app_name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def subject(self):\n return self.mail.get('Subject')",
"def getSubject(self):\r\n return self.msg[\"Subject\"]",
"def subject(self):\n return self.properties.get(\"subject\", None)",
"def get_subject(self):\n return self._subject",
"def subject(self):\n return self.get(\"subj... | [
"0.85039127",
"0.84494317",
"0.79497236",
"0.7938282",
"0.7885958",
"0.7774435",
"0.7774435",
"0.7769633",
"0.77543914",
"0.77393216",
"0.7721028",
"0.76066816",
"0.74656695",
"0.74626553",
"0.7323837",
"0.7316676",
"0.7280974",
"0.7280175",
"0.72613007",
"0.72613007",
"0.712... | 0.6934014 | 21 |
Get the email template name for the first contact email. | def _get_first_contact_email_template_name(app):
return app[FIRST_CONTACT_EMAIL_TEMPLATE_NAME_KEY] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_template_name(self):\n template = None\n if self.template:\n template = self.template\n if not template:\n for p in self.get_ancestors(ascending=True):\n if p.template:\n template = p.template\n break\n ... | [
"0.68836665",
"0.6812669",
"0.66186845",
"0.66120255",
"0.6575655",
"0.6516548",
"0.64882386",
"0.64112824",
"0.63238996",
"0.6301571",
"0.6288311",
"0.6213783",
"0.6116907",
"0.60900533",
"0.6080471",
"0.6079054",
"0.60654145",
"0.6055386",
"0.60473263",
"0.60457283",
"0.603... | 0.87440306 | 0 |
Gets the tote store url for this app. | def _get_app_tote_store_url(app):
return app[APP_TOTE_STORE_URL] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getNoteStoreUrl(self, authenticationToken):\r\n pass",
"def getNoteStoreUrl(self, authenticationToken):\r\n self.send_getNoteStoreUrl(authenticationToken)\r\n return self.recv_getNoteStoreUrl()",
"def get_store_path(cls):\n user_data_dir = cls.user_data_dir()\n store_path = os.path.j... | [
"0.6696655",
"0.64120066",
"0.6146364",
"0.5828228",
"0.57313335",
"0.5705295",
"0.56562585",
"0.5626252",
"0.5613728",
"0.5612579",
"0.5582851",
"0.555923",
"0.555923",
"0.5541939",
"0.5541939",
"0.5510885",
"0.55108297",
"0.5492612",
"0.5492612",
"0.5468174",
"0.54611695",
... | 0.84141535 | 0 |
Check if we already sent the first contact email. | def _did_send_first_contact_email(app):
first_contact = app[FIRST_CONTACT_EMAIL_SENT_KEY]
if first_contact and first_contact.lower() == 'y':
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def IsfirstAddContact(self):\n if search_text(contact.get_value('accounts'), isScrollable = 0, searchFlag = TEXT_CONTAINS):\n click_in_list_by_index(0)\n return True\n else:\n return False",
"def recent_email_sent(self):\n recent_contact_activity = self.activ... | [
"0.6324304",
"0.6179195",
"0.610429",
"0.59007627",
"0.58576906",
"0.5768399",
"0.5731466",
"0.57095504",
"0.5704638",
"0.56970215",
"0.5689795",
"0.566889",
"0.56208533",
"0.5612742",
"0.5604829",
"0.5577359",
"0.55763453",
"0.55086017",
"0.55008966",
"0.5475762",
"0.5462582... | 0.8393486 | 0 |
Prints a summary of the results. | def _print_summary(results):
if not len(results) > 0:
print 'No results to show in summary.'
return
table = {}
for res in results:
for k, v in res.iteritems():
table.setdefault(k, []).append(v)
print tabulate(table, headers='keys', tablefmt="simple") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def printSummary(self):\n pass",
"def print_summary(self):\n #outcomes = self.get_outcomes()\n #passes = 'Passes: %i' % sum(1 for outcome in outcomes if outcome == Result.PASS)\n #untested = 'Untested: %i' % sum(1 for outcome in outcomes if outcome == Result.UNTESTED)\n #er... | [
"0.82503015",
"0.8232667",
"0.79443955",
"0.76772296",
"0.7640588",
"0.74202365",
"0.7303483",
"0.72779363",
"0.7266571",
"0.7234515",
"0.7221001",
"0.7205003",
"0.7152706",
"0.7136578",
"0.7104214",
"0.709339",
"0.7073432",
"0.70705724",
"0.70628256",
"0.70268404",
"0.701721... | 0.8227009 | 2 |
Sends out emails to the apps in the provided csv. | def send(app_csv='apps.csv', verbose=True, dry_run=True):
results = []
app_info = _csv_to_dict(app_csv)
for app in app_info:
# Get all the app info needed for this request.
app_name = _get_app_name(app)
contact_first_name = _get_contact_first_name(app)
email_address = _get_contact_email(app)
app_tote_store_url = _get_app_tote_store_url(app)
subject = _get_email_subject(app_name)
# If we already sent the first contact email, continue.
if _did_send_first_contact_email(app):
result = dict(
app_name=app_name,
contact_first_name=contact_first_name,
email_address=email_address,
app_tote_store_url=app_tote_store_url,
subject=subject,
status='skipped',
error=None,
)
logger.info(result)
results.append(result)
continue
try:
# Get the appropriate template to send.
email_template = _get_first_contact_email_template_name(app)
template = env.get_template(email_template)
# Render the template with app info.
content = template.render(
app_name=app_name,
contact_first_name=contact_first_name,
app_tote_store_url=app_tote_store_url,
)
send_email(to=email_address, subject=subject, html=content, dry_run=dry_run)
result = dict(
app_name=app_name,
contact_first_name=contact_first_name,
email_address=email_address,
app_tote_store_url=app_tote_store_url,
subject=subject,
status='success',
error=None,
)
except Exception as e:
result = dict(
app_name=app_name,
contact_first_name=contact_first_name,
email_address=email_address,
app_tote_store_url=app_tote_store_url,
subject=subject,
status='failure',
error=str(e),
)
logger.info(result)
results.append(result)
# Sleep momentarily to avoid dos'ing the server.
if not dry_run:
time.sleep(0.1)
if verbose:
_print_summary(results) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_email_csv(csv_input):\n # Get a pandas dataframe column with all of the relevant duns numbers\n\n df = pd.read_csv(csv_input)\n duns_numbers = df.dunsnumber.tolist()\n\n # Gets the file number for the current file by taking the max of all of the other numbers in the lists directory and add... | [
"0.5723836",
"0.556769",
"0.5490822",
"0.54697037",
"0.54161894",
"0.5410227",
"0.5337697",
"0.53324795",
"0.5231842",
"0.52236265",
"0.5195237",
"0.5186955",
"0.51598907",
"0.51523805",
"0.5090487",
"0.508662",
"0.5077356",
"0.50331646",
"0.50279236",
"0.50225353",
"0.501493... | 0.7534394 | 0 |
First build the sum of divisors for all numbers and then look for nonabundants | def solver2(input_val):
sum_div = [1] * (input_val + 1)
for i in range(2, int(input_val ** 0.5) + 1):
sum_div[i * i] += i
for k in range(i + 1, input_val // i + 1):
sum_div[k * i] += k + i
abundants, result = set(), 0
for n in range(1, input_val + 1):
if sum_div[n] > n:
abundants.add(n)
if not any((n - a in abundants) for a in abundants):
result += n
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def non_abundant_sums():\n # the sum of divisors of every number\n divisor_sum = [0] * LIMIT\n for i in range(1, LIMIT):\n for j in range(i * 2, LIMIT, i):\n divisor_sum[j] += i\n # abundant numbers\n abundant_nums = [i for (i, x) in enumerate(divisor_sum) if x > i]\n\n expressi... | [
"0.71596134",
"0.6881637",
"0.6874127",
"0.68740165",
"0.6870829",
"0.6703803",
"0.66957605",
"0.66898984",
"0.6660096",
"0.66297686",
"0.6602979",
"0.65995604",
"0.6504165",
"0.64978504",
"0.6480131",
"0.6476575",
"0.6474925",
"0.6459346",
"0.64593166",
"0.6448392",
"0.63862... | 0.687742 | 2 |
Perform a string compression on the input string. | def string_compression(input_string):
compressed_string = ''
char_count = 1
prev_char = ''
for char in input_string:
if char == prev_char:
char_count += 1
else:
compressed_string = compressed_string + str(char_count) + char
char_count = 1
prev_char = char
return compressed_string[1:] + str(char_count) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compress(string):",
"def compress(string):",
"def compression(s):",
"def compress_zlib(self, string):\n #encode the input sting\n self.string = string.encode()\n return zlib.compress(self.string)",
"def compress(string):\n \n # Build the dictionary.\n dict_size = 256\n see... | [
"0.88319397",
"0.88319397",
"0.8700479",
"0.79835236",
"0.7687754",
"0.7666799",
"0.7238186",
"0.7213857",
"0.7115728",
"0.7022821",
"0.6945289",
"0.69063985",
"0.6815695",
"0.66225106",
"0.65985954",
"0.65551895",
"0.65420026",
"0.649725",
"0.6487858",
"0.6423921",
"0.641245... | 0.7696003 | 4 |
writes data from instream into additional allocated clusters of given file. Metadata of this file will be stored in Metadata object | def write(self, instream: typ.BinaryIO, filepath: str,
filename: str = None) -> None:
if filename is not None:
filename = path.basename(filename)
if self.fs_type == 'FAT':
allocator_metadata = self.fs.write(instream, filepath)
self.metadata.add_file(filename, allocator_metadata)
elif self.fs_type == 'NTFS':
allocator_metadata = self.fs.write(instream, filepath)
self.metadata.add_file(filename, allocator_metadata)
else:
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __write(self, storage):\n\n positions = storage.get_positions()\n if len(positions) == 0: return\n\n X = storage.get_X()\n Y = storage.get_Y()\n\n if Y: assert len(positions) == len(X) == len(Y)\n else: assert len(positions) == len(X)\n\n start, end = positions[... | [
"0.56617075",
"0.56513876",
"0.561701",
"0.55935436",
"0.5525497",
"0.5482356",
"0.54683065",
"0.54394776",
"0.5432194",
"0.5414132",
"0.5392",
"0.5390164",
"0.53824586",
"0.53770757",
"0.5337196",
"0.5310381",
"0.5272025",
"0.5262886",
"0.5257946",
"0.52343404",
"0.52302665"... | 0.60996723 | 0 |
writes hidden data from slackspace into stream. The examined slack space information is taken from metadata. | def read(self, outstream: typ.BinaryIO):
file_metadata = self.metadata.get_file("0")['metadata']
if self.fs_type == 'FAT':
allocator_metadata = FATAllocatorMeta(file_metadata)
self.fs.read(outstream, allocator_metadata)
elif self.fs_type == 'NTFS':
allocator_metadata = NTFSAllocatorMeta(file_metadata)
self.fs.read(outstream, allocator_metadata)
else:
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_hidden(file_name, data):\n # For *nix add a '.' prefix.\n prefix = '.' if os.name != 'nt' else ''\n file_name = prefix + file_name\n\n # Write file.\n with open(file_name, 'w') as f:\n f.write(data)\n\n # For windows set file attribute.\n if os.name == 'nt':\n ret = cty... | [
"0.51169866",
"0.50111604",
"0.4976669",
"0.4859597",
"0.4805777",
"0.4788097",
"0.46907136",
"0.4596308",
"0.45624852",
"0.4542059",
"0.45340312",
"0.45145792",
"0.45093474",
"0.45045894",
"0.4497126",
"0.4490438",
"0.44690353",
"0.44639584",
"0.44553003",
"0.44552484",
"0.4... | 0.0 | -1 |
reads hidden data from slack into files | def read_into_file(self, outfilepath: str):
if self.fs_type == 'FAT':
with open(outfilepath, 'wb+') as outfile:
self.read(outfile)
elif self.fs_type == 'NTFS':
with open(outfilepath, 'wb+') as outfile:
self.read(outfile)
else:
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_parsed_data():\n\n echonest_data_files = [f for f in os.listdir('.') if re.match(\"^echonest_[\\w]+.txt$\", f)]\n\n # Setting up header with user id and attributes\n header = ['user_id']\n header.extend(ATTRIBUTES)\n\n # printing header to standard out\n print \",\".join(header) \n\n # Processing ea... | [
"0.5406376",
"0.5285635",
"0.5277233",
"0.5269591",
"0.5216304",
"0.52033526",
"0.5198252",
"0.51780796",
"0.5176623",
"0.516422",
"0.5149858",
"0.51421016",
"0.5128155",
"0.5119425",
"0.510754",
"0.5094407",
"0.5070182",
"0.5065792",
"0.5031172",
"0.50137323",
"0.49910444",
... | 0.0 | -1 |
clears the slackspace of files. Information of them is stored in metadata. | def clear(self):
if self.fs_type == 'FAT':
for file_entry in self.metadata.get_files():
file_metadata = file_entry['metadata']
file_metadata = FATAllocatorMeta(file_metadata)
self.fs.clear(file_metadata)
elif self.fs_type == 'NTFS':
for file_entry in self.metadata.get_files():
file_metadata = file_entry['metadata']
file_metadata = NTFSAllocatorMeta(file_metadata)
self.fs.clear(file_metadata)
else:
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean():\n clean_files()",
"def clean_files(self):\n self.filenames.clear()",
"def clear(self):\n\n Console.info(\"Cleaning sprite files...\")\n Console.indent()\n \n for dirPath, dirNames, fileNames in os.walk(self.base):\n for fileName in fileNames:\n ... | [
"0.74671215",
"0.7415675",
"0.6979348",
"0.6971708",
"0.6971565",
"0.689763",
"0.68770945",
"0.6817018",
"0.6782567",
"0.67809623",
"0.6693809",
"0.666803",
"0.666092",
"0.6653605",
"0.6635497",
"0.66262114",
"0.6615348",
"0.66098607",
"0.6608693",
"0.65980065",
"0.6585141",
... | 0.74563277 | 1 |
Returns the unit vector of the vector. | def unit_vector(vector):
vector = np.array(vector)
if np.linalg.norm(vector) <= 0.00010:
normv = 1.0
else:
normv = np.linalg.norm(vector)
return vector / normv | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unit_vector(vector):\n #print 'unit_vector'\n #print vector\n #print type(vector)\n #npvector = np.array(vector)\n return vector / np.linalg.norm(vector)",
"def _get_unit_vector(self, v):\n return v / np.linalg.norm(v)",
"def get_unit_vector(self, vector):\n return vector / la.... | [
"0.8355314",
"0.8344175",
"0.83402044",
"0.83041203",
"0.8288785",
"0.82710177",
"0.8263843",
"0.8237869",
"0.8219826",
"0.8203201",
"0.8180198",
"0.8180198",
"0.8180198",
"0.8157419",
"0.8116172",
"0.8116172",
"0.8116172",
"0.8116172",
"0.8116172",
"0.8116172",
"0.8116172",
... | 0.7595422 | 37 |
ClairpbVulnerability a model defined in OpenAPI | def __init__(self, name=None, namespace_name=None, description=None, link=None, severity=None, metadata=None, fixed_by=None, affected_versions=None): # noqa: E501 # noqa: E501
self._name = None
self._namespace_name = None
self._description = None
self._link = None
self._severity = None
self._metadata = None
self._fixed_by = None
self._affected_versions = None
self.discriminator = None
if name is not None:
self.name = name
if namespace_name is not None:
self.namespace_name = namespace_name
if description is not None:
self.description = description
if link is not None:
self.link = link
if severity is not None:
self.severity = severity
if metadata is not None:
self.metadata = metadata
if fixed_by is not None:
self.fixed_by = fixed_by
if affected_versions is not None:
self.affected_versions = affected_versions | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vulnerabilities(self) -> api.Vulnerabilities:\n return self._get_model(model=api.Vulnerabilities)",
"def opt_model_create_rest_api():\n request_json = request.get_json()\n OptimModelRequestAPI(request_json).validate()\n return create_model_data(request_json)",
"def __init__(self):\n ... | [
"0.54777217",
"0.539541",
"0.538349",
"0.53488857",
"0.53337604",
"0.53252006",
"0.5288814",
"0.5252521",
"0.5168391",
"0.516711",
"0.51452863",
"0.51452863",
"0.51452863",
"0.51452863",
"0.51452863",
"0.5060443",
"0.5005577",
"0.5000991",
"0.50000215",
"0.49836135",
"0.49804... | 0.0 | -1 |
Sets the name of this ClairpbVulnerability. | def name(self, name):
self._name = name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_name(self, name):\n self.name = name # overwrite the existing name with the input name",
"def set_name(self, name):\n self.name = name # overwrite the existing name with the input name",
"def set_name(self, name):\n self.name = name",
"def set_name(self, name):\n self.na... | [
"0.7476369",
"0.7476369",
"0.74305564",
"0.74305564",
"0.74305564",
"0.74305564",
"0.74305564",
"0.7423173",
"0.73924625",
"0.73535186",
"0.73535186",
"0.73509634",
"0.7336383",
"0.7328558",
"0.7323258",
"0.73170054",
"0.71923685",
"0.71672845",
"0.71672845",
"0.71484566",
"0... | 0.0 | -1 |
Sets the namespace_name of this ClairpbVulnerability. | def namespace_name(self, namespace_name):
self._namespace_name = namespace_name | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_namespace(self, namespace: str) -> None:\n self._namespace = namespace",
"def namespace(self, namespace: str):\n\n self._namespace = namespace",
"def namespace(self, namespace):\n\n self._namespace = namespace",
"def namespace(self, namespace):\n\n self._namespace = namesp... | [
"0.7218368",
"0.6848428",
"0.6652187",
"0.6652187",
"0.6394273",
"0.61235774",
"0.60623956",
"0.59424466",
"0.5783313",
"0.57451713",
"0.57072073",
"0.56936276",
"0.56725025",
"0.5653841",
"0.5579495",
"0.55766636",
"0.55388397",
"0.5538237",
"0.5520687",
"0.55004734",
"0.539... | 0.7917395 | 0 |
Sets the description of this ClairpbVulnerability. | def description(self, description):
self._description = description | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_description(self, description):\r\n self.__description = description",
"def set_description(self, description):\n self.description = description",
"def set_description(self, description):\n self.__description = description",
"def description(self, description):\n self._des... | [
"0.72097325",
"0.7180765",
"0.7136288",
"0.7065354",
"0.7065354",
"0.7065354",
"0.7065354",
"0.7059732",
"0.70556676",
"0.7041413",
"0.6891786",
"0.6891786",
"0.6891786",
"0.6891786",
"0.68883944",
"0.68043464",
"0.670095",
"0.66983426",
"0.6676779",
"0.6659177",
"0.6595515",... | 0.69659215 | 38 |
Sets the link of this ClairpbVulnerability. | def link(self, link):
self._link = link | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def link(self, link):\n\n self._set_field(\"link\", link)",
"def link(self, link):\n\n self.container['link'] = link",
"def href(self, href):\n\n self._href = href",
"def href(self, href):\n\n self._href = href",
"def href(self, href):\n\n self._href = href",
"def href(... | [
"0.7018405",
"0.6961583",
"0.6805548",
"0.6805548",
"0.6805548",
"0.6805548",
"0.6280648",
"0.62231255",
"0.6152556",
"0.61381596",
"0.6075746",
"0.597047",
"0.59602845",
"0.5926421",
"0.59064543",
"0.58775926",
"0.5876989",
"0.5859482",
"0.58415675",
"0.5837184",
"0.58210844... | 0.71737444 | 6 |
Sets the severity of this ClairpbVulnerability. | def severity(self, severity):
self._severity = severity | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def severity(self, severity):\n self._severity = severity",
"def severity(self, severity):\n if severity is None:\n raise ValueError(\"Invalid value for `severity`, must not be `None`\") # noqa: E501\n\n self._severity = severity",
"def severity(self, severity):\n if sev... | [
"0.77666795",
"0.738541",
"0.73160356",
"0.7266142",
"0.62618464",
"0.6216128",
"0.59445876",
"0.59445876",
"0.59445876",
"0.5885588",
"0.5885588",
"0.5885588",
"0.58778495",
"0.58508825",
"0.58508825",
"0.562879",
"0.5625883",
"0.55735195",
"0.55235606",
"0.55169725",
"0.550... | 0.776778 | 0 |
Sets the metadata of this ClairpbVulnerability. | def metadata(self, metadata):
self._metadata = metadata | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_metadata(self, data):\r\n pass",
"def set_metadata(self, attribute, value):\n self.metadata[attribute] = value",
"def set_metadata(self, metadata):\n self.metadata = metadata\n return self",
"def set_metadata(self, loadbalancer, metadata):\n return loadbalancer.set_... | [
"0.7049014",
"0.6655038",
"0.65871096",
"0.63758785",
"0.63146836",
"0.63146836",
"0.62831694",
"0.6266832",
"0.6266832",
"0.6024687",
"0.59310377",
"0.59303904",
"0.59018284",
"0.58468807",
"0.5824315",
"0.58013225",
"0.57796216",
"0.5759306",
"0.5752463",
"0.57415015",
"0.5... | 0.6576822 | 7 |
Sets the fixed_by of this ClairpbVulnerability. | def fixed_by(self, fixed_by):
self._fixed_by = fixed_by | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fixed_amount(self, fixed_amount):\n\n self._fixed_amount = fixed_amount",
"def fixed_amount(self, fixed_amount):\n\n self._fixed_amount = fixed_amount",
"def issued_by(self, issued_by):\n\n self._issued_by = issued_by",
"def mitigated_by(self, mitigated_by):\n\n self._mitigate... | [
"0.6088768",
"0.6088768",
"0.60354835",
"0.594974",
"0.56890184",
"0.5542011",
"0.5290293",
"0.5184325",
"0.5179588",
"0.51558876",
"0.51558876",
"0.51558876",
"0.51558876",
"0.51558876",
"0.51558876",
"0.5038125",
"0.4941069",
"0.49050403",
"0.479892",
"0.47826055",
"0.47764... | 0.8097117 | 0 |
Sets the affected_versions of this ClairpbVulnerability. | def affected_versions(self, affected_versions):
self._affected_versions = affected_versions | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vulnerabilities(self, vulnerabilities):\n\n self._vulnerabilities = vulnerabilities",
"def vulnerabilities(self, vulnerabilities):\n\n self._vulnerabilities = vulnerabilities",
"def versions(self, versions):\n\n self._versions = versions",
"def set_versions(self, consumer, versions):... | [
"0.609255",
"0.609255",
"0.59750617",
"0.5626721",
"0.54159355",
"0.51944435",
"0.51533484",
"0.5120908",
"0.50574327",
"0.50420326",
"0.50411284",
"0.50248915",
"0.48979875",
"0.4828377",
"0.48191965",
"0.4787847",
"0.46811602",
"0.4634885",
"0.46162087",
"0.4607605",
"0.460... | 0.8137943 | 0 |
Returns the model properties as a dict | def to_dict(self):
result = {}
for attr, _ in six.iteritems(self.openapi_types):
value = getattr(self, attr)
if isinstance(value, list):
result[attr] = list(map(
lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
value
))
elif hasattr(value, "to_dict"):
result[attr] = value.to_dict()
elif isinstance(value, dict):
result[attr] = dict(map(
lambda item: (item[0], item[1].to_dict())
if hasattr(item[1], "to_dict") else item,
value.items()
))
else:
result[attr] = value
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_dict(self):\n return self.properties",
"def to_dict(self):\n return self.properties",
"def get_properties(self):\n return self.properties",
"def asdict(self):\n return self._prop_dict",
"def json(self):\n rv = {\n prop: getattr(self, prop)\n f... | [
"0.7751993",
"0.7751993",
"0.73391134",
"0.7334895",
"0.7297356",
"0.727818",
"0.7159078",
"0.71578115",
"0.71494967",
"0.71494967",
"0.71283495",
"0.71275014",
"0.7122587",
"0.71079814",
"0.7060394",
"0.7043251",
"0.7034103",
"0.70233124",
"0.69635814",
"0.69586295",
"0.6900... | 0.0 | -1 |
Returns the string representation of the model | def to_str(self):
return pprint.pformat(self.to_dict()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n return super().__str__() + self.model.__str__()",
"def __str__(self) -> str:\n # noinspection PyUnresolvedReferences\n opts = self._meta\n if self.name_field:\n result = str(opts.get_field(self.name_field).value_from_object(self))\n else:\n ... | [
"0.85856134",
"0.7814518",
"0.77898884",
"0.7751367",
"0.7751367",
"0.7712228",
"0.76981676",
"0.76700574",
"0.7651133",
"0.7597206",
"0.75800353",
"0.7568254",
"0.7538184",
"0.75228703",
"0.7515832",
"0.7498764",
"0.74850684",
"0.74850684",
"0.7467648",
"0.74488163",
"0.7442... | 0.0 | -1 |
For `print` and `pprint` | def __repr__(self):
return self.to_str() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pprint(*args, **kwargs):\n if PRINTING:\n print(*args, **kwargs)",
"def print_out():\n pass",
"def custom_print(*objects):\n print(*objects, sep=OFS, end=ORS)",
"def _print(self, *args):\n return _ida_hexrays.vd_printer_t__print(self, *args)",
"def _printable(self):\n ... | [
"0.75577617",
"0.73375154",
"0.6986672",
"0.698475",
"0.6944995",
"0.692333",
"0.6899106",
"0.6898902",
"0.68146646",
"0.6806209",
"0.6753795",
"0.67497987",
"0.6744008",
"0.6700308",
"0.6691256",
"0.6674591",
"0.6658083",
"0.66091245",
"0.6606931",
"0.6601862",
"0.6563738",
... | 0.0 | -1 |
Returns true if both objects are equal | def __eq__(self, other):
if not isinstance(other, ClairpbVulnerability):
return False
return self.__dict__ == other.__dict__ | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __eq__(self, other):\n return are_equal(self, other)",
"def __eq__(self, other):\n return are_equal(self, other)",
"def __eq__(self,other):\n try: return self.object==other.object and isinstance(self,type(other))\n except: return False",
"def __eq__(self, other):\n if i... | [
"0.8088132",
"0.8088132",
"0.8054589",
"0.7982687",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
"0.79670393",
... | 0.0 | -1 |
Returns true if both objects are not equal | def __ne__(self, other):
return not self == other | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __ne__(self, other: object) -> bool:\n if self.__eq__(other):\n return False\n return True",
"def __ne__(self, other: object) -> bool:\n return not self.__eq__(other)",
"def __ne__(self, other) -> bool:\n return not self.__eq__(other)",
"def __eq__(self, other):\n ... | [
"0.845611",
"0.8391477",
"0.8144138",
"0.81410587",
"0.8132492",
"0.8093973",
"0.80920255",
"0.80920255",
"0.80920255",
"0.8085325",
"0.8085325",
"0.8076365",
"0.8076365",
"0.8065748"
] | 0.0 | -1 |
Calculates the output size of the last conv layer. | def _get_conv_out(self, shape) -> int:
conv_out = self.conv(torch.zeros(1, *shape))
return int(np.prod(conv_out.size())) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def output_size(self) -> int:\n return self.output_dim",
"def get_output_shape(self):\n weights = self.W.get_shape().as_list()\n input_size = np.asarray(self.incoming_shape[-3:-1])\n strides = np.asarray(self.strides[-3:-1])\n kernels = np.asarray(weights[0:2])\n num_out... | [
"0.72758055",
"0.7067759",
"0.70510364",
"0.7000888",
"0.68895096",
"0.6863038",
"0.6814944",
"0.68022835",
"0.67512447",
"0.67106795",
"0.6696877",
"0.6696877",
"0.66832334",
"0.66832334",
"0.6663041",
"0.6635598",
"0.6611119",
"0.6571467",
"0.6549242",
"0.65476173",
"0.6491... | 0.6925207 | 4 |
Forward pass through network. | def forward(self, input_x) -> Tensor:
conv_out = self.conv(input_x).view(input_x.size()[0], -1)
return self.head(conv_out) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self):\n pass",
"def forward(self):\n pass",
"def forward(self, input):\n\n return self.network(input)",
"def forward(self, input):\n\n return self.network(input)",
"def forward(self, input):\n\n return self.network(input)",
"def forward_pass(self):",
"def... | [
"0.7486405",
"0.7486405",
"0.72931826",
"0.72931826",
"0.72931826",
"0.72568643",
"0.71754724",
"0.70931304",
"0.70689535",
"0.7054133",
"0.69913656",
"0.6969786",
"0.69356275",
"0.69356275",
"0.69356275",
"0.6921335",
"0.6920985",
"0.6747466",
"0.6711534",
"0.67010707",
"0.6... | 0.0 | -1 |
Forward pass through network. | def forward(self, input_x):
return self.net(input_x.float()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self):\n pass",
"def forward(self):\n pass",
"def forward(self, input):\n\n return self.network(input)",
"def forward(self, input):\n\n return self.network(input)",
"def forward(self, input):\n\n return self.network(input)",
"def forward_pass(self):",
"def... | [
"0.7486405",
"0.7486405",
"0.72931826",
"0.72931826",
"0.72931826",
"0.72568643",
"0.71754724",
"0.70931304",
"0.70689535",
"0.7054133",
"0.69913656",
"0.6969786",
"0.69356275",
"0.69356275",
"0.69356275",
"0.6921335",
"0.6920985",
"0.6747466",
"0.6711534",
"0.67010707",
"0.6... | 0.0 | -1 |
Forward pass through network. Calculates the action distribution. | def forward(self, x: FloatTensor) -> TanhMultivariateNormal:
x = self.shared_net(x.float())
batch_mean = self.mean_layer(x)
logstd = torch.clamp(self.logstd_layer(x), -20, 2)
batch_scale_tril = torch.diag_embed(torch.exp(logstd))
return TanhMultivariateNormal(
action_bias=self.action_bias, action_scale=self.action_scale, loc=batch_mean, scale_tril=batch_scale_tril
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, x):\n x = self.fc0(x.view(-1, x.size(-1))).view(x.size(0), x.size(1), -1)\n x = self.pe(x)\n\n x = self.inner_layers(x) # FF, FF, FF, finalFF\n\n state_value = self.fc_s(x) # double-dqn : state\n\n advantage_values = self.fc_a(x) # double-dqn : advantage\n ... | [
"0.6780671",
"0.6720904",
"0.66573745",
"0.65337664",
"0.6500491",
"0.6433926",
"0.6398824",
"0.63217956",
"0.6288894",
"0.62833714",
"0.62578505",
"0.62466264",
"0.6242794",
"0.62398285",
"0.6232702",
"0.6224309",
"0.6224309",
"0.6190171",
"0.61818534",
"0.61756337",
"0.6167... | 0.0 | -1 |
Get the action greedily (without sampling) | def get_action(self, x: FloatTensor) -> Tensor:
x = self.shared_net(x.float())
batch_mean = self.mean_layer(x)
return self.action_scale * torch.tanh(batch_mean) + self.action_bias | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_action(self, state):\n return self.env.action_space.sample()",
"def choose_random_action(env):\n return env.action_space.sample()",
"def select_action(self, state):\n\t\treturn sample(range(0, self.action_space), 1)[0]",
"def get_action(self, s, eval=False):\n if eval:\n w... | [
"0.7114393",
"0.70404077",
"0.70395607",
"0.6984486",
"0.6971175",
"0.6954252",
"0.6913596",
"0.6889728",
"0.68695825",
"0.6852474",
"0.68420124",
"0.6805876",
"0.6799169",
"0.67951995",
"0.6754626",
"0.6733447",
"0.6733447",
"0.6664213",
"0.664351",
"0.663247",
"0.66250086",... | 0.0 | -1 |
Forward pass through network. Calculates the action logits and the value. | def forward(self, x) -> Tuple[Tensor, Tensor]:
x = F.relu(self.fc1(x.float()))
a = F.log_softmax(self.actor_head(x), dim=-1)
c = self.critic_head(x)
return a, c | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, x):\n # action\n act = self.act_fc1(x)\n act = torch.tanh(act)\n act = self.act_fc2(act)\n act = torch.tanh(act)\n mean = self.mu(act) # N, num_actions\n logstd = self.logstd.expand_as(mean)\n std = torch.exp(logstd)\n action = torch... | [
"0.7648056",
"0.7441679",
"0.7235342",
"0.7074458",
"0.7050156",
"0.69769365",
"0.6912717",
"0.6907993",
"0.69072765",
"0.6904189",
"0.6899755",
"0.6880525",
"0.6867396",
"0.6824801",
"0.6819598",
"0.67802507",
"0.67745304",
"0.6761813",
"0.6747654",
"0.6747654",
"0.67306876"... | 0.6286952 | 67 |
Forward pass through network. Calculates the Q using the value and advantage. | def forward(self, input_x):
adv, val = self.adv_val(input_x)
return val + (adv - adv.mean(dim=1, keepdim=True)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, state):\n x = state\n feature = self.feature_layer(x)\n action_value = self.value_layer(feature)\n advantage = self.advantage_layer(feature)\n \n q_value = action_value + (advantage - advantage.mean(dim=1, keepdim=True))\n return q_value",
"def a... | [
"0.67463326",
"0.6215198",
"0.6126189",
"0.60463625",
"0.6016947",
"0.60107875",
"0.600079",
"0.598151",
"0.5964633",
"0.595709",
"0.5950874",
"0.59488696",
"0.5943859",
"0.5934017",
"0.59093964",
"0.5896094",
"0.58890605",
"0.5857793",
"0.58310497",
"0.58174837",
"0.579977",... | 0.5647406 | 42 |
Gets the advantage and value by passing out of the base network through the value and advantage heads. | def adv_val(self, input_x) -> Tuple[Tensor, Tensor]:
float_x = input_x.float()
base_out = self.net(float_x)
return self.fc_adv(base_out), self.fc_val(base_out) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bias(self):",
"def __get_net_probs(self):\n return np.array([node.value for node in self.net]).reshape(5,5)",
"def net_output(self):\n result = self.gives()\n for k, v in self.needs().items():\n result[k] = result.get(k, 0) - v\n\n return result",
"def forward(self,... | [
"0.5776241",
"0.5750878",
"0.5623462",
"0.54842955",
"0.5386926",
"0.52231693",
"0.52097505",
"0.5197751",
"0.5113644",
"0.5086685",
"0.5073465",
"0.50708735",
"0.5056254",
"0.5033763",
"0.5021825",
"0.5015476",
"0.50106674",
"0.5005514",
"0.4995753",
"0.49826834",
"0.4966393... | 0.5109669 | 9 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.